Fork of midizap that works with djcontrol instinct
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

2143 lines
58 KiB

/*
Copyright 2013 Eric Messick (FixedImagePhoto.com/Contact)
Copyright 2018 Albert Graef <aggraef@gmail.com>
Read and process the configuration file ~/.midizaprc
Lines starting with # are comments.
The file is a sequence of sections defining translation classes. Each
section takes the following form:
[name] regex
CC<0..127> output # control change
PC<0..127> output # program change
PB output # pitch bend
CP output # channel pressure
KP:<A-G>[#b]<-11..11> output # key pressure (aftertouch)
<A-G>[#b]<-11..11> output # note
When focus is on a window whose class or title matches regex, the
following translation class is in effect. An empty regex for the last
class will always match, allowing default translations. Any output
sequences not bound in a matched section will be loaded from the
default section if they are bound there.
Each "[name] regex" line introduces the list of MIDI message
translations for the named translation class. The name is only used
for debugging output, and needn't be unique. The following lines
indicate what output should be produced for the given MIDI messages.
MIDI messages are on channel 1 by default; a suffix of the form
-<1..16> can be used to specify a different MIDI channel. E.g., C3-10
denotes note C3 on MIDI channel 10.
Note messages are specified using the cutomary notation (note name
A..G, optionally followed by an accidental, # or b, followed by a
(zero-based) MIDI octave number. Note that all MIDI octaves start at
the note C, so B0 comes before C1. By default, C5 denotes middle C, A5
is the chamber pitch (usually at 440 Hz). Enharmonic spellings are
equivalent, so, e.g., D# and Eb denote exactly the same MIDI note.
More details on the syntax of MIDI messages can be found in the
comments preceding the parse_midi() routine below.
*/
#include "midizap.h"
int default_debug_regex = 0;
int default_debug_strokes = 0;
int default_debug_keys = 0;
int default_debug_midi = 0;
int debug_regex = 0;
int debug_strokes = 0;
int debug_keys = 0;
int debug_midi = 0;
int midi_octave = 0;
char *jack_client_name, *jack_in_regex[2], *jack_out_regex[2];
char *
allocate(size_t len)
{
char *ret = (char *)calloc(1, len);
if (ret == NULL) {
fprintf(stderr, "out of memory!\n");
exit(1);
}
return ret;
}
char *
alloc_strcat(char *a, char *b)
{
size_t len = 0;
char *result;
if (a != NULL) {
len += strlen(a);
}
if (b != NULL) {
len += strlen(b);
}
result = allocate(len+1);
result[0] = '\0';
if (a != NULL) {
strcpy(result, a);
}
if (b != NULL) {
strcat(result, b);
}
return result;
}
static char *read_line_buffer = NULL;
static int read_line_buffer_length = 0;
#define BUF_GROWTH_STEP 1024
// read a line of text from the given file into a managed buffer.
// returns a partial line at EOF if the file does not end with \n.
// exits with error message on read error.
char *
read_line(FILE *f, char *name)
{
int pos = 0;
char *new_buffer;
int new_buffer_length;
if (read_line_buffer == NULL) {
read_line_buffer_length = BUF_GROWTH_STEP;
read_line_buffer = allocate(read_line_buffer_length);
read_line_buffer[0] = '\0';
}
while (1) {
read_line_buffer[read_line_buffer_length-1] = '\377';
if (fgets(read_line_buffer+pos, read_line_buffer_length-pos, f) == NULL) {
if (feof(f)) {
if (pos > 0) {
// partial line at EOF
return read_line_buffer;
} else {
return NULL;
}
}
perror(name);
exit(1);
}
if (read_line_buffer[read_line_buffer_length-1] != '\0') {
return read_line_buffer;
}
if (read_line_buffer[read_line_buffer_length-2] == '\n') {
return read_line_buffer;
}
new_buffer_length = read_line_buffer_length + BUF_GROWTH_STEP;
new_buffer = allocate(new_buffer_length);
memcpy(new_buffer, read_line_buffer, read_line_buffer_length);
free(read_line_buffer);
pos = read_line_buffer_length-1;
read_line_buffer = new_buffer;
read_line_buffer_length = new_buffer_length;
}
}
static translation *first_translation_section = NULL;
static translation *last_translation_section = NULL;
translation *default_translation, *default_midi_translation[2];
translation *
new_translation_section(char *name, int mode, char *regex)
{
translation *ret = (translation *)allocate(sizeof(translation));
int err;
memset(ret, 0, sizeof(translation));
if (debug_strokes) {
printf("------------------------\n[%s] %s%s\n\n", name,
mode==1?"TITLE ":mode==2?"CLASS ":"",
regex);
}
ret->next = NULL;
ret->name = alloc_strcat(name, NULL);
ret->mode = mode;
if (regex == NULL || *regex == '\0') {
ret->is_default = 1;
if (!strcmp(name, "MIDI"))
default_midi_translation[0] = ret;
else if (!strcmp(name, "MIDI2")) {
default_midi_translation[1] = ret;
ret->portno = 1;
} else
default_translation = ret;
} else {
ret->is_default = 0;
err = regcomp(&ret->regex, regex, REG_EXTENDED|REG_NOSUB);
if (err != 0) {
regerror(err, &ret->regex, read_line_buffer, read_line_buffer_length);
fprintf(stderr, "error compiling regex for [%s]: %s\n", name, read_line_buffer);
regfree(&ret->regex);
free(ret->name);
free(ret);
return NULL;
}
}
if (first_translation_section == NULL) {
first_translation_section = ret;
last_translation_section = ret;
} else {
last_translation_section->next = ret;
last_translation_section = ret;
}
return ret;
}
void
free_strokes(stroke *s)
{
stroke *next;
while (s != NULL) {
next = s->next;
if (s->steps) free(s->steps);
free(s);
s = next;
}
}
static int stroke_data_cmp(const void *a, const void *b)
{
const stroke_data *ad = (const stroke_data*)a;
const stroke_data *bd = (const stroke_data*)b;
if (ad->chan == bd->chan)
return ad->data - bd->data;
else
return ad->chan - bd->chan;
}
static void finish_stroke_data(stroke_data **sd,
uint16_t *n, uint16_t *a)
{
if (*a && *a > *n) {
// realloc to needed size
*sd = realloc(*sd, (*n)*sizeof(stroke_data));
*a = *n;
}
// sort by chan/data for faster access
qsort(*sd, *n, sizeof(stroke_data), stroke_data_cmp);
}
static void free_stroke_data(stroke_data *sd, uint16_t n)
{
uint16_t i;
for (i = 0; i < n; i++) {
free_strokes(sd[i].s[0]);
free_strokes(sd[i].s[1]);
if (sd[i].steps[0]) free(sd[i].steps[0]);
if (sd[i].steps[1]) free(sd[i].steps[1]);
}
free(sd);
}
static int *stepsdup(int n_steps, int *steps)
{
if (n_steps) {
int *ret = malloc(n_steps*sizeof(int));
memcpy(ret, steps, n_steps*sizeof(int));
return ret;
} else
return 0;
}
static stroke **find_stroke_data(stroke_data **sd,
int chan, int data, int index,
int step, int n_steps, int *steps,
int incr, int mod, int anyshift,
uint16_t *n, uint16_t *a)
{
uint16_t i;
for (i = 0; i < *n; i++) {
if ((*sd)[i].chan == chan && (*sd)[i].data == data) {
// existing entry
if ((*sd)[i].s[index]) return 0;
(*sd)[i].step[index] = step;
(*sd)[i].n_steps[index] = n_steps;
(*sd)[i].steps[index] = stepsdup(n_steps, steps);
(*sd)[i].is_incr = incr;
(*sd)[i].mod = mod;
(*sd)[i].anyshift = anyshift;
return &(*sd)[i].s[index];
}
}
// add a new entry
if (*n >= *a) {
// make some room
*a = (*a)?2*(*a):8;
*sd = realloc(*sd, (*a)*sizeof(stroke_data));
}
memset(&(*sd)[*n], 0, sizeof(stroke_data));
(*sd)[*n].chan = chan;
(*sd)[*n].data = data;
(*sd)[*n].step[index] = step;
(*sd)[*n].n_steps[index] = n_steps;
(*sd)[*n].steps[index] = stepsdup(n_steps, steps);
(*sd)[*n].is_incr = incr;
(*sd)[*n].mod = mod;
(*sd)[*n].anyshift = anyshift;
return &(*sd)[(*n)++].s[index];
}
static int check_stroke_data(stroke_data *sd,
int chan, int data,
uint16_t n)
{
uint16_t i;
for (i = 0; i < n; i++) {
if (sd[i].chan == chan && sd[i].data == data)
return 1;
}
return 0;
}
static stroke **find_note(translation *tr, int shift,
int chan, int data, int index, int mod,
int step, int n_steps, int *steps,
int anyshift)
{
if (check_stroke_data(tr->notes[shift], chan, data, tr->n_notes[shift]))
return 0;
else
return find_stroke_data(&tr->note[shift], chan, data, index,
step, n_steps, steps, 0, mod, anyshift,
&tr->n_note[shift], &tr->a_note[shift]);
}
static stroke **find_notes(translation *tr, int shift,
int chan, int data, int index, int step,
int anyshift)
{
if (check_stroke_data(tr->note[shift], chan, data, tr->n_note[shift]))
return 0;
else
return find_stroke_data(&tr->notes[shift], chan, data, index,
step, 0, 0, 0, 0, anyshift,
&tr->n_notes[shift], &tr->a_notes[shift]);
}
static stroke **find_pc(translation *tr, int shift,
int chan, int data, int index,
int anyshift)
{
return find_stroke_data(&tr->pc[shift], chan, data, index,
0, 0, 0, 0, 0, anyshift,
&tr->n_pc[shift], &tr->a_pc[shift]);
}
static stroke **find_cc(translation *tr, int shift,
int chan, int data, int index, int mod,
int step, int n_steps, int *steps,
int anyshift)
{
if (check_stroke_data(tr->ccs[shift], chan, data, tr->n_ccs[shift]))
return 0;
else
return find_stroke_data(&tr->cc[shift], chan, data, index,
step, n_steps, steps, 0, mod, anyshift,
&tr->n_cc[shift], &tr->a_cc[shift]);
}
static stroke **find_ccs(translation *tr, int shift,
int chan, int data, int index, int step, int incr,
int anyshift)
{
if (check_stroke_data(tr->cc[shift], chan, data, tr->n_cc[shift]))
return 0;
else
return find_stroke_data(&tr->ccs[shift], chan, data, index,
step, 0, 0, incr, 0, anyshift,
&tr->n_ccs[shift], &tr->a_ccs[shift]);
}
static stroke **find_kp(translation *tr, int shift,
int chan, int data, int index, int mod,
int step, int n_steps, int *steps,
int anyshift)
{
if (check_stroke_data(tr->kps[shift], chan, data, tr->n_kps[shift]))
return 0;
else
return find_stroke_data(&tr->kp[shift], chan, data, index,
step, n_steps, steps, 0, mod, anyshift,
&tr->n_kp[shift], &tr->a_kp[shift]);
}
static stroke **find_kps(translation *tr, int shift,
int chan, int data, int index, int step,
int anyshift)
{
if (check_stroke_data(tr->kp[shift], chan, data, tr->n_kp[shift]))
return 0;
else
return find_stroke_data(&tr->kps[shift], chan, data, index, step,
0, 0, 0, 0, anyshift,
&tr->n_kps[shift], &tr->a_kps[shift]);
}
static stroke **find_cp(translation *tr, int shift,
int chan, int index, int mod,
int step, int n_steps, int *steps,
int anyshift)
{
if (check_stroke_data(tr->cps[shift], chan, 0, tr->n_cps[shift]))
return 0;
else
return find_stroke_data(&tr->cp[shift], chan, 0, index,
step, n_steps, steps, 0, mod, anyshift,
&tr->n_cp[shift], &tr->a_cp[shift]);
}
static stroke **find_cps(translation *tr, int shift,
int chan, int index, int step,
int anyshift)
{
if (check_stroke_data(tr->cp[shift], chan, 0, tr->n_cp[shift]))
return 0;
else
return find_stroke_data(&tr->cps[shift], chan, 0, index, step,
0, 0, 0, 0, anyshift,
&tr->n_cps[shift], &tr->a_cps[shift]);
}
static stroke **find_pb(translation *tr, int shift,
int chan, int index, int mod,
int step, int n_steps, int *steps,
int anyshift)
{
if (check_stroke_data(tr->pbs[shift], chan, 0, tr->n_pbs[shift]))
return 0;
else
return find_stroke_data(&tr->pb[shift], chan, 0, index,
step, n_steps, steps, 0, mod, anyshift,
&tr->n_pb[shift], &tr->a_pb[shift]);
}
static stroke **find_pbs(translation *tr, int shift,
int chan, int index, int step,
int anyshift)
{
if (check_stroke_data(tr->pb[shift], chan, 0, tr->n_pb[shift]))
return 0;
else
return find_stroke_data(&tr->pbs[shift], chan, 0, index, step,
0, 0, 0, 0, anyshift,
&tr->n_pbs[shift], &tr->a_pbs[shift]);
}
static void dup_stroke_data(stroke_data **sd, uint16_t *n, uint16_t *a,
stroke_data *sd0, uint16_t n0,
stroke_data *sd1, uint16_t n1);
void
finish_translation_section(translation *tr)
{
int k;
if (tr) {
for (k=1; k<N_SHIFTS+1; k++) {
dup_stroke_data(&tr->pc[k], &tr->n_pc[k], &tr->a_pc[k],
0, 0,
tr->pc[0], tr->n_pc[0]);
dup_stroke_data(&tr->note[k], &tr->n_note[k], &tr->a_note[k],
tr->notes[k], tr->n_notes[k],
tr->note[0], tr->n_note[0]);
dup_stroke_data(&tr->notes[k], &tr->n_notes[k], &tr->a_notes[k],
tr->note[k], tr->n_note[k],
tr->notes[0], tr->n_notes[0]);
dup_stroke_data(&tr->cc[k], &tr->n_cc[k], &tr->a_cc[k],
tr->ccs[k], tr->n_ccs[k],
tr->cc[0], tr->n_cc[0]);
dup_stroke_data(&tr->ccs[k], &tr->n_ccs[k], &tr->a_ccs[k],
tr->cc[k], tr->n_cc[k],
tr->ccs[0], tr->n_ccs[0]);
dup_stroke_data(&tr->pb[k], &tr->n_pb[k], &tr->a_pb[k],
tr->pbs[k], tr->n_pbs[k],
tr->pb[0], tr->n_pb[0]);
dup_stroke_data(&tr->pbs[k], &tr->n_pbs[k], &tr->a_pbs[k],
tr->pb[k], tr->n_pb[k],
tr->pbs[0], tr->n_pbs[0]);
dup_stroke_data(&tr->kp[k], &tr->n_kp[k], &tr->a_kp[k],
tr->kps[k], tr->n_kps[k],
tr->kp[0], tr->n_kp[0]);
dup_stroke_data(&tr->kps[k], &tr->n_kps[k], &tr->a_kps[k],
tr->kp[k], tr->n_kp[k],
tr->kps[0], tr->n_kps[0]);
dup_stroke_data(&tr->cp[k], &tr->n_cp[k], &tr->a_cp[k],
tr->cps[k], tr->n_cps[k],
tr->cp[0], tr->n_cp[0]);
dup_stroke_data(&tr->cps[k], &tr->n_cps[k], &tr->a_cps[k],
tr->cp[k], tr->n_cp[k],
tr->cps[0], tr->n_cps[0]);
}
for (k=0; k<N_SHIFTS+1; k++) {
finish_stroke_data(&tr->pc[k], &tr->n_pc[k], &tr->a_pc[k]);
finish_stroke_data(&tr->note[k], &tr->n_note[k], &tr->a_note[k]);
finish_stroke_data(&tr->notes[k], &tr->n_notes[k], &tr->a_notes[k]);
finish_stroke_data(&tr->cc[k], &tr->n_cc[k], &tr->a_cc[k]);
finish_stroke_data(&tr->ccs[k], &tr->n_ccs[k], &tr->a_ccs[k]);
finish_stroke_data(&tr->pb[k], &tr->n_pb[k], &tr->a_pb[k]);
finish_stroke_data(&tr->pbs[k], &tr->n_pbs[k], &tr->a_pbs[k]);
finish_stroke_data(&tr->kp[k], &tr->n_kp[k], &tr->a_kp[k]);
finish_stroke_data(&tr->kps[k], &tr->n_kps[k], &tr->a_kps[k]);
finish_stroke_data(&tr->cp[k], &tr->n_cp[k], &tr->a_cp[k]);
finish_stroke_data(&tr->cps[k], &tr->n_cps[k], &tr->a_cps[k]);
}
}
}
void
free_translation_section(translation *tr)
{
int k;
if (tr != NULL) {
free(tr->name);
if (!tr->is_default) {
regfree(&tr->regex);
}
for (k=0; k<N_SHIFTS+1; k++) {
free_stroke_data(tr->pc[k], tr->n_pc[k]);
free_stroke_data(tr->note[k], tr->n_note[k]);
free_stroke_data(tr->cc[k], tr->n_cc[k]);
free_stroke_data(tr->ccs[k], tr->n_ccs[k]);
free_stroke_data(tr->pb[k], tr->n_pb[k]);
free_stroke_data(tr->pbs[k], tr->n_pbs[k]);
}
free(tr);
}
}
void
free_all_translations(void)
{
translation *tr = first_translation_section;
translation *next;
while (tr != NULL) {
next = tr->next;
free_translation_section(tr);
tr = next;
}
first_translation_section = NULL;
last_translation_section = NULL;
default_translation = default_midi_translation[0] =
default_midi_translation[1] = NULL;
}
char *config_file_name = NULL;
static time_t config_file_modification_time;
static char *token_src = NULL;
// similar to strtok, but it tells us what delimiter was found at the
// end of the token, handles double quoted strings specially, and
// hardcodes the delimiter set.
char *
token(char *src, char *delim_found)
{
char *delims = " \t\n/\"";
char *d;
char *token_start;
if (src == NULL) {
src = token_src;
}
if (src == NULL) {
*delim_found = '\0';
return NULL;
}
token_start = src;
while (*src) {
d = delims;
while (*d && *src != *d) {
d++;
}
if (*d) {
if (src == token_start) {
src++;
token_start = src;
if (*d == '"') {
while (*src && *src != '"' && *src != '\n') {
src++;
}
} else {
continue;
}
}
*delim_found = *d;
if (*src) {
*src = '\0';
token_src = src+1;
} else {
token_src = NULL;
}
return token_start;
}
src++;
}
token_src = NULL;
*delim_found = '\0';
if (src == token_start) {
return NULL;
}
return token_start;
}
typedef struct _keysymmapping {
char *str;
KeySym sym;
} keysymmapping;
static keysymmapping key_sym_mapping[] = {
#include "keys.h"
{ "XK_Button_1", XK_Button_1 },
{ "XK_Button_2", XK_Button_2 },
{ "XK_Button_3", XK_Button_3 },
{ "XK_Scroll_Up", XK_Scroll_Up },
{ "XK_Scroll_Down", XK_Scroll_Down },
{ NULL, 0 }
};
KeySym
string_to_KeySym(char *str)
{
size_t len = strlen(str) + 1;
int i = 0;
while (key_sym_mapping[i].str != NULL) {
if (!strncmp(str, key_sym_mapping[i].str, len)) {
return key_sym_mapping[i].sym;
}
i++;
}
return 0;
}
char *
KeySym_to_string(KeySym ks)
{
int i = 0;
while (key_sym_mapping[i].sym != 0) {
if (key_sym_mapping[i].sym == ks) {
return key_sym_mapping[i].str;
}
i++;
}
return NULL;
}
static char *note_name(int n)
{
static char *note_names[] = { "C", "C#", "D", "Eb", "E", "F", "F#", "G", "G#", "A", "Bb", "B" };
if (n < 0 && n%12)
return note_names[12+n%12];
else
return note_names[n%12];
}
static int note_octave(int n)
{
if (n < 0 && n%12)
return n/12-1 + midi_octave;
else
return n/12 + midi_octave;
}
static int datavals(int val, int step, int *steps, int n_steps)
{
if (val < 0)
return -datavals(-val, step, steps, n_steps);
else if (val < n_steps)
return steps[val];
else if (n_steps)
return steps[n_steps-1];
else if (step)
return step*val;
else
return val;
}
void
print_stroke(stroke *s, int mod, int step, int n_steps, int *steps, int val)
{
char *str;
if (s != NULL) {
if (s->keysym) {
str = KeySym_to_string(s->keysym);
if (str == NULL) {
printf("0x%x", (int)s->keysym);
str = "???";
}
printf("%s/%c ", str, s->press ? 'D' : 'U');
} else if (s->shift) {
printf("SHIFT%d ", s->shift);
} else if (!s->status) {
printf("NOP ");
} else {
int status = s->status & 0xf0;
int channel = (s->status & 0x0f) + 1;
char suffix[3] = "";
if (s->incr) strcpy(suffix, "~");
if (s->swap) strcat(suffix, "'");
if (s->change) strcat(suffix, "?");
if (s->recursive) printf("$");
if (s->feedback) printf(s->feedback==2?"^":"!");
switch (status) {
case 0x90:
if (mod) {
int q = s->swap?val%mod:val/mod, r = s->swap?val/mod:val%mod;
int d = s->data + datavals(q, step, steps, n_steps);
int v = datavals(r, s->step, s->steps, s->n_steps);
printf("%s%d[%d]-%d%s ", note_name(d),
note_octave(d), v, channel, suffix);
} else if (s->steps) {
printf("%s%d{", note_name(s->data),
note_octave(s->data));
for (int i = 0; i < s->n_steps; i++)
printf("%s%d", i?",":"", s->steps[i]);
printf("}-%d%s ", channel, suffix);
} else if (s->step)
printf("%s%d[%d]-%d%s ", note_name(s->data),
note_octave(s->data), s->step, channel, suffix);
else
printf("%s%d-%d%s ", note_name(s->data),
note_octave(s->data), channel, suffix);
break;
case 0xa0:
if (mod) {
int q = s->swap?val%mod:val/mod, r = s->swap?val/mod:val%mod;
int d = s->data + datavals(q, step, steps, n_steps);
int v = datavals(r, s->step, s->steps, s->n_steps);
printf("KP:%s%d[%d]-%d%s ", note_name(d),
note_octave(d), v, channel, suffix);
} else if (s->steps) {
printf("KP:%s%d{", note_name(s->data),
note_octave(s->data));
for (int i = 0; i < s->n_steps; i++)
printf("%s%d", i?",":"", s->steps[i]);
printf("}-%d%s ", channel, suffix);
} else if (s->step)
printf("KP:%s%d[%d]-%d%s ", note_name(s->data),
note_octave(s->data), s->step, channel, suffix);
else
printf("KP:%s%d-%d%s ", note_name(s->data),
note_octave(s->data), channel, suffix);
break;
case 0xb0: {
// check for pseudo CC messages denoting a macro
int data = s->data;
char *tok = data>=128?"M":"CC";
data %= 128;
if (mod) {
int q = s->swap?val%mod:val/mod, r = s->swap?val/mod:val%mod;
int d = data + datavals(q, step, steps, n_steps);
int v = datavals(r, s->step, s->steps, s->n_steps);
printf("%s%d[%d]-%d%s ", tok, d, v, channel, suffix);
} else if (s->steps) {
printf("%s%d{", tok, data);
for (int i = 0; i < s->n_steps; i++)
printf("%s%d", i?",":"", s->steps[i]);
printf("}-%d%s ", channel, suffix);
} else if (s->step)
printf("%s%d[%d]-%d%s ", tok, data, s->step, channel, suffix);
else
printf("%s%d-%d%s ", tok, data, channel, suffix);
break;
}
case 0xc0:
if (mod) {
int v = datavals(s->swap?val%mod:val/mod, s->step, s->steps, s->n_steps);
printf("PC%d-%d%s ", v, channel, suffix);
} else
printf("PC%d-%d%s ", s->data, channel, suffix);
break;
case 0xd0:
if (mod) {
int v = datavals(s->swap?val/mod:val%mod, s->step, s->steps, s->n_steps);
printf("CP[%d]-%d%s ", v, channel, suffix);
} else if (s->steps) {
printf("CP{");
for (int i = 0; i < s->n_steps; i++)
printf("%s%d", i?",":"", s->steps[i]);
printf("}-%d%s ", channel, suffix);
} else if (s->step)
printf("CP[%d]-%d%s ", s->step, channel, suffix);
else
printf("CP-%d%s ", channel, suffix);
break;
case 0xe0:
if (mod) {
int v = datavals(s->swap?val/mod:val%mod, s->step, s->steps, s->n_steps);
printf("PB[%d]-%d%s ", v-8192, channel, suffix);
} else if (s->steps) {
printf("PB{");
for (int i = 0; i < s->n_steps; i++)
printf("%s%d", i?",":"", s->steps[i]);
printf("}-%d%s ", channel, suffix);
} else if (s->step)
printf("PB[%d]-%d%s ", s->step, channel, suffix);
else
printf("PB-%d%s ", channel, suffix);
break;
default: // this can't happen
break;
}
}
}
}
void
print_stroke_sequence(char *name, char *up_or_down, stroke *s,
int mod, int step, int n_steps, int *steps,
int val)
{
if (up_or_down && *up_or_down)
printf("%s[%s]: ", name, up_or_down);
else
printf("%s: ", name);
while (s) {
print_stroke(s, mod, step, n_steps, steps, val);
s = s->next;
}
printf("\n");
}
stroke **first_stroke;
stroke *last_stroke;
stroke **press_first_stroke;
stroke **release_first_stroke;
int is_keystroke, is_bidirectional, is_nop, midi_release, explicit_release;
int mode;
char *current_translation;
char *key_name;
int first_release_stroke; // is this the first stroke of a release?
KeySym regular_key_down;
#define NUM_MODIFIERS 64
stroke modifiers_down[NUM_MODIFIERS];
int modifier_count;
int midi_channel;
void
append_stroke(KeySym sym, int press)
{
stroke *s = (stroke *)allocate(sizeof(stroke));
memset(s, 0, sizeof(stroke));
s->keysym = sym;
s->press = press;
if (*first_stroke) {
last_stroke->next = s;
} else {
*first_stroke = s;
}
last_stroke = s;
}
void
append_shift(int shift)
{
stroke *s = (stroke *)allocate(sizeof(stroke));
memset(s, 0, sizeof(stroke));
s->shift = shift;
if (*first_stroke) {
last_stroke->next = s;
} else {
*first_stroke = s;
}
last_stroke = s;
}
void
append_nop(void)
{
stroke *s = (stroke *)allocate(sizeof(stroke));
memset(s, 0, sizeof(stroke));
if (*first_stroke) {
last_stroke->next = s;
} else {
*first_stroke = s;
}
last_stroke = s;
is_nop = is_keystroke;
}
void
append_midi(int status, int data, int step, int n_steps, int *steps,
int swap, int change, int incr, int recursive, int feedback)
{
stroke *s = (stroke *)allocate(sizeof(stroke));
memset(s, 0, sizeof(stroke));
s->status = status;
s->data = data;
s->swap = swap;
s->change = change;
s->step = step;
s->n_steps = n_steps;
s->steps = stepsdup(n_steps, steps);
s->incr = incr;
s->recursive = recursive;
s->feedback = feedback;
// if this is a keystroke event, for all messages but program change (which
// has no "on" and "off" states), mark the event as "dirty" so that the
// corresponding "off" event gets added later to the "release" strokes
s->dirty = is_keystroke && ((status&0xf0) != 0xc0);
if (*first_stroke) {
last_stroke->next = s;
} else {
*first_stroke = s;
}
last_stroke = s;
midi_release = 1;
}
// s->press values in modifiers_down:
// PRESS -> down
// HOLD -> held
// PRESS_RELEASE -> released, but to be re-pressed if necessary
// RELEASE -> up
void
mark_as_down(KeySym sym, int hold)
{
int i;
for (i=0; i<modifier_count; i++) {
if (modifiers_down[i].keysym == sym) {
modifiers_down[i].press = hold ? HOLD : PRESS;
return;
}
}
if (modifier_count > NUM_MODIFIERS) {
fprintf(stderr, "too many modifiers down in [%s]%s\n", current_translation, key_name);
return;
}
modifiers_down[modifier_count].keysym = sym;
modifiers_down[modifier_count].press = hold ? HOLD : PRESS;
modifier_count++;
}
void
mark_as_up(KeySym sym)
{
int i;
for (i=0; i<modifier_count; i++) {
if (modifiers_down[i].keysym == sym) {
modifiers_down[i].press = RELEASE;
return;
}
}
}
void
release_modifiers(int allkeys)
{
int i;
for (i=0; i<modifier_count; i++) {
if (modifiers_down[i].press == PRESS) {
append_stroke(modifiers_down[i].keysym, 0);
modifiers_down[i].press = PRESS_RELEASE;
} else if (allkeys && modifiers_down[i].press == HOLD) {
append_stroke(modifiers_down[i].keysym, 0);
modifiers_down[i].press = RELEASE;
}
}
}
void
re_press_temp_modifiers(void)
{
int i;
for (i=0; i<modifier_count; i++) {
if (modifiers_down[i].press == PRESS_RELEASE) {
append_stroke(modifiers_down[i].keysym, 1);
modifiers_down[i].press = PRESS;
}
}
}
/* Parser for the MIDI message syntax. The same parser is used for both
the left-hand side (lhs) and the right-hand side (rhs) of a translation.
The syntax we actually parse here is the following:
tok ::= msg [ number ] [ steps ] [ "-" number] [ flag ]
msg ::= note | other
note ::= ( "a" | ... | "g" ) [ "#" | "b" ]
other ::= "ch" | "pb" | "pc" | "cc" | "cp" | "kp:" note
steps ::= [ "[" [ number ] "]" ] [ "{" list "}" ]
list ::= number { "," number | ":" number | "-" number }
flag ::= "-" | "+" | "=" | "<" | ">" | "~" | "'"
Case is insignificant. Numbers are always in decimal. The meaning of
the first number depends on the context (octave number for notes and
key pressure, the actual data byte for other messages). This can
optionally be followed by a number in brackets, denoting a step size,
or (in some translations) a list of values in curly braces. Also
optionally, the suffix with the third number (after the dash) denotes
the MIDI channel; otherwise the default MIDI channel is used.
Note that not all combinations are possible -- "pb" and "cp" have no
data byte, "pc" no step size and flag; and "ch" must *not* occur on
the lhs at all, and is followed by just a channel number. (In fact,
"ch" is no real MIDI message at all; it just sets the default MIDI
channel for subsequent messages in the output sequence.)
The optional flag at the end of the token indicates an "incremental"
controller or pitch bend value which responds to up ("+") and down
("-") changes; it is only permitted (with one exception, see below)
on the lhs of a translation. In addition, "<" and ">" can be used in
lieu of "-" and "-" to indicate a relative controller in "sign bit"
representation, where controller values > 64 denote down, and values
< 64 up changes. This notation is only permitted with "cc". It is
used for endless rotary encoders, jog wheels and the like, as can be
found, e.g., on Mackie-like units.
The flags "=" and "~" are used in lieu of "+"/"-" or "<"/">",
respectively, to denote a "bidirectional" translation which applies
to both positive and negative changes of the parameter value. Since
bidirectional translations cannot have distinct keystroke sequences
for up and down changes associated with them, this makes most sense
with pure MIDI translations.
Among these, only the "~" flag is also permitted on the rhs of a
translation, and only with "cc", where it is used to denote a
relative (sign bit) controller change on output.
Finally, the special "transposition" flag "'" is used in so-called
"mod" translations where it swaps offset and data value; please check
the documentation for details. */
static int note_number(char c, char b, int k)
{
c = tolower(c); b = tolower(b);
if (c < 'a' || c > 'g' || (b && b != '#' && b != 'b'))
return -1; // either wrong note name or invalid accidental
else {
static int note_numbers[] = { -3, -1, 0, 2, 4, 5, 7 };
int m = note_numbers[c-'a'], a = (b=='#')?1:(b=='b')?-1:0;
if (m<0) k++;
return m + a + 12*k;
}
}
#define MAXSTEPS 16384
static char *parse_steps(char *tok, char *p,
int *step, int *n_steps, int **steps)
{
int l, n;
char c = *p++, d = c=='[' ? ']' : '}';
if (sscanf(p, "%d%n", &l, &n) == 1) {
p += n;
if (c == '{') {
int n_st = 1;
static int st[MAXSTEPS];
st[0] = l;
while (*p == ',' || *p == ':' || *p == '-') {
char c = *p++;
if (sscanf(p, "%d%n", &l, &n) == 1) {
p += n;
} else
return 0;
if (c == ':') {
// ':l' repeats the last value l-1 times
if (l <= 0) {
// remove the last value
if (n_st > 0) n_st--;
} else if (n_st > 0 && n_st < MAXSTEPS) {
int last = st[n_st-1];
for (int i = 1; i < l; i++) {
st[n_st++] = last;
if (n_st == MAXSTEPS) {
fprintf(stderr, "warning: too many steps: %s\n", tok);
break;
}
}
}
} else if (c == '-') {
// '-l' denotes an enumeration starting at the last value
if (n_st <= 0) return 0;
int last = st[n_st-1];
if (l >= last) {
for (int i = last+1; i <= l; i++) {
st[n_st++] = i;
if (n_st == MAXSTEPS) {
fprintf(stderr, "warning: too many steps: %s\n", tok);
break;
}
}
} else {
for (int i = last-1; i >= l; i--) {
st[n_st++] = i;
if (n_st == MAXSTEPS) {
fprintf(stderr, "warning: too many steps: %s\n", tok);
break;
}
}
}
if (st[n_st-1] != l) break;
} else if (n_st < MAXSTEPS) {
st[n_st++] = l;
if (n_st == MAXSTEPS)
fprintf(stderr, "warning: too many steps: %s\n", tok);
}
}
*n_steps = n_st;
*steps = st;
*step = 0;
} else {
*n_steps = 0;
*steps = 0;
*step = l;
}
if (*p == d)
return ++p;
else
return 0;
} else {
return 0;
}
}
int
parse_midi(char *tok, char *s, int lhs, int mode, int recursive,
int *status, int *data, int *step, int *n_steps, int **steps,
int *incr, int *dir, int *mod, int *swap, int *change)
{
char *p = tok, *t;
int n, m = -1, k = midi_channel;
s[0] = 0;
while (*p && !isdigit(*p) && !strchr("+-=<>~'[{:", *p)) p++;
if (p == tok || p-tok > 10) return 0; // no valid token
// the token by itself
strncpy(s, tok, p-tok); s[p-tok] = 0;
// normalize to lowercase
for (t = s; *t; t++) *t = tolower(*t);
// octave number or data byte
if (strcmp(s, "pb") && strcmp(s, "cp")) {
if ((*p == '-' || isdigit(*p))) {
if (sscanf(p, "%d%n", &m, &n) == 1)
p += n;
else
return 0;
} else if (!strcmp(s, "kp")) {
// key pressure, must be followed by colon and note name
if (*p == ':' && p[1]) {
char c = *++p, b = *++p;
if (*p == '#' || tolower(*p) == 'b')
p++;
else
b = 0;
int k = note_number(c, b, 0);
if (k < 0) return 0;
if ((*p == '-' || isdigit(*p)) &&
sscanf(p, "%d%n", &m, &n) == 1) {
// octave number
m = k + 12 * (m - midi_octave);
p += n;
} else {
return 0;
}
} else {
return 0;
}
} else {
return 0;
}
}
// step size / modulus
*mod = 0;
int step2 = 0, n_steps2 = 0, *steps2 = 0;
if (*p == '[' || *p == '{') {
if (p[0] == '[' && p[1] == ']') {
// basic mod translation with zero offset; only permitted on the lhs
if (!lhs) return 0;
*step = -1; // sentinel value, modulus will be filled in later
p += 2;
} else if ((p = parse_steps(tok, p, step, n_steps, steps))) {
if (*n_steps) {
// only permitted on the rhs in mod translations
if (lhs || mode < 2) return 0;
} else if (!*step || (lhs && *step<0))
// must be nonzero / positive on lhs
return 0;
if (*p == '[' || *p == '{') {
// possible step size on lhs for mod translations (we just record it
// here, will be resolved later)
if ((p = parse_steps(tok, p, &step2, &n_steps2, &steps2))) {
if (!n_steps2 && !step2) return 0; // must be nonzero
} else {
return 0;
}
}
} else {
return 0;
}
} else {
// sentinel value; for the lhs, this will be filled in below; for
// the rhs this indicates the default value
*step = 0;
*n_steps = 0;
*steps = 0;
}
// suffix with MIDI channel (not permitted with 'ch')
if (p[0] == '-' && isdigit(p[1])) {
if (strcmp(s, "ch") == 0) return 0;
if (sscanf(++p, "%d%n", &k, &n) == 1) {
// check that it is a valid channel number
if (k < 1 || k > 16) return 0;
k--; // actual MIDI channel in the range 0..15
p += n;
} else {
return 0;
}
}
*incr = *dir = *swap = *change = 0;
if (*p == '\'') {
// swap flag (only on rhs in mod translations)
if (lhs || mode < 2) return 0;
*swap = 1;
p++;
if (*p == '?') {
// change flag
*change = 1;
p++;
}
} else if (*p == '?') {
// change flag (only on rhs in mod translations)
if (lhs || mode < 2) return 0;
*change = 1;
p++;
if (*p == '\'') {
// swap flag
*swap = 1;
p++;
}
} else if (*p && strchr("+-=<>~", *p)) {
// incremental flag (messages with data only, not "ch" or "pc")
if (strcmp(s, "ch") == 0) return 0;
if (strcmp(s, "pc") == 0) return 0;
// these are only permitted with "cc"
if (strchr("<>~", *p) && strcmp(s, "cc")) return 0;
if (lhs) {
// *incr = 2 indicates an endless, sign-bit controller
*incr = strchr("+-=", *p) ? 1 : 2;
// *dir is -1 or +1 for down and up changes, but can also be zero for
// *bidirectional translations ("=" and "~")
*dir = (*p == '-' || *p == '<') ? -1 :
(*p == '+' || *p == '>') ? 1 : 0;
} else {
// only the "~" form is permitted in output messages, where it indicates
// an endless, sign-bit encoder
if (*p != '~')
return 0;
else if (mode)
fprintf(stderr, "warning: incremental flag ignored: %s\n", tok);
else
*incr = 2;
}
p++;
}
// check for trailing garbage
if (*p) return 0;
// check for the different messages types we support
if (strcmp(s, "ch") == 0) {
if (lhs) return 0; // not permitted on lhs
if (*step || *n_steps) return 0; // not permitted
if (*swap || *change || steps2 || n_steps2) return 0; // not permitted
// we return a bogus status of 0 here, along with the MIDI channel
// in the data byte; also check that the MIDI channel is in the
// proper range
if (m < 1 || m > 16) return 0;
*status = 0; *data = m-1;
return 1;
} else if (strcmp(s, "pb") == 0) {
// pitch bend, no data byte
*status = 0xe0 | k; *data = 0;
// step size on lhs indicates modulus if non-incremental
if (lhs && *step && !*incr) {
*mod = *step; *step = step2;
*n_steps = n_steps2; *steps = steps2;
if (*mod < 0) *mod = 16384;
}
if (lhs && *incr && *step < 0) return 0; // not permitted
if (lhs && !*step) *step = 1; // default
return 1;
} else if (strcmp(s, "cp") == 0) {
// channel pressure, no data byte
*status = 0xd0 | k; *data = 0;
// step size on lhs indicates modulus if non-incremental
if (lhs && *step && !*incr) {
*mod = *step; *step = step2;
*n_steps = n_steps2; *steps = steps2;
if (*mod < 0) *mod = 128;
}
if (lhs && *incr && *step < 0) return 0; // not permitted
if (lhs && !*step) *step = 1; // default
return 1;
} else if (strcmp(s, "pc") == 0) {
// program change
if (*step || *n_steps) return 0; // not permitted
if (steps2 || n_steps2) return 0; // not permitted
if (m < 0 || m > 127) return 0;
*status = 0xc0 | k; *data = m;
return 1;
} else if (strcmp(s, "cc") == 0) {
// control change
if (m < 0 || m > 127) return 0;
*status = 0xb0 | k; *data = m;
// step size on lhs indicates modulus if non-incremental
if (lhs && *step && !*incr) {
*mod = *step; *step = step2;
*n_steps = n_steps2; *steps = steps2;
if (*mod < 0) *mod = 128;
}
if (lhs && *incr && *step < 0) return 0; // not permitted
if (lhs && !*step) *step = 1; // default
return 1;
} else if (strcmp(s, "m") == 0) {
// macro, encoded as a pseudo cc message which cannot actually occur on
// input; this is only permitted in macro calls or on the lhs of a mod
// translation
if (m < 0 || m > 127) return 0;
*status = 0xb0 | k; *data = m+128;
// step size on lhs indicates modulus if non-incremental
if (lhs && *step && !*incr) {
*mod = *step; *step = step2;
*n_steps = n_steps2; *steps = steps2;
if (*mod < 0) *mod = 128;
} else if (lhs || !recursive)
return 0; // not permitted
if (lhs && *incr && *step < 0) return 0; // not permitted
if (lhs && !*step) *step = 1; // default
return 1;
} else if (strcmp(s, "kp") == 0) {
// key pressure
if (m < 0 || m > 127) return 0;
*status = 0xa0 | k; *data = m;
// step size on lhs indicates modulus if non-incremental
if (lhs && *step && !*incr) {
*mod = *step; *step = step2;
*n_steps = n_steps2; *steps = steps2;
if (*mod < 0) *mod = 128;
}
if (lhs && *incr && *step < 0) return 0; // not permitted
if (lhs && !*step) *step = 1; // default
return 1;
} else {
// step size on lhs indicates modulus
if (lhs && *step && !*incr) {
*mod = *step; *step = step2;
*n_steps = n_steps2; *steps = steps2;
if (*mod < 0) *mod = 128;
}
if (lhs && *incr && *step < 0) return 0; // not permitted
if (lhs && !*step) *step = 1; // default
// we must be looking at a MIDI note here, with m denoting the
// octave number; first character is the note name (must be a..g);
// optionally, the second character may denote an accidental (# or b)
n = note_number(s[0], s[1], m - midi_octave);
if (n < 0 || n > 127) return 0;
*status = 0x90 | k; *data = n;
return 1;
}
}
static int chk(stroke **s)
{
return !s || *s;
}
static void dup_stroke_data(stroke_data **sd, uint16_t *n, uint16_t *a,
stroke_data *sd0, uint16_t n0,
stroke_data *sd1, uint16_t n1)
{
for (int i = 0; i < n1; i++) {
if (sd1[i].anyshift) {
int nindex = sd1[i].mod?1:2; // no release seq in mod translations
for (int index = 0; index < nindex; index++) {
stroke **t =
sd0 && check_stroke_data(sd0, sd1[i].chan, sd1[i].data, n0) ? 0 :
find_stroke_data(sd, sd1[i].chan, sd1[i].data, index,
sd1[i].step[index],
sd1[i].n_steps[index], sd1[i].steps[index],
sd1[i].is_incr, sd1[i].mod, 0,
n, a);
// only add a default translation if we don't have one already
if (!chk(t)) {
stroke *s = sd1[i].s[index];
first_stroke = t;
is_keystroke = 0;
while (s) {
if (s->keysym) {
append_stroke(s->keysym, s->press);
} else if (s->shift) {
append_shift(s->shift);
} else if (!s->status) {
append_nop();
} else {
append_midi(s->status, s->data,
s->step, s->n_steps, s->steps,
s->swap, s->change, s->incr, s->recursive, s->feedback);
}
s = s->next;
}
}
}
}
}
}
int
start_translation(translation *tr, char *which_key)
{
int status, data, step, n_steps, *steps, incr, dir, mod, swap, change,
anyshift;
char buf[100];
//printf("start_translation(%s)\n", which_key);
if (tr == NULL) {
fprintf(stderr, "missing translation section: %s\n", which_key);
return 1;
}
current_translation = tr->name;
key_name = which_key;
is_keystroke = is_bidirectional = is_nop = anyshift = 0;
midi_release = explicit_release = 0;
first_release_stroke = 0;
regular_key_down = 0;
modifier_count = 0;
midi_channel = 0;
int k = 0, offs = 0;
if (isdigit(which_key[0]) && which_key[1] == '^') {
offs = 2; k = which_key[0]-'0';
if (k<0 || k>N_SHIFTS) {
fprintf(stderr, "invalid shift key: [%s]%s\n", current_translation, which_key);
return 1;
}
} else if (*which_key == '^') {
offs = k = 1;
} else {
anyshift = 1;
}
if (parse_midi(which_key+offs, buf, 1, 0, 0, &status, &data, &step, &n_steps, &steps, &incr, &dir, &mod, &swap, &change)) {
int chan = status & 0x0f;
mode = incr?0:mod?2:1;
switch (status & 0xf0) {
case 0x90:
if (incr) {
// note (step up, down)
if (step <= 0) {
fprintf(stderr, "zero or negative step size not permitted here: [%s]%s\n", current_translation, which_key);
return 1;
}
first_stroke = find_notes(tr, k, chan, data, dir>0, step,
anyshift);
if (!dir) {
is_bidirectional = 1;
release_first_stroke = find_notes(tr, k, chan, data, 1, step,
anyshift);
}
} else if (mod) {
// note mod
first_stroke = find_note(tr, k, chan, data, 0, mod,
step, n_steps, steps,
anyshift);
} else {
// note on/off
first_stroke = find_note(tr, k, chan, data, 0, 0, 0, 0, 0,
anyshift);
release_first_stroke = find_note(tr, k, chan, data, 1, 0, 0, 0, 0,
anyshift);
is_keystroke = 1;
}
break;
case 0xc0:
// pc: To make our live easier and for consistency with the other
// messages, we treat this exactly like a note/cc on/off, even though
// this message has no off state. Thus, when we receive a pc, it's
// supposed to be treated as a "press" sequence immediately followed by
// the corresponding "release" sequence.
first_stroke = find_pc(tr, k, chan, data, 0,
anyshift);
release_first_stroke = find_pc(tr, k, chan, data, 1,
anyshift);
is_keystroke = 1;
break;
case 0xb0:
if (incr) {
// cc (step up, down)
if (step <= 0) {
fprintf(stderr, "zero or negative step size not permitted here: [%s]%s\n", current_translation, which_key);
return 1;
}
first_stroke = find_ccs(tr, k, chan, data, dir>0, step, incr>1,
anyshift);
if (!dir) {
// This is a bidirectional translation (=, ~). We first fill in the
// "down" part (pointed to by first_stroke). When finishing off the
// translation, we then create an exact duplicate of the sequence
// for the "up" part. Note that we (ab)use the release_first_stroke
// variable, which normally records the release part of a key
// translation, here to remember the "up" part of the translation,
// so that we can fill in that part later.
is_bidirectional = 1;
release_first_stroke = find_ccs(tr, k, chan, data, 1, step, incr>1,
anyshift);
}
} else if (mod) {
// cc mod
first_stroke = find_cc(tr, k, chan, data, 0, mod,
step, n_steps, steps,
anyshift);
} else {
// cc on/off
first_stroke = find_cc(tr, k, chan, data, 0, 0, 0, 0, 0,
anyshift);
release_first_stroke = find_cc(tr, k, chan, data, 1, 0, 0, 0, 0,
anyshift);
is_keystroke = 1;
}
break;
case 0xa0:
if (incr) {
// kp (step up, down)
if (step <= 0) {
fprintf(stderr, "zero or negative step size not permitted here: [%s]%s\n", current_translation, which_key);
return 1;
}
first_stroke = find_kps(tr, k, chan, data, dir>0, step,
anyshift);
if (!dir) {
is_bidirectional = 1;
release_first_stroke = find_kps(tr, k, chan, data, 1, step,
anyshift);
}
} else if (mod) {
// kp mod
first_stroke = find_kp(tr, k, chan, data, 0, mod,
step, n_steps, steps,
anyshift);
} else {
// kp on/off
first_stroke = find_kp(tr, k, chan, data, 0, 0, 0, 0, 0,
anyshift);
release_first_stroke = find_kp(tr, k, chan, data, 1, 0, 0, 0, 0,
anyshift);
is_keystroke = 1;
}
break;
case 0xd0:
if (incr) {
// cp (step up, down)
if (step <= 0) {
fprintf(stderr, "zero or negative step size not permitted here: [%s]%s\n", current_translation, which_key);
return 1;
}
first_stroke = find_cps(tr, k, chan, dir>0, step,
anyshift);
if (!dir) {
is_bidirectional = 1;
release_first_stroke = find_cps(tr, k, chan, 1, step,
anyshift);
}
} else if (mod) {
// cp mod
first_stroke = find_cp(tr, k, chan, 0, mod,
step, n_steps, steps,
anyshift);
} else {
// cp on/off
first_stroke = find_cp(tr, k, chan, 0, 0, 0, 0, 0,
anyshift);
release_first_stroke = find_cp(tr, k, chan, 1, 0, 0, 0, 0,
anyshift);
is_keystroke = 1;
}
break;
case 0xe0:
if (incr) {
// pb (step up, down)
if (step <= 0) {
fprintf(stderr, "zero or negative step size not permitted here: [%s]%s\n", current_translation, which_key);
return 1;
}
first_stroke = find_pbs(tr, k, chan, dir>0, step,
anyshift);
if (!dir) {
is_bidirectional = 1;
release_first_stroke = find_pbs(tr, k, chan, 1, step,
anyshift);
}
} else if (mod) {
// pb mod
first_stroke = find_pb(tr, k, chan, 0, mod,
step, n_steps, steps,
anyshift);
} else {
// pb on/off
first_stroke = find_pb(tr, k, chan, 0, 0, 0, 0, 0,
anyshift);
release_first_stroke = find_pb(tr, k, chan, 1, 0, 0, 0, 0,
anyshift);
is_keystroke = 1;
}
break;
default:
// this can't happen
fprintf(stderr, "unexpected error: [%s]%s\n", current_translation, which_key);
return 1;
}
} else {
fprintf(stderr, "syntax error: [%s]%s\n", current_translation, which_key);
return 1;
}
if (chk(first_stroke) ||
(is_bidirectional && chk(release_first_stroke))) {
fprintf(stderr, "already defined: [%s]%s\n", current_translation, which_key);
return 1;
}
press_first_stroke = first_stroke;
return 0;
}
void
add_keysym(KeySym sym, int press_release)
{
//printf("add_keysym(0x%x, %d)\n", (int)sym, press_release);
switch (press_release) {
case PRESS:
append_stroke(sym, 1);
mark_as_down(sym, 0);
break;
case RELEASE:
append_stroke(sym, 0);
mark_as_up(sym);
break;
case HOLD:
append_stroke(sym, 1);
mark_as_down(sym, 1);
break;
case PRESS_RELEASE:
default:
if (first_release_stroke) {
re_press_temp_modifiers();
}
if (regular_key_down != 0) {
append_stroke(regular_key_down, 0);
}
append_stroke(sym, 1);
regular_key_down = sym;
first_release_stroke = 0;
break;
}
}
void
add_release(int all_keys)
{
//printf("add_release(%d)\n", all_keys);
release_modifiers(all_keys);
if (!all_keys) {
if (!*first_stroke) append_nop();
first_stroke = release_first_stroke;
if (midi_release) {
// walk the list of "press" strokes, find all "dirty" (as yet unhandled)
// MIDI events in there and add them to the "release" strokes (unless
// there's an explicit release sequence in which case we output nothing)
stroke *s = *press_first_stroke;
while (s) {
if (!s->keysym && !s->shift && s->dirty) {
if (!explicit_release)
append_midi(s->status, s->data,
s->step, s->n_steps, s->steps,
s->swap, s->change, s->incr, s->recursive, s->feedback);
s->dirty = 0;
}
s = s->next;
}
}
}
if (regular_key_down) append_stroke(regular_key_down, 0);
if (all_keys && is_nop && !*first_stroke) append_nop();
regular_key_down = 0;
first_release_stroke = 1;
if (all_keys && is_bidirectional) {
// create a duplicate for bidirectional translations (=, ~)
stroke *s = *press_first_stroke;
first_stroke = release_first_stroke;
while (s) {
if (s->keysym) {
append_stroke(s->keysym, s->press);
} else if (s->shift) {
append_shift(s->shift);
} else if (!s->status) {
append_nop();
} else {
append_midi(s->status, s->data,
s->step, s->n_steps, s->steps,
s->swap, s->change, s->incr, s->recursive, s->feedback);
}
s = s->next;
}
}
}
void
add_keystroke(char *keySymName, int press_release)
{
KeySym sym;
if (is_keystroke && !strncmp(keySymName, "RELEASE", 8)) {
add_release(0);
return;
}
sym = string_to_KeySym(keySymName);
if (sym != 0) {
add_keysym(sym, press_release);
} else {
fprintf(stderr, "unrecognized keysym: %s\n", keySymName);
}
}
void
add_string(char *str)
{
while (str && *str) {
if (*str >= ' ' && *str <= '~') {
add_keysym((KeySym)(*str), PRESS_RELEASE);
}
str++;
}
}
void
add_midi(char *tok)
{
int status, data, step, n_steps, *steps, incr, dir = 0, mod = 0, swap = 0, change = 0;
int recursive = *tok == '$', fb = *tok == '!', fb2 = *tok == '^';
char buf[100];
if (fb2 && mode != 1) {
fprintf(stderr, "shift feedback only allowed in key translations: %s\n", tok);
return;
}
if (parse_midi(tok+recursive+fb+fb2, buf, 0, mode, recursive, &status, &data, &step, &n_steps, &steps, &incr, &dir, &mod, &swap, &change)) {
if (status == 0) {
// 'ch' token; this doesn't actually generate any output, it just sets
// the default MIDI channel
midi_channel = data;
if (recursive)
fprintf(stderr, "invalid macro call: %s\n", tok);
} else {
append_midi(status, data, step, n_steps, steps,
swap, change, incr!=0, recursive, fb2?2:fb);
}
} else {
// inspect the token that was actually recognized (if any) to give some
// useful error message here
if (strcmp(buf, "ch"))
fprintf(stderr, "syntax error: %s\n", tok);
else
fprintf(stderr, "invalid MIDI channel: %s\n", tok);
}
}
void
finish_translation(void)
{
//printf("finish_translation()\n");
if (is_keystroke) {
add_release(0);
}
add_release(1);
if (debug_strokes) {
if (is_keystroke) {
print_stroke_sequence(key_name, "D", *press_first_stroke, 0, 0, 0, 0, 0);
print_stroke_sequence(key_name, "U", *release_first_stroke, 0, 0, 0, 0, 0);
} else {
print_stroke_sequence(key_name, "", *first_stroke, 0, 0, 0, 0, 0);
}
printf("\n");
}
}
int
read_config_file(void)
{
struct stat buf;
char *home;
char *line;
char *s;
char *name = NULL;
char *regex;
char *tok;
char *which_key;
char *updown;
char delim;
translation *tr = NULL;
FILE *f;
int config_file_default = 0;
static int errors = 0;
if (config_file_name == NULL) {
config_file_name = getenv("MIDIZAP_CONFIG_FILE");
if (config_file_name == NULL) {
home = getenv("HOME");
config_file_name = alloc_strcat(home, "/.midizaprc");
config_file_default = 1;
} else {
config_file_name = alloc_strcat(config_file_name, NULL);
}
config_file_modification_time = 0;
}
if (stat(config_file_name, &buf) < 0) {
// AG: Fall back to the system-wide configuration file.
if (!config_file_default && !errors) {
perror(config_file_name);
errors++;
}
config_file_name = "/etc/midizaprc";
config_file_modification_time = 0;
}
if (stat(config_file_name, &buf) < 0) {
if (!errors) {
perror(config_file_name);
errors++;
}
return 0;
}
if (buf.st_mtime == 0) {
buf.st_mtime = 1;
}
if (buf.st_mtime > config_file_modification_time) {
config_file_modification_time = buf.st_mtime;
if (default_debug_regex || default_debug_strokes || default_debug_keys ||
default_debug_midi) {
printf("Loading configuration: %s\n", config_file_name);
}
f = fopen(config_file_name, "r");
if (f == NULL) {
if (!errors) {
perror(config_file_name);
errors++;
}
return 0;
}
free_all_translations();
reload_callback();
debug_regex = default_debug_regex;
debug_strokes = default_debug_strokes;
debug_keys = default_debug_keys;
debug_midi = default_debug_midi;
midi_octave = 0;
while ((line=read_line(f, config_file_name)) != NULL) {
//printf("line: %s", line);
s = line;
while (*s && isspace(*s)) {
s++;
}
if (*s == '#') {
continue;
}
if (*s == '[') {
// [name] regex\n
int mode = 0;
name = ++s;
while (*s && *s != ']') {
s++;
}
regex = NULL;
if (*s) {
*s = '\0';
s++;
while (*s && isspace(*s)) {
s++;
}
if (!strncmp(s, "TITLE", 5)) {
mode = 1;
s += 5;
} else if (!strncmp(s, "CLASS", 5)) {
mode = 2;
s += 5;
}
while (*s && isspace(*s)) {
s++;
}
regex = s;
while (*s) {
s++;
}
s--;
while (s > regex && isspace(*s)) {
s--;
}
s[1] = '\0';
}
finish_translation_section(tr);
tr = new_translation_section(name, mode, regex);
continue;
}
tok = token(s, &delim);
if (tok == NULL) {
continue;
}
if (!strcmp(tok, "DEBUG_REGEX")) {
debug_regex = 1; // -dr
continue;
}
if (!strcmp(tok, "DEBUG_STROKES")) {
debug_strokes = 1; // -ds
continue;
}
if (!strcmp(tok, "DEBUG_KEYS")) {
debug_keys = 1; // -dk
continue;
}
if (!strcmp(tok, "DEBUG_MIDI")) {
debug_midi = 1; // -dm
continue;
}
if (!strcmp(tok, "NO_FEEDBACK")) {
auto_feedback = 0; // -n
continue;
}
if (!strcmp(tok, "JACK_NAME")) {
char *a = token(NULL, &delim);
if (!jack_client_name) {
static char buf[100];
strncpy(buf, a, 100); buf[99] = 0; // just in case...
jack_client_name = buf; // -j
}
continue;
}
if (!strcmp(tok, "JACK_PORTS")) {
char *a = token(NULL, &delim);
int k, n;
if (!jack_num_outputs) {
if (sscanf(a, "%d%n", &k, &n) == 1 && !a[n] && k>=0 && k<=2) {
jack_num_outputs = k; // -o
} else {
fprintf(stderr, "invalid port number: %s, must be 0, 1 or 2\n", a);
}
}
continue;
}
if (!strncmp(tok, "JACK_", 5)) {
// JACK_IN/OUT. The port number follows (default: 1), then a regex
// (taken verbatim from the rest of the line).
char *s = tok+5, *regex;
int is_input = strncmp(s, "IN", 2) == 0;
if (is_input)
s += 2;
else if (strncmp(s, "OUT", 3) == 0)
s += 3;
else {
fprintf(stderr, "invalid token: %s, must be JACK_IN or JACK_OUT\n",
tok);
continue;
}
int portno = !*s||*s=='1'?0:*s=='2'?1:-1;
if (portno < 0) {
fprintf(stderr, "invalid port number: %s, must be 1 or 2\n", s);
continue;
}
if (*s && *++s) {
// trailing garbage
fprintf(stderr, "invalid token: %s, must be JACK_IN or JACK_OUT\n",
tok);
continue;
}
s = token_src;
while (*s && isspace(*s)) {
s++;
}
regex = s;
while (*s) {
s++;
}
s--;
while (s > regex && isspace(*s)) {
s--;
}
s[1] = '\0';
char **jack_regex = is_input?jack_in_regex:jack_out_regex;
if (jack_regex[portno]) {
if (strcmp(jack_regex[portno], regex))
fprintf(stderr, "error: attempt to redefine %s as '%s'\n(is already defined as '%s')\n", tok, regex, jack_regex[portno]);
} else {
jack_regex[portno] = strdup(regex);
}
continue;
}
if (!strcmp(tok, "PASSTHROUGH")) { // -t
char *a = token(NULL, &delim);
int k, n;
if (a && *a && *a != '#') {
if (sscanf(a, "%d%n", &k, &n) == 1 && !a[n] && k>=0 && k<=2) {
if (passthrough[0] < 0) passthrough[0] = k==1;
if (passthrough[1] < 0) passthrough[1] = k==2;
} else {
fprintf(stderr, "invalid port number: %s, must be 0, 1 or 2\n", a);
}
} else {
if (passthrough[0] < 0) passthrough[0] = 1;
if (passthrough[1] < 0) passthrough[1] = 1;
}
continue;
}
if (!strcmp(tok, "SYSTEM_PASSTHROUGH")) { // -s
char *a = token(NULL, &delim);
int k, n;
if (a && *a && *a != '#') {
if (sscanf(a, "%d%n", &k, &n) == 1 && !a[n] && k>=0 && k<=2) {
if (system_passthrough[0] < 0) system_passthrough[0] = k==1;
if (system_passthrough[1] < 0) system_passthrough[1] = k==2;
} else {
fprintf(stderr, "invalid port number: %s, must be 0, 1 or 2\n", a);
}
} else {
if (system_passthrough[0] < 0) system_passthrough[0] = 1;
if (system_passthrough[1] < 0) system_passthrough[1] = 1;
}
continue;
}
if (!strncmp(tok, "MIDI_OCTAVE", 11)) {
char *a = tok+11;
int k, n;
if (!*a)
// look for the offset in the next token
a = token(NULL, &delim);
if (sscanf(a, "%d%n", &k, &n) == 1 && !a[n]) {
midi_octave = k;
} else {
fprintf(stderr, "invalid octave offset: %s\n", a);
}
continue;
}
which_key = tok;
if (start_translation(tr, which_key)) {
continue;
}
tok = token(NULL, &delim);
while (tok != NULL) {
if (delim != '"' && tok[0] == '#') {
break; // skip rest as comment
}
//printf("token: [%s] delim [%d]\n", tok, delim);
switch (delim) {
case ' ':
case '\t':
case '\n':
case '\0': // no newline at eof
if (!strcmp(tok, "RELEASE")) {
// Suppress the default MIDI release sequence if there's an
// explicit release sequence.
explicit_release = 1;
add_keystroke(tok, PRESS_RELEASE);
} else if (!strncmp(tok, "SHIFT", 5)) {
int shift = isdigit(tok[5])?tok[5]-'0':1;
if ((tok[5] == 0 || (isdigit(tok[5]) && tok[6] == 0)) &&
shift >= 1 && shift <= N_SHIFTS)
append_shift(shift);
else
fprintf(stderr, "invalid shift key: [%s]%s\n", name, tok);
} else if (!strcmp(tok, "NOP"))
append_nop();
else if (strncmp(tok, "XK", 2))
add_midi(tok);
else
add_keystroke(tok, PRESS_RELEASE);
break;
case '"':
add_string(tok);
break;
default: // should be slash
updown = token(NULL, &delim);
if (updown != NULL) {
switch (updown[0]) {
case 'U':
add_keystroke(tok, RELEASE);
break;
case 'D':
add_keystroke(tok, PRESS);
break;
case 'H':
add_keystroke(tok, HOLD);
break;
default:
fprintf(stderr, "invalid up/down modifier [%s]%s: %s\n", name, which_key, updown);
add_keystroke(tok, PRESS);
break;
}
}
}
tok = token(NULL, &delim);
}
finish_translation();
}
finish_translation_section(tr);
fclose(f);
return 1;
} else {
return 0;
}
}
translation *
get_translation(char *win_title, char *win_class)
{
translation *tr;
read_config_file();
tr = first_translation_section;
while (tr != NULL) {
if (!tr->is_default) {
// AG: We first try to match the class name, since it usually provides
// better identification clues.
if ((tr->mode == 0 || tr->mode == 2) && win_class && *win_class &&
regexec(&tr->regex, win_class, 0, NULL, 0) == 0) {
return tr;
}
if ((tr->mode == 0 || tr->mode == 1) && win_title && *win_title &&
regexec(&tr->regex, win_title, 0, NULL, 0) == 0) {
return tr;
}
}
tr = tr->next;
}
return NULL;
}