int type_in_pre_strokes(void)
{
struct char_set *keyb_charset = trconfig.keyb_charset;
if (config.pre_stroke && !pre_stroke) {
size_t characters, src_len;
const char *ptr;
struct char_set_state state;
init_charset_state(&state, keyb_charset);
src_len = strlen(config.pre_stroke) +1;
ptr = config.pre_stroke;
characters = character_count(&state, ptr, src_len);
pre_stroke_mem = pre_stroke =
malloc(sizeof(t_unicode) * (characters +1));
charset_to_unicode_string(&state, pre_stroke, &ptr, src_len);
cleanup_charset_state(&state);
}
if (pre_stroke) {
pre_stroke = type_one_key(pre_stroke);
if (!pre_stroke) {
free(config.pre_stroke);
free(pre_stroke_mem);
config.pre_stroke = 0;
}
}
return stroke_pause;
}
static char *get_selection_string(t_unicode sel_text[], char *charset)
{
struct char_set_state paste_state;
struct char_set *paste_charset;
t_unicode *u = sel_text;
char *s, *p;
size_t sel_space = 0;
while (sel_text[sel_space])
sel_space++;
paste_charset = lookup_charset(charset);
sel_space *= MB_LEN_MAX;
p = s = malloc(sel_space);
init_charset_state(&paste_state, paste_charset);
while (*u) {
size_t result = unicode_to_charset(&paste_state, *u++,
(unsigned char *)p, sel_space);
if (result == -1) {
warn("save_selection unfinished2\n");
break;
}
p += result;
sel_space -= result;
}
*p = '\0';
cleanup_charset_state(&paste_state);
return s;
}
static void init_upperlowerDOS_table(void)
{
struct char_set_state dos_state;
t_unicode symbol, symbolc;
int i, result;
for (i = 0; i < 128; i++) {
/* force English ASCII handling for 0 -- 127 to avoid problems
with the Turkish dotless i */
upperDOS_table[i] = lowerDOS_table[i] = i;
if (i >= 'a' && i <= 'z')
upperDOS_table[i] = i - ('a' - 'A');
else if (i >= 'A' && i <= 'Z')
lowerDOS_table[i] = i + ('a' - 'A');
}
for (i = 128; i < 256; i++) {
upperDOS_table[i] = lowerDOS_table[i] = i;
init_charset_state(&dos_state, trconfig.dos_charset);
result = charset_to_unicode(&dos_state, &symbol, &upperDOS_table[i], 1);
cleanup_charset_state(&dos_state);
if (result == 1) {
symbolc = towupper(symbol);
init_charset_state(&dos_state, trconfig.dos_charset);
result = unicode_to_charset(&dos_state, symbolc, &upperDOS_table[i], 1);
cleanup_charset_state(&dos_state);
if (result != 1)
upperDOS_table[i] = i;
symbolc = towlower(symbol);
init_charset_state(&dos_state, trconfig.dos_charset);
result = unicode_to_charset(&dos_state, symbolc, &lowerDOS_table[i], 1);
cleanup_charset_state(&dos_state);
if (result != 1)
lowerDOS_table[i] = i;
}
}
}
static t_unicode keysym_to_unicode(t_unicode ch)
{
struct char_set *keyb_charset;
unsigned char buff[1];
struct char_set_state keyb_state;
/* 0xef00 - 0xefff is a pass through range to the current
* character set.
*/
if ((ch < 0xef00) || (ch > 0xefff))
return ch;
keyb_charset = trconfig.keyb_config_charset;
init_charset_state(&keyb_state, keyb_charset);
buff[0] = ch & 0xFF;
charset_to_unicode(&keyb_state, &ch, buff, 1);
cleanup_charset_state(&keyb_state);
return ch;
}
/* paste a string of (almost) arbitrary length through the DOS keyboard,
* without danger of overrunning the keyboard queue/buffer.
* 'text' is expected to be in latin1 charset, with unix ('\n')
* line end convention.
*
* 'text' is actually expected to be in trconfig.paste_charset
* which defaults to iso8859-1 with unix ('\n') line end convetion.
*/
int paste_text(const char *text, int len)
{
struct char_set *paste_charset = trconfig.paste_charset;
struct char_set_state state;
t_unicode *str;
int characters;
int result;
init_charset_state(&state, paste_charset);
characters = character_count(&state, text, len);
str = malloc(sizeof(t_unicode) * (characters +1));
charset_to_unicode_string(&state, str, &text, len);
cleanup_charset_state(&state);
result = paste_unicode_text(str, characters);
free(str);
return result;
}
static void init_dos_to_unicode_table(void)
{
struct char_set_state dos_state;
unsigned short *dest;
int i;
t_unicode symbol;
int result;
dest = dos_to_unicode_table;
for (i = 0; i < 0x100; i++) {
unsigned char ch = i;
init_charset_state(&dos_state, trconfig.dos_charset);
result = charset_to_unicode(&dos_state, &symbol, &ch, 1);
*dest = symbol;
if (result != 1)
*dest = '?';
cleanup_charset_state(&dos_state);
dest++;
}
}
BOOL strhasupperDOS(char *s)
{
struct char_set_state dos_state;
t_unicode symbol;
size_t len = strlen(s);
int result = -1;
init_charset_state(&dos_state, trconfig.dos_charset);
while (*s) {
result = charset_to_unicode(&dos_state, &symbol, (unsigned char *)s, len);
if (result == -1)
break;
if (iswupper(symbol))
break;
len -= result;
s += result;
}
cleanup_charset_state(&dos_state);
return(result != -1 && iswupper(symbol));
}
static void init_unicode_to_dos_table(void)
{
struct char_set_state dos_state;
unsigned char *dest;
t_unicode symbol;
int result;
dest = unicode_to_dos_table;
/* these are either invalid or ascii: no replacement '_' ! */
for (symbol = 0; symbol <= 0x7f; symbol++)
*dest++ = symbol;
for (symbol = 0x80; symbol <= 0xffff; symbol++) {
init_charset_state(&dos_state, trconfig.dos_charset);
result = unicode_to_charset(&dos_state, symbol, dest, 1);
if (result == -1 && errno == -E2BIG)
error("BUG: Internal multibyte character sets can't happen\n");
if (result != 1 || *dest == '?')
*dest = '_';
cleanup_charset_state(&dos_state);
dest++;
}
}
/* This function is borrowed from Wine (LGPL'ed)
http://source.winehq.org/source/dlls/x11drv/keyboard.c
with adjustments to match dosemu
The idea is, if $_layout="auto", to match each keyboard map with
the X keymap and choose the one that matches best.
It is used when we can access display, not just for xdosemu,
but also in xterms. Remote users using terminals will have
to specify $_layout explicitly though.
The console map is just another map in this scheme that may
or may not be the best one.
*/
int X11_DetectLayout (void)
{
Display *display;
unsigned match, mismatch, seq, i, alternate;
int score, keyc, key, pkey, ok = 0;
KeySym keysym;
unsigned max_seq[3] = {0, 0};
int max_score[3] = {INT_MIN, INT_MIN};
int ismatch = 0;
int min_keycode, max_keycode;
t_unicode ckey[2] = {0, 0};
t_keysym lkey[2] = {0, 0};
struct keytable_entry *kt;
struct char_set_state X_charset;
char *display_name = config.X_display ? config.X_display : getenv("DISPLAY");
display = XOpenDisplay(display_name);
if (display == NULL) return 1;
XDisplayKeycodes(display, &min_keycode, &max_keycode);
#ifndef HAVE_XKB
int keysyms_per_keycode;
KeySym *key_mapping;
/* get data for keycode from X server */
key_mapping = XGetKeyboardMapping(display, min_keycode,
max_keycode + 1 - min_keycode,
&keysyms_per_keycode);
#endif
init_charset_state(&X_charset, lookup_charset("X_keysym"));
for (kt = keytable_list, alternate = 0; kt->name; ) {
k_printf("Attempting to match against \"%s\"\n", kt->name);
match = 0;
mismatch = 0;
score = 0;
seq = 0;
pkey = -1;
for (keyc = min_keycode; keyc <= max_keycode; keyc++) {
for (i = 0; i < 2; i++) {
#ifdef HAVE_XKB
keysym = XkbKeycodeToKeysym(display, keyc, alternate, i);
#else
keysym = X11_KeycodeToKeysym(key_mapping, keysyms_per_keycode,
min_keycode, keyc, alternate, i);
#endif
charset_to_unicode(&X_charset, &ckey[i],
(const unsigned char *)&keysym, sizeof(keysym));
}
if (ckey[0] != U_VOID && (ckey[0] & 0xf000) != 0xe000) {
/* search for a match in layout table */
/* right now, we just find an absolute match for defined positions */
/* (undefined positions are ignored, so if it's defined as "3#" in */
/* the table, it's okay that the X server has "3#£", for example) */
/* however, the score will be higher for longer matches */
for (key = 0; key < kt->sizemap; key++) {
lkey[0] = keysym_to_unicode(kt->key_map[key]);
lkey[1] = keysym_to_unicode(kt->shift_map[key]);
for (ok = 0, i = 0; (ok >= 0) && (i < 2); i++) {
if (lkey[i] != U_VOID) {
if (lkey[i] == ckey[i])
ok++;
else if (ckey[i] != U_VOID)
ok = -1;
}
}
if (debug_level('k') > 5)
k_printf("key: % 3d score % 2d for keycode % 3d, %04x %04x, "
"got %04x %04x\n",
key, ok, keyc, lkey[0], lkey[1], ckey[0], ckey[1]);
if (ok > 0) {
score += ok;
break;
}
}
/* count the matches and mismatches */
if (ok > 0) {
match++;
/* and how much the keycode order matches */
if (key > pkey) seq++;
pkey = key;
} else {
/* print spaces instead of \0's */
for (i = 0; i < ARRAY_SIZE(ckey); i++) if (!ckey[i]) ckey[i] = ' ';
mismatch++;
score -= 2;
}
}
}
k_printf("matches=%d, mismatches=%d, seq=%d, score=%d\n",
match, mismatch, seq, score);
if (score > max_score[alternate] ||
(score == max_score[alternate] &&
((seq > max_seq[alternate]) ||
(seq == max_seq[alternate] && kt->keyboard == KEYB_AUTO)))) {
/* best match so far */
if (alternate) {
/* alternate keyboards are optional so a threshold is used */
if (score > 20) config.altkeytable = kt;
}
else
config.keytable = kt;
max_score[alternate] = score;
max_seq[alternate] = seq;
ismatch = !mismatch;
}
alternate = !alternate;
if (!alternate)
kt++;
}
cleanup_charset_state(&X_charset);
#ifndef HAVE_XKB
XFree(key_mapping);
#endif
/* we're done, report results if necessary */
if (!ismatch)
k_printf("Using closest match (%s) for scan/virtual codes mapping.\n",
config.keytable->name);
c_printf("CONF: detected layout is \"%s\"\n", config.keytable->name);
if (config.altkeytable)
c_printf("CONF: detected alternate layout: %s\n", config.altkeytable->name);
XCloseDisplay(display);
return 0;
}
