/**
* Retrieve xkb values from the XKB_RULES_NAMES property and store their
* contents in svValues.
* If the property cannot be read, the built-in defaults are used.
*
* @return True.
*/
Bool
getServerValues(void)
{
XkbRF_VarDefsRec vd;
char *tmp = NULL;
if (!XkbRF_GetNamesProp(dpy, &tmp, &vd) || !tmp)
{
VMSG1(3, "Couldn't interpret %s property\n", _XKB_RF_NAMES_PROP_ATOM);
tmp = DFLT_XKB_RULES_FILE;
vd.model = DFLT_XKB_MODEL;
vd.layout = DFLT_XKB_LAYOUT;
vd.variant = NULL;
vd.options = NULL;
VMSG3(3, "Use defaults: rules - '%s' model - '%s' layout - '%s'\n",
tmp, vd.model, vd.layout);
}
if (tmp)
trySetString(&settings.rules, tmp, FROM_SERVER);
if (vd.model)
trySetString(&settings.model, vd.model, FROM_SERVER);
if (vd.layout)
trySetString(&settings.layout, vd.layout, FROM_SERVER);
if (vd.variant)
trySetString(&settings.variant, vd.variant, FROM_SERVER);
if ((vd.options) && (!clearOptions))
{
addStringToOptions(vd.options, &options);
XFree(vd.options);
}
return True;
}
const TQString
X11Helper::findXkbRulesFile(TQString x11Dir, Display *dpy)
{
TQString rulesFile;
XkbRF_VarDefsRec vd;
char *tmp = NULL;
if (XkbRF_GetNamesProp(dpy, &tmp, &vd) && tmp != NULL ) {
// kdDebug() << "namesprop " << tmp << endl;
rulesFile = x11Dir + TQString("xkb/rules/%1").arg(tmp);
// kdDebug() << "rulesF " << rulesFile << endl;
}
else {
// old way
for(int ii=0; ii<X11_RULES_COUNT; ii++) {
const char* ruleFile = rulesFileList[ii];
TQString xruleFilePath = x11Dir + ruleFile;
// kdDebug() << "trying " << xruleFilePath << endl;
if( TQFile(xruleFilePath).exists() ) {
rulesFile = xruleFilePath;
break;
}
}
}
return rulesFile;
}
unsigned int detect_keyboard_layout_from_xkb(void *dpy)
{
char *layout, *variant;
unsigned int keyboard_layout = 0, group = 0;
XkbRF_VarDefsRec rules_names;
XKeyboardState coreKbdState;
XkbStateRec state;
DEBUG_KBD("display: %p", dpy);
if (dpy && XkbRF_GetNamesProp(dpy, NULL, &rules_names))
{
DEBUG_KBD("layouts: %s", rules_names.layout);
DEBUG_KBD("variants: %s", rules_names.variant);
XGetKeyboardControl(dpy, &coreKbdState);
if (XkbGetState(dpy, XkbUseCoreKbd, &state) == Success)
group = state.group;
DEBUG_KBD("group: %d", state.group);
layout = comma_substring(rules_names.layout, group);
variant = comma_substring(rules_names.variant, group);
DEBUG_KBD("layout: %s", layout);
DEBUG_KBD("variant: %s", variant);
keyboard_layout = find_keyboard_layout_in_xorg_rules(layout, variant);
free(rules_names.model);
free(rules_names.layout);
free(rules_names.variant);
free(rules_names.options);
}
return keyboard_layout;
}
// Reads the contents of the root window property _XKB_RULES_NAMES.
static PyObject * virtkey_get_rules_names(PyObject *self, PyObject *args)
{
PyObject* result = NULL;
virtkey * cvirt = (virtkey *)self;
XkbRF_VarDefsRec vd;
char *tmp = NULL;
Display * display = cvirt->display;
if (XkbRF_GetNamesProp(display, &tmp, &vd) && tmp)
{
result = PyTuple_New(5);
PyTuple_SetItem(result, 0, PyUnicode_FromString(tmp ? tmp : ""));
PyTuple_SetItem(result, 1, PyUnicode_FromString(vd.model ? vd.model : ""));
PyTuple_SetItem(result, 2, PyUnicode_FromString(vd.layout ? vd.layout : ""));
PyTuple_SetItem(result, 3, PyUnicode_FromString(vd.variant ? vd.variant : ""));
PyTuple_SetItem(result, 4, PyUnicode_FromString(vd.options ? vd.options : ""));
}
else
{
result = PyTuple_New(0);
}
return result;
}
static bool
FcitxXkbInitDefaultLayout (QStringList& layout, QStringList& variant)
{
Display* dpy = QX11Info::display();
XkbRF_VarDefsRec vd;
char *tmp = NULL;
if (!XkbRF_GetNamesProp(dpy, &tmp, &vd) || !tmp)
return false;
if (!vd.model || !vd.layout)
return false;
QString variantString, layoutString;
if (vd.layout)
layoutString = vd.layout;
else
layoutString = QString();
if (vd.variant)
variantString = vd.variant;
else
variantString = QString();
layout = layoutString.split(',');
variant = variantString.split(',');
return true;
}
/*
* Use XKB extension and libxkbfile to discover the type of keycodes
* generated by the X keyboard
*/
const char *get_xkb_keycodes (Display *display)
{
char *result = 0;
char *rulesfile = 0;
int32_t major = XkbMajorVersion;
int32_t minor = XkbMinorVersion;
int32_t error = 0;
XkbRF_VarDefsRec vd;
if (!XkbLibraryVersion (&major, &minor)) {
write_log ("X11GFX: Xkb version conflict!\n");
return 0;
}
if (!XkbQueryExtension (display, 0, 0, &error, &major, &minor)) {
printf ("X11GFX: XKB error: %d\n", error);
return 0;
}
if (XkbRF_GetNamesProp (display, &rulesfile, &vd) && rulesfile != 0) {
if (rulesfile[0] == '/') {
char *tmp = malloc (strlen (rulesfile));
if (tmp) {
strcpy (tmp, rulesfile);
rulesfile = tmp;
}
} else {
char *tmp = malloc (strlen (xkb_rules_path) + strlen (rulesfile) + 1);
if (tmp) {
strcpy (tmp, xkb_rules_path);
strcat (tmp, rulesfile);
rulesfile = tmp;
}
}
}
if (rulesfile) {
XkbRF_RulesPtr rules;
if ((rules = XkbRF_Load (rulesfile, 0, True, True))) {
XkbComponentNamesRec names;
XkbRF_GetComponents (rules, &vd, &names);
if (names.keycodes)
result = names.keycodes;
}
}
return result;
}
static QString FcitxXkbGetRulesName()
{
XkbRF_VarDefsRec vd;
char *tmp = NULL;
if (XkbRF_GetNamesProp(QX11Info::display(), &tmp, &vd) && tmp != NULL ) {
return tmp;
}
return QString();
}
void KeyLayout::do_key_layout(void) {
#ifdef HAVE_XKBRULES
char *tmp = NULL;
XkbRF_VarDefsRec vd;
if(XkbRF_GetNamesProp(fl_display, &tmp, &vd)) {
/* do nothing if layout do not exists or the same was catched */
if(!vd.layout || (curr_layout == vd.layout))
return;
/* just store it, so update_flag() can do the rest */
curr_layout = vd.layout;
xkbrf_names_prop_free(vd, tmp);
}
#endif
}
static void fetch_current_layout(String ¤t) {
char *rules_file;
XkbRF_VarDefsRec vd;
/* get the layout straight from X since the layout can be changed during X session */
if(!XkbRF_GetNamesProp(fl_display, &rules_file, &vd)) {
/* use some values */
current = DEFAULT_X_LAYOUT;
} else {
current = vd.layout;
}
/* free everything */
XFree(rules_file);
XFree(vd.layout);
XFree(vd.model);
XFree(vd.options);
XFree(vd.variant);
}
static bool
FcitxXkbInitDefaultOption (QString& model, QString& option)
{
Display* dpy = QX11Info::display();
XkbRF_VarDefsRec vd;
char *tmp = NULL;
if (!XkbRF_GetNamesProp(dpy, &tmp, &vd) || !tmp)
return false;
if (!vd.model || !vd.layout)
return false;
if (vd.model)
model = vd.model;
else
model = QString();
if (vd.options)
option = vd.options;
else
option = QString();
return true;
}
G_MODULE_EXPORT gboolean
remmina_plugin_entry (RemminaPluginService *service)
{
Display *dpy;
XkbRF_VarDefsRec vd;
gchar *s;
remmina_plugin_nx_service = service;
bindtextdomain (GETTEXT_PACKAGE, REMMINA_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
if ((dpy = XkbOpenDisplay (NULL, NULL, NULL, NULL, NULL, NULL)) != NULL)
{
if (XkbRF_GetNamesProp (dpy, NULL, &vd))
{
remmina_kbtype = g_strdup_printf ("%s/%s", vd.model, vd.layout);
if (vd.layout) XFree (vd.layout);
if (vd.model) XFree (vd.model);
if (vd.variant) XFree (vd.variant);
if (vd.options) XFree (vd.options);
s = strchr (remmina_kbtype, ',');
if (s) *s = '\0';
g_print ("NX: detected keyboard type %s\n", remmina_kbtype);
}
XCloseDisplay (dpy);
}
if (! service->register_plugin ((RemminaPlugin *) &remmina_plugin_nx))
{
return FALSE;
}
ssh_init ();
pthread_mutex_init (&remmina_nx_init_mutex, NULL);
remmina_nx_window_id_array = g_array_new (FALSE, TRUE, sizeof (Window));
return TRUE;
}
void XKeyboard::BuildLayout(string_vector& vec) {
XkbRF_VarDefsRec vdr;
int i = 0;
char str[20] = {0};
const char s[2] = ",";
char *token;
char* tmp = NULL;
strcpy(str, (
!_display ? NO_KEYBOARD :
(XkbRF_GetNamesProp(_display, &tmp, &vdr) && vdr.layout) ?
vdr.layout : DFLT_XKB_LAYOUT));
/* get the first token */
token = strtok(str, s);
/* walk through other tokens */
while( token != NULL )
{
vec.push_back(token);
token = strtok(NULL, s);
}
}
static void
get_xkbrf_var_defs (Display *xdisplay,
const char *layouts,
const char *variants,
const char *options,
char **rules_p,
XkbRF_VarDefsRec *var_defs)
{
char *rules = NULL;
/* Get it from the X property or fallback on defaults */
if (!XkbRF_GetNamesProp (xdisplay, &rules, var_defs) || !rules)
{
rules = strdup (DEFAULT_XKB_RULES_FILE);
var_defs->model = strdup (DEFAULT_XKB_MODEL);
var_defs->layout = NULL;
var_defs->variant = NULL;
var_defs->options = NULL;
}
/* Swap in our new options... */
free (var_defs->layout);
var_defs->layout = strdup (layouts);
free (var_defs->variant);
var_defs->variant = strdup (variants);
free (var_defs->options);
var_defs->options = strdup (options);
/* Sometimes, the property is a file path, and sometimes it's
not. Normalize it so it's always a file path. */
if (rules[0] == '/')
*rules_p = g_strdup (rules);
else
*rules_p = g_build_filename (XKB_BASE, "rules", rules, NULL);
free (rules);
}
/**
* gnome_xkb_info_get_var_defs: (skip)
* @rules: (out) (transfer full): location to store the rules file
* path. Use g_free() when it's no longer needed
* @var_defs: (out) (transfer full): location to store a
* #XkbRF_VarDefsRec pointer. Use gnome_xkb_info_free_var_defs() to
* free it
*
* Gets both the XKB rules file path and the current XKB parameters in
* use by the X server.
*
* Since: 3.6
*/
void
gnome_xkb_info_get_var_defs (gchar **rules,
XkbRF_VarDefsRec **var_defs)
{
Display *display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
char *tmp;
g_return_if_fail (rules != NULL);
g_return_if_fail (var_defs != NULL);
*rules = NULL;
*var_defs = g_new0 (XkbRF_VarDefsRec, 1);
gdk_error_trap_push ();
/* Get it from the X property or fallback on defaults */
if (!XkbRF_GetNamesProp (display, rules, *var_defs) || !*rules)
{
*rules = strdup (XKB_RULES_FILE);
(*var_defs)->model = strdup (XKB_MODEL);
(*var_defs)->layout = strdup (XKB_LAYOUT);
(*var_defs)->variant = NULL;
(*var_defs)->options = NULL;
}
gdk_error_trap_pop_ignored ();
tmp = *rules;
if (*rules[0] == '/')
*rules = g_strdup (*rules);
else
*rules = g_build_filename (XKB_BASE, "rules", *rules, NULL);
free (tmp);
}
