static void
bind_keys_qwertz(PianoKeyboard *pk)
{
bind_keys_qwerty(pk);
/* The only difference between QWERTY and QWERTZ is that the "y" and "z" are swapped together. */
bind_key(pk, "y", 12);
bind_key(pk, "z", 33);
}
void key_listener::bind_key(int logical_key, const SDLKey& k,
const SDLMod& m, bool collapse_doubles) {
SDL_keysym sym;
sym.sym = k;
sym.mod = m;
bind_key(logical_key, sym, collapse_doubles);
}
sqlite3_stmt *YesqlClient::construct_sql_scan(const TableId& table, const Key& start_key, int count,
const FieldList& fields){
sqlite3_stmt* ret = nullptr;
std::string sql;
bool prepared = false;
sql.append("SELECT ");
for (auto& it : fields){
sql.append(it);
sql.append(",");
}
sql.back() = ' ';
sql.append(" FROM ");
sql.append(table);
sql.append(" WHERE ");
sql.append(KEYNAME);
sql.append(">=?");
sql.append(" LIMIT ");
char num_buf[10];
snprintf(num_buf, 10, "%d", count);
sql.append(num_buf);
int rc = stmt_cache(STMT_INDEX_SCAN, sql.c_str(), &ret);
if (rc == SQLITE_OK){
prepared = true;
rc = bind_key(ret, start_key);
}
if (rc != SQLITE_OK){
LOG("Error %s scan: %s\n\tSQL was: %s\n", (prepared) ? "binding" : "preparing",
sqlite3_errmsg(_dbhandle), sql.c_str());
//sqlite3_finalize(ret);
ret = nullptr;
}
return ret;
}
sqlite3_stmt *YesqlClient::construct_sql_read(const TableId& table, const Key& key, const FieldList& fields){
sqlite3_stmt* ret = nullptr;
bool prepared = false;
int rc=0;
std::string sql;
sql.append("SELECT ");
for (auto& it : fields){
sql.append(it);
sql.append(",");
}
sql.back() = ' ';
sql.append(" FROM ");
sql.append(table);
sql.append(" WHERE ");
sql.append(KEYNAME);
sql.append("=?");
rc = stmt_cache(STMT_INDEX_READ, sql.c_str(), &ret);
if (rc == SQLITE_OK){
prepared = true;
rc = bind_key(ret, key);
}
if (rc != SQLITE_OK){
if (sql == "") sql.append("(previously-prepared-query)");
LOG("Error %s read: %s\n\tSQL was: %s\n", (prepared) ? "binding" : "preparing",
sqlite3_errmsg(_dbhandle), sql.c_str());
//sqlite3_finalize(ret);
ret = nullptr;
}
return ret;
}
void
JoystickKeyboardController::process_menu_key_event(const SDL_KeyboardEvent& event)
{
// wait for key mode?
if(wait_for_key >= 0) {
if(event.type == SDL_KEYUP)
return;
if(event.keysym.sym != SDLK_ESCAPE
&& event.keysym.sym != SDLK_PAUSE) {
bind_key(event.keysym.sym, Control(wait_for_key));
}
reset();
MenuStorage::get_key_options_menu()->update();
wait_for_key = -1;
return;
}
if(wait_for_joystick >= 0) {
if(event.keysym.sym == SDLK_ESCAPE) {
reset();
MenuStorage::get_joystick_options_menu()->update();
wait_for_joystick = -1;
}
return;
}
Control control;
/* we use default keys when the menu is open (to avoid problems when
* redefining keys to invalid settings
*/
switch(event.keysym.sym) {
case SDLK_UP:
control = Controller::UP;
break;
case SDLK_DOWN:
control = Controller::DOWN;
break;
case SDLK_LEFT:
control = Controller::LEFT;
break;
case SDLK_RIGHT:
control = Controller::RIGHT;
break;
case SDLK_SPACE:
case SDLK_RETURN:
case SDLK_KP_ENTER:
control = Controller::MENU_SELECT;
break;
case SDLK_ESCAPE:
case SDLK_PAUSE:
control = Controller::PAUSE_MENU;
break;
default:
return;
break;
}
controller->set_control(control, (event.type == SDL_KEYDOWN));
}
/*
* Try to get a handle to a readline function from a variety of different
* libraries. If nothing is present on the system, then fall back to an
* internal one.
*
* Logic originally based off of code in the e2fsutils package in the
* lib/ss/get_readline.c file, which is licensed under the MIT license.
*
* This keeps us from having to relicense the bti codebase if readline
* ever changes its license, as there is no link-time dependency.
* It is a run-time thing only, and we handle any readline-like library
* in the same manner, making bti not be a derivative work of any
* other program.
*/
static void session_readline_init(struct session *session)
{
/* Libraries we will try to use for readline/editline functionality */
const char *libpath = "libreadline.so.6:libreadline.so.5:"
"libreadline.so.4:libreadline.so:libedit.so.2:"
"libedit.so:libeditline.so.0:libeditline.so";
void *handle = NULL;
char *tmp, *cp, *next;
int (*bind_key) (int, void *);
void (*insert) (void);
/* default to internal function if we can't or won't find anything */
session->readline = get_string;
if (!isatty(0))
return;
session->interactive = 1;
tmp = malloc(strlen(libpath) + 1);
if (!tmp)
return;
strcpy(tmp, libpath);
for (cp = tmp; cp; cp = next) {
next = strchr(cp, ':');
if (next)
*next++ = 0;
if (*cp == 0)
continue;
handle = dlopen(cp, RTLD_NOW);
if (handle) {
dbg("Using %s for readline library\n", cp);
break;
}
}
free(tmp);
if (!handle) {
dbg("No readline library found.\n");
return;
}
session->readline_handle = handle;
session->readline = (char *(*)(const char *))dlsym(handle, "readline");
if (session->readline == NULL) {
/* something odd happened, default back to internal stuff */
session->readline_handle = NULL;
session->readline = get_string;
return;
}
/*
* If we found a library, turn off filename expansion
* as that makes no sense from within bti.
*/
bind_key = (int (*)(int, void *))dlsym(handle, "rl_bind_key");
insert = (void (*)(void))dlsym(handle, "rl_insert");
if (bind_key && insert)
bind_key('\t', insert);
}
void key_listener::expand_keys(int logical_key, const SDL_keysym& sym,
const SDLMod& processed_mask, int depth) {
SDL_keysym tmp;
tmp = sym;
static const int NUM_CHUNKS = 4;
static const SDLMod chunks[NUM_CHUNKS] = {
(SDLMod)KMOD_SHIFT, (SDLMod)KMOD_ALT,
(SDLMod)KMOD_CTRL, (SDLMod)KMOD_META
};
static const SDLMod ALL_CHUNKS = (SDLMod)(KMOD_SHIFT | KMOD_ALT | KMOD_CTRL | KMOD_META);
static const int NUM_BITS = sizeof(SDLMod)*8;
int bit_idx[NUM_BITS];
int remaining = ALL_CHUNKS & sym.mod & ~processed_mask;
if(remaining == 0) {
bind_key(logical_key, sym, false);
return;
}
for(int i =0;i<NUM_CHUNKS;++i) {
if(sym.mod & chunks[i] && !(processed_mask & chunks[i])) {
SDLMod newmask = (SDLMod)(processed_mask | chunks[i]);
SDLMod newmod = (SDLMod)(sym.mod & ~chunks[i]);
int bit_count = 0;
for(int j=0;j<NUM_BITS;++j) {
if(chunks[i] & (1 << j)) {
bit_idx[bit_count++] = j;
}
}
int k_max = 1 << bit_count;
for(int k=1;k < k_max;++k) {
tmp.mod = newmod;
for(int j=0;j<bit_count;++j) {
int bit = 1 << j;
if(k & bit) {
tmp.mod = (SDLMod)(tmp.mod | (1 << bit_idx[j]));
}
}
expand_keys(logical_key, tmp, newmask, depth+1);
}
return;
}
}
}
static SCM scm_bind_key(SCM mod_mask, SCM key, SCM proc)
{
xcb_keysym_t keysym;
if (scm_is_true(scm_number_p(key)))
keysym = scm_to_uint32(key);
else if (scm_is_true(scm_string_p(key))) {
scm_dynwind_begin(0);
char *c_key = scm_to_locale_string(key);
scm_dynwind_free(c_key);
keysym = get_keysym(c_key);
scm_dynwind_end();
}
else
return SCM_UNSPECIFIED;
bind_key(scm_to_uint16(mod_mask), keysym, proc);
return SCM_UNSPECIFIED;
}
sqlite3_stmt *YesqlClient::construct_sql_remove(const TableId& table, const Key& key){
sqlite3_stmt* ret;
bool prepared = false;
std::string sql;
sql.append("DELETE FROM ");
sql.append(table);
sql.append(" WHERE ");
sql.append(KEYNAME);
sql.append("=?");
int rc = stmt_cache(STMT_INDEX_REMOVE, sql.c_str(), &ret);
if (rc == SQLITE_OK){
rc = bind_key(ret, key);
}
if (rc != SQLITE_OK){
LOG("Error %s delete: %s\n\tSQL was: %s\n", (prepared) ? "binding" : "preparing",
sqlite3_errmsg(_dbhandle), sql.c_str());
//sqlite3_finalize(ret);
ret = nullptr;
}
return ret;
}
static void
bind_keys_azerty(PianoKeyboard *pk)
{
clear_notes(pk);
bind_key(pk, "space", 128);
/* Lower keyboard row - "wxcvbn,". */
bind_key(pk, "w", 12); /* C0 */
bind_key(pk, "s", 13);
bind_key(pk, "x", 14);
bind_key(pk, "d", 15);
bind_key(pk, "c", 16);
bind_key(pk, "v", 17);
bind_key(pk, "g", 18);
bind_key(pk, "b", 19);
bind_key(pk, "h", 20);
bind_key(pk, "n", 21);
bind_key(pk, "j", 22);
bind_key(pk, "comma", 23);
/* Upper keyboard row, first octave - "azertyu". */
bind_key(pk, "a", 24);
bind_key(pk, "eacute", 25);
bind_key(pk, "z", 26);
bind_key(pk, "quotedbl", 27);
bind_key(pk, "e", 28);
bind_key(pk, "r", 29);
bind_key(pk, "parenleft", 30);
bind_key(pk, "t", 31);
bind_key(pk, "minus", 32);
bind_key(pk, "y", 33);
bind_key(pk, "egrave", 34);
bind_key(pk, "u", 35);
/* Upper keyboard row, the rest - "iop". */
bind_key(pk, "i", 36);
bind_key(pk, "ccedilla", 37);
bind_key(pk, "o", 38);
bind_key(pk, "agrave", 39);
bind_key(pk, "p", 40);
}
static void
bind_keys_qwerty(PianoKeyboard *pk)
{
clear_notes(pk);
bind_key(pk, "space", 128);
/* Lower keyboard row - "zxcvbnm". */
bind_key(pk, "z", 12); /* C0 */
bind_key(pk, "s", 13);
bind_key(pk, "x", 14);
bind_key(pk, "d", 15);
bind_key(pk, "c", 16);
bind_key(pk, "v", 17);
bind_key(pk, "g", 18);
bind_key(pk, "b", 19);
bind_key(pk, "h", 20);
bind_key(pk, "n", 21);
bind_key(pk, "j", 22);
bind_key(pk, "m", 23);
/* Upper keyboard row, first octave - "qwertyu". */
bind_key(pk, "q", 24);
bind_key(pk, "2", 25);
bind_key(pk, "w", 26);
bind_key(pk, "3", 27);
bind_key(pk, "e", 28);
bind_key(pk, "r", 29);
bind_key(pk, "5", 30);
bind_key(pk, "t", 31);
bind_key(pk, "6", 32);
bind_key(pk, "y", 33);
bind_key(pk, "7", 34);
bind_key(pk, "u", 35);
/* Upper keyboard row, the rest - "iop". */
bind_key(pk, "i", 36);
bind_key(pk, "9", 37);
bind_key(pk, "o", 38);
bind_key(pk, "0", 39);
bind_key(pk, "p", 40);
}
bool Keybinding_pool::load_from(std::string filename)
{
std::ifstream fin;
fin.open(filename.c_str());
if (!fin.is_open()) {
debugmsg("Failed to open '%s'", filename.c_str());
return false;
}
std::string keystr;
std::vector<long> keys;
while (!fin.eof() && fin >> keystr) {
if (lookup_key(keystr) != 0) {
keys.push_back( lookup_key(keystr) );
} else if (keystr == "=") {
std::string action_name;
std::getline(fin, action_name);
action_name = trim(action_name);
Interface_action act = lookup_interface_action(action_name);
if (act == IACTION_NULL) {
Debug_action debug_act = lookup_debug_action(action_name);
if (debug_act == DEBUG_ACTION_NULL) {
debugmsg("Unknown action in '%s': '%s'", filename.c_str(),
action_name.c_str());
} else {
for (int i = 0; i < keys.size(); i++) {
Debug_action already_bound = bound_to_debug_key( keys[i] );
if (already_bound != DEBUG_ACTION_NULL) {
debugmsg("Key %c bound to %s; reassigned to %s. (%s)", keys[i],
debug_action_name(already_bound).c_str(),
debug_action_name(debug_act).c_str(),
filename.c_str());
}
bind_debug_key( keys[i], debug_act );
}
}
} else { // if (act == IACTION_NULL)
for (int i = 0; i < keys.size(); i++) {
Interface_action already_bound = bound_to_key( keys[i] );
if (already_bound != IACTION_NULL) {
debugmsg("Key %c bound to %s; reassigned to %s. (%s)", keys[i],
interface_action_name(already_bound).c_str(),
interface_action_name(act).c_str(),
filename.c_str());
}
bind_key( keys[i], act );
}
}
keys.clear();
} else {
for (int i = 0; i < keystr.size(); i++) {
keys.push_back( keystr[i] );
}
}
}
return true;
}
