frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
xserver/hw/xfree86/utils/xorgcfg/keyboard-cfg.c

1379 lines
39 KiB
C
Raw Blame History

/*
* Copyright (c) 2000 by Conectiva S.A. (http://www.conectiva.com)
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* CONECTIVA LINUX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of Conectiva Linux shall
* not be used in advertising or otherwise to promote the sale, use or other
* dealings in this Software without prior written authorization from
* Conectiva Linux.
*
* Author: Paulo César Pereira de Andrade <pcpa@conectiva.com.br>
*
*/
#include "xf86config.h"
#include "keyboard-cfg.h"
#include <X11/Xaw/Command.h>
#include <X11/Xaw/Form.h>
#include <X11/Xaw/Label.h>
#include <X11/Xaw/MenuButton.h>
#include <X11/Xaw/SimpleMenu.h>
#include <X11/Xaw/SmeBSB.h>
#define IS_KBDDRIV(X) ((strcasecmp((X),"kbd") == 0))
/*
* Types
*/
typedef struct {
char *rules;
XkbRF_RulesPtr list;
XF86XkbDescInfo model;
XF86XkbDescInfo layout;
XF86XkbDescInfo variant;
XF86XkbDescInfo option;
} XF86XkbRulesDescInfo;
/*
* Prototypes
*/
static void KeyboardRulesCallback(Widget, XtPointer, XtPointer);
static void KeyboardModelCallback(Widget, XtPointer, XtPointer);
static void KeyboardLayoutCallback(Widget, XtPointer, XtPointer);
static void KeyboardVariantCallback(Widget, XtPointer, XtPointer);
static void KeyboardOptionsCallback(Widget, XtPointer, XtPointer);
static void KeyboardApplyCallback(Widget, XtPointer, XtPointer);
static Bool KeyboardConfigCheck(void);
static void XkbUIEventHandler(Widget, XtPointer, XEvent*, Boolean*);
static XF86XkbRulesDescInfo *GetXkbRulesDesc(char*);
static void UpdateRulesPopups(void);
/*
* Initialization
*/
static XF86XkbRulesDescInfo **xkb_desc, *xkb_rules;
static int num_xkb_desc;
static char *XkbRulesDir = "share/X11/xkb/rules/";
#ifdef XFREE98_XKB
static char *XkbRulesFile = "xfree98";
#else
static char *XkbRulesFile = __XKBDEFRULES__;
#endif
static XF86ConfInputPtr current_input;
static char *rules, *model, *layout, *variant, *options;
static Widget kbd, rulesb, modelb, layoutb, variantb, optionsb,
modelp, layoutp, variantp, optionsp;
static XkbInfo **xkb_infos;
static int num_xkb_infos;
XkbInfo *xkb_info;
static Widget apply;
/*
* Implementation
*/
/*ARGSUSED*/
XtPointer
KeyboardConfig(XtPointer config)
{
XF86ConfInputPtr keyboard = (XF86ConfInputPtr)config;
XF86OptionPtr option;
Arg args[1];
static char *XkbRules = "XkbRules", *XkbModel = "XkbModel",
*XkbLayout = "XkbLayout", *XkbVariant = "XkbVariant",
*XkbOptions = "XkbOptions";
XF86XkbRulesDescInfo *info;
char *omodel, *olayout, *ovariant, *ooptions;
InitializeKeyboard();
rules = xkb_rules->rules;
if (xkb_info->config.rules_file == NULL)
xkb_info->config.rules_file = rules;
if (options)
XtFree(options);
options = NULL;
if (xkb_info->conf == NULL)
xkb_info->conf = keyboard;
if (xkb_info->conf != keyboard) {
int i;
for (i = 0; i < num_xkb_infos; i++)
if (xkb_infos[i]->conf == keyboard) {
xkb_info = xkb_infos[i];
break;
}
if (i >= num_xkb_infos) {
int timeout = 10;
xkb_info = (XkbInfo*)XtCalloc(1, sizeof(XkbInfo));
xkb_info->conf = keyboard;
xkb_infos = (XkbInfo**)
XtRealloc((XtPointer)xkb_infos, sizeof(XkbInfo*) *
(num_xkb_infos + 1));
xkb_infos[num_xkb_infos++] = xkb_info;
xkb_info->conf = keyboard;
bzero((char*)&(xkb_info->defs), sizeof(XkbRF_VarDefsRec));
while (timeout > 0) {
xkb_info->xkb =
XkbGetKeyboard(XtDisplay(configp),
XkbGBN_AllComponentsMask, XkbUseCoreKbd);
if (xkb_info->xkb == NULL) {
timeout -= 1;
sleep(1);
}
else
break;
}
if (timeout <= 0) {
fprintf(stderr, "Couldn't get keyboard\n");
}
if (xkb_info->xkb && xkb_info->xkb->names && xkb_info->xkb->geom &&
xkb_info->xkb->names->geometry == 0)
xkb_info->xkb->names->geometry = xkb_info->xkb->geom->name;
}
/* check for removed devices */
for (i = 0; i < num_xkb_infos; i++) {
XF86ConfInputPtr key = XF86Config->conf_input_lst;
while (key != NULL) {
if (IS_KBDDRIV(key->inp_driver) && xkb_infos[i]->conf == key)
break;
key = (XF86ConfInputPtr)(key->list.next);
}
if (xkb_infos[i]->conf != NULL && key == NULL) {
XkbFreeKeyboard(xkb_infos[i]->xkb, 0, False);
XtFree((XtPointer)xkb_infos[i]);
if (--num_xkb_infos > i)
memmove(&xkb_infos[i], &xkb_infos[i + 1],
(num_xkb_infos - i) * sizeof(XkbInfo*));
}
}
}
current_input = keyboard;
if (keyboard != NULL) {
if ((option = xf86findOption(keyboard->inp_option_lst, XkbRules)) != NULL) {
if (strcmp(rules, option->opt_val)) {
XF86XkbRulesDescInfo *info = GetXkbRulesDesc(option->opt_val);
if (info) {
rules = info->rules;
UpdateRulesPopups();
}
}
}
if ((option = xf86findOption(keyboard->inp_option_lst, XkbModel)) != NULL)
xkb_info->defs.model = model = option->opt_val;
else
xkb_info->defs.model = model = xkb_rules->model.name[0];
if ((option = xf86findOption(keyboard->inp_option_lst, XkbLayout)) != NULL)
xkb_info->defs.layout = layout = option->opt_val;
else
xkb_info->defs.layout = layout = xkb_rules->layout.name[0];
if ((option = xf86findOption(keyboard->inp_option_lst, XkbVariant)) != NULL)
xkb_info->defs.variant = variant = option->opt_val;
else
xkb_info->defs.variant = variant = NULL;
if ((option = xf86findOption(keyboard->inp_option_lst, XkbOptions)) != NULL)
xkb_info->defs.options = options = XtNewString(option->opt_val);
else
xkb_info->defs.options = options = NULL;
XtSetArg(args[0], XtNstring, keyboard->inp_identifier);
XtSetValues(ident_widget, args, 1);
(void)UpdateKeyboard(False);
}
else {
XF86ConfInputPtr input = XF86Config->conf_input_lst;
char keyboard_name[48];
int nkeyboards = 0;
while (input != NULL) {
if (IS_KBDDRIV(input->inp_driver))
++nkeyboards;
input = (XF86ConfInputPtr)(input->list.next);
}
do {
XmuSnprintf(keyboard_name, sizeof(keyboard_name),
"Keyboard%d", nkeyboards);
++nkeyboards;
} while (xf86findInput(keyboard_name,
XF86Config->conf_input_lst));
model = xkb_rules->model.name[0];
layout = xkb_rules->layout.name[0];
variant = "";
options = XtNewString("");
XtSetArg(args[0], XtNstring, keyboard_name);
XtSetValues(ident_widget, args, 1);
}
info = xkb_rules;
omodel = model;
olayout = layout;
ovariant = variant;
ooptions = options ? XtNewString(options) : NULL;
xf86info.cur_list = KEYBOARD;
XtSetSensitive(back, xf86info.lists[KEYBOARD].cur_function > 0);
XtSetSensitive(next, xf86info.lists[KEYBOARD].cur_function <
xf86info.lists[KEYBOARD].num_functions - 1);
(xf86info.lists[KEYBOARD].functions[xf86info.lists[KEYBOARD].cur_function])
(&xf86info);
if (ConfigLoop(KeyboardConfigCheck) == True) {
if (keyboard == NULL) {
keyboard = XtNew(XF86ConfInputRec);
keyboard->list.next = NULL;
keyboard->inp_identifier = XtNewString(ident_string);
keyboard->inp_driver = XtNewString("kbd");
keyboard->inp_option_lst = xf86newOption(XtNewString(XkbRules),
XtNewString(rules));
xf86addNewOption(keyboard->inp_option_lst,
XtNewString(XkbModel), XtNewString(model));
xf86addNewOption(keyboard->inp_option_lst,
XtNewString(XkbLayout), XtNewString(layout));
if (variant && *variant)
xf86addNewOption(keyboard->inp_option_lst,
XtNewString(XkbVariant), XtNewString(variant));
if (options && *options) {
xf86addNewOption(keyboard->inp_option_lst,
XtNewString(XkbOptions), options);
options = NULL;
}
keyboard->inp_comment = NULL;
}
else {
int i;
char *str;
XtSetArg(args[0], XtNlabel, &str);
XtGetValues(modelb, args, 1);
for (i = 0; i < xkb_rules->model.nelem; i++)
if (strcmp(xkb_rules->model.desc[i], str) == 0) {
model = xkb_rules->model.name[i];
break;
}
XtSetArg(args[0], XtNlabel, &str);
XtGetValues(layoutb, args, 1);
for (i = 0; i < xkb_rules->layout.nelem; i++)
if (strcmp(xkb_rules->layout.desc[i], str) == 0) {
layout = xkb_rules->layout.name[i];
break;
}
if ((option = xf86findOption(keyboard->inp_option_lst, XkbRules))
!= NULL) {
XtFree(option->opt_val);
option->opt_val = XtNewString(rules);
XtFree(option->opt_comment);
option->opt_comment = NULL;
}
else
keyboard->inp_option_lst =
xf86addNewOption(keyboard->inp_option_lst,
XtNewString(XkbRules), XtNewString(rules));
if ((option = xf86findOption(keyboard->inp_option_lst, XkbModel))
!= NULL) {
XtFree(option->opt_val);
option->opt_val = XtNewString(model);
XtFree(option->opt_comment);
option->opt_comment = NULL;
}
else
keyboard->inp_option_lst =
xf86addNewOption(keyboard->inp_option_lst,
XtNewString(XkbModel), XtNewString(model));
XtFree(xkb_info->config.model);
xkb_info->config.model = XtNewString(model);
if ((option = xf86findOption(keyboard->inp_option_lst, XkbLayout))
!= NULL) {
XtFree(option->opt_val);
option->opt_val = XtNewString(layout);
}
else
keyboard->inp_option_lst =
xf86addNewOption(keyboard->inp_option_lst,
XtNewString(XkbLayout), XtNewString(layout));
XtFree(xkb_info->config.layout);
xkb_info->config.layout = XtNewString(layout);
if ((option = xf86findOption(keyboard->inp_option_lst, XkbVariant))
!= NULL) {
if (variant && *variant) {
XtFree(option->opt_val);
option->opt_val = XtNewString(variant);
}
else
xf86removeOption(&keyboard->inp_option_lst, XkbVariant);
}
else if (variant && *variant)
xf86addNewOption(keyboard->inp_option_lst,
XtNewString(XkbVariant), XtNewString(variant));
XtFree(xkb_info->config.variant);
xkb_info->config.variant = variant && *variant ?
XtNewString(variant) : NULL;
XtFree(xkb_info->config.options);
xkb_info->config.options = options && *options ?
XtNewString(options) : NULL;
if ((option = xf86findOption(keyboard->inp_option_lst, XkbOptions))
!= NULL) {
if (options && *options) {
XtFree(option->opt_val);
option->opt_val = options;
options = NULL;
}
else
xf86removeOption(&keyboard->inp_option_lst, XkbOptions);
}
else if (options && *options) {
xf86addNewOption(keyboard->inp_option_lst,
XtNewString(XkbOptions), options);
options = NULL;
}
}
if (strcasecmp(keyboard->inp_identifier, ident_string))
xf86renameInput(XF86Config, keyboard, ident_string);
xkb_info->conf = keyboard;
xkb_info->config.rules_file = rules;
return ((XtPointer)keyboard);
}
xkb_rules = info;
rules = info->rules;
model = omodel;
layout = olayout;
variant = ovariant;
XtFree(options);
options = ooptions;
return (NULL);
}
static Bool
KeyboardConfigCheck(void)
{
XF86ConfInputPtr keyboard = XF86Config->conf_input_lst;
while (keyboard != NULL) {
if (keyboard != current_input &&
strcasecmp(ident_string, keyboard->inp_identifier) == 0)
return (False);
keyboard = (XF86ConfInputPtr)(keyboard->list.next);
}
return (True);
}
/*ARGSUSED*/
static void
XkbUIEventHandler(Widget w, XtPointer closure,
XEvent *event, Boolean *continue_to_dispatch)
{
XkbUI_ViewOptsRec opts;
XkbUI_ViewPtr view;
int width, height, bd;
if (event->xexpose.count > 1)
return;
bzero((char *)&opts, sizeof(opts));
bd = 1;
opts.present = XkbUI_SizeMask | XkbUI_ColormapMask |
XkbUI_MarginMask | XkbUI_OffsetMask;
opts.margin_width = opts.margin_height = 0;
opts.viewport.x = opts.viewport.y = bd;
width = opts.viewport.width = w->core.width - 2 * bd;
height = opts.viewport.height = w->core.height - 2 * bd;
opts.cmap = w->core.colormap;
if ((view = XkbUI_Init(XtDisplay(w), XtWindow(w), width, height,
xkb_info->xkb, &opts)) != NULL) {
XkbUI_DrawRegion(view, NULL);
free(view);
}
}
void
InitializeKeyboard(void)
{
int major, minor, op, event, error;
static int first = 1;
int timeout = 5;
XF86ConfInputPtr keyboard = XF86Config->conf_input_lst;
XF86OptionPtr option;
char name[PATH_MAX];
FILE *file;
if (!first)
return;
first = 0;
major = XkbMajorVersion;
minor = XkbMinorVersion;
if (XkbQueryExtension(DPY, &op, &event, &error, &major, &minor) == 0) {
fprintf(stderr, "Unable to initialize XKEYBOARD extension");
exit(1);
}
xkb_info = (XkbInfo *)XtCalloc(1, sizeof(XkbInfo));
xkb_info->conf = NULL;
xkb_infos = (XkbInfo**)XtCalloc(1, sizeof(XkbInfo*));
num_xkb_infos = 1;
xkb_infos[0] = xkb_info;
bzero((char*)&(xkb_info->defs), sizeof(XkbRF_VarDefsRec));
while (timeout > 0) {
xkb_info->xkb =
XkbGetKeyboard(DPY, XkbGBN_AllComponentsMask, XkbUseCoreKbd);
if (xkb_info->xkb == NULL) {
timeout -= 1;
sleep(1);
}
else
break;
}
if (timeout <= 0) {
fprintf(stderr, "Couldn't get keyboard\n");
}
if (xkb_info->xkb && xkb_info->xkb->names && xkb_info->xkb->geom &&
xkb_info->xkb->names->geometry == 0)
xkb_info->xkb->names->geometry = xkb_info->xkb->geom->name;
/* Load configuration */
XmuSnprintf(name, sizeof(name), "%s%s", XkbConfigDir, XkbConfigFile);
file = fopen(name, "r");
if (file != NULL) {
if (XkbCFParse(file, XkbCFDflts, xkb_info->xkb, &xkb_info->config) == 0) {
fprintf(stderr, "Error parsing config file: ");
XkbCFReportError(stderr, name, xkb_info->config.error,
xkb_info->config.line);
}
fclose(file);
}
xkb_rules = GetXkbRulesDesc(xkb_info->config.rules_file != NULL ?
xkb_info->config.rules_file : XkbRulesFile);
if (xkb_rules == NULL)
/* error message was printed */
exit(1);
/* XXX Assumes the first keyboard is the core keyboard */
while (keyboard != NULL) {
if (IS_KBDDRIV(keyboard->inp_driver))
break;
keyboard = (XF86ConfInputPtr)(keyboard->list.next);
}
if (keyboard == NULL)
return;
if (xkb_info->config.rules_file != NULL)
rules = xkb_info->config.rules_file;
else if ((option = xf86findOption(keyboard->inp_option_lst, "XkbRules"))
!= NULL)
rules = option->opt_val;
else
rules = XkbRulesFile;
if (strcmp(rules, xkb_rules->rules)) {
xkb_rules = GetXkbRulesDesc(rules);
if (xkb_rules == NULL)
/* error message was printed */
exit(1);
}
{
FILE *fp;
char filename[1024];
XmuSnprintf(filename, sizeof(filename), "%s%s",
XkbRulesDir, xkb_rules->rules);
if ((fp = fopen(filename, "r")) == NULL) {
fprintf(stderr, "Can't open rules file\n");
exit(1);
}
if (!XkbRF_LoadRules(fp, xkb_rules->list)) {
fclose(fp);
fprintf(stderr, "Can't load rules\n");
exit(1);
}
fclose(fp);
}
if (xkb_info->config.rules_file == NULL)
xkb_info->config.rules_file = xkb_rules->rules;
if (xkb_info->config.model != NULL)
xkb_info->defs.model = xkb_info->config.model;
else if ((option = xf86findOption(keyboard->inp_option_lst, "XkbModel"))
!= NULL)
xkb_info->defs.model = option->opt_val;
else
xkb_info->defs.model = xkb_rules->model.name[0];
if (xkb_info->config.layout != NULL)
xkb_info->defs.layout = xkb_info->config.layout;
else if ((option = xf86findOption(keyboard->inp_option_lst, "XkbLayout"))
!= NULL)
xkb_info->defs.layout = option->opt_val;
else
xkb_info->defs.layout = xkb_rules->layout.name[0];
if (xkb_info->config.variant != NULL)
xkb_info->defs.variant = xkb_info->config.variant;
else if ((option = xf86findOption(keyboard->inp_option_lst, "XkbVariant"))
!= NULL)
xkb_info->defs.variant = option->opt_val;
else
xkb_info->defs.variant = NULL;
if (xkb_info->config.options != NULL)
xkb_info->defs.options = xkb_info->config.options;
else if ((option = xf86findOption(keyboard->inp_option_lst, "XkbOptions"))
!= NULL)
xkb_info->defs.options = option->opt_val;
else
xkb_info->defs.options = NULL;
if (xkb_info->xkb == NULL) {
/* Try again */
XkbComponentNamesRec comps;
bzero((char*)&comps, sizeof(XkbComponentNamesRec));
XkbRF_GetComponents(xkb_rules->list, &(xkb_info->defs), &comps);
xkb_info->xkb = XkbGetKeyboardByName(DPY, XkbUseCoreKbd, &comps,
XkbGBN_AllComponentsMask, 0, 0);
}
}
static XF86XkbRulesDescInfo *
GetXkbRulesDesc(char *rules)
{
int i;
XkbRF_RulesPtr list;
char filename[1024];
XF86XkbRulesDescInfo *info;
if (rules == NULL)
return (NULL);
for (i = 0; i < num_xkb_desc; i++)
if (strcmp(rules, xkb_desc[i]->rules) == 0)
return (xkb_desc[i]);
XmuSnprintf(filename, sizeof(filename), "%s%s", XkbRulesDir, rules);
if ((list = XkbRF_Create(0, 0)) == NULL ||
!XkbRF_LoadDescriptionsByName(filename, NULL, list)) {
fprintf(stderr, "Can't create rules structure\n");
return (NULL);
}
info = (XF86XkbRulesDescInfo*)XtCalloc(1, sizeof(XF86XkbRulesDescInfo));
xkb_desc = (XF86XkbRulesDescInfo**)
XtRealloc((XtPointer)xkb_desc,
sizeof(XF86XkbRulesDescInfo*) * (num_xkb_desc + 1));
xkb_desc[num_xkb_desc++] = info;
info->rules = XtNewString(rules);
for (i = 0; i < list->models.num_desc; i++) {
if (i % 16 == 0) {
info->model.name = (char**)XtRealloc((XtPointer)info->model.name,
(i + 16) * sizeof(char*));
info->model.desc = (char**)XtRealloc((XtPointer)info->model.desc,
(i + 16) * sizeof(char*));
}
info->model.name[i] = XtNewString(list->models.desc[i].name);
info->model.desc[i] = XtNewString(list->models.desc[i].desc);
}
info->model.nelem = i;
for (i = 0; i < list->layouts.num_desc; i++) {
if (i % 16 == 0) {
info->layout.name = (char**)XtRealloc((XtPointer)info->layout.name,
(i + 16) * sizeof(char*));
info->layout.desc = (char**)XtRealloc((XtPointer)info->layout.desc,
(i + 16) * sizeof(char*));
}
info->layout.name[i] = XtNewString(list->layouts.desc[i].name);
info->layout.desc[i] = XtNewString(list->layouts.desc[i].desc);
}
info->layout.nelem = i;
for (i = 0; i < list->variants.num_desc; i++) {
if (i % 16 == 0) {
info->variant.name = (char**)XtRealloc((XtPointer)info->variant.name,
(i + 16) * sizeof(char*));
info->variant.desc = (char**)XtRealloc((XtPointer)info->variant.desc,
(i + 16) * sizeof(char*));
}
info->variant.name[i] = XtNewString(list->variants.desc[i].name);
info->variant.desc[i] = XtNewString(list->variants.desc[i].desc);
}
info->variant.nelem = i;
for (i = 0; i < list->options.num_desc; i++) {
if (i % 16 == 0) {
info->option.name = (char**)XtRealloc((XtPointer)info->option.name,
(i + 16) * sizeof(char*));
info->option.desc = (char**)XtRealloc((XtPointer)info->option.desc,
(i + 16) * sizeof(char*));
}
info->option.name[i] = XtNewString(list->options.desc[i].name);
info->option.desc[i] = XtNewString(list->options.desc[i].desc);
}
info->option.nelem = i;
info->list = list;
return (info);
}
static xf86ConfigSymTabRec ax_controls[] =
{
{XkbRepeatKeysMask, "RepeatKeys"},
{XkbSlowKeysMask, "SlowKeys"},
{XkbBounceKeysMask, "BounceKeys"},
{XkbStickyKeysMask, "StickyKeys"},
{XkbMouseKeysMask, "MouseKeys"},
{XkbMouseKeysAccelMask, "MouseKeysAccel"},
{XkbAccessXKeysMask, "AccessxKeys"},
{XkbAccessXTimeoutMask, "AccessxTimeout"},
{XkbAccessXFeedbackMask, "AccessxFeedback"},
{XkbAudibleBellMask, "AudibleBell"},
{XkbOverlay1Mask, "Overlay1"},
{XkbOverlay2Mask, "Overlay2"},
{XkbIgnoreGroupLockMask, "IgnoreGroupLock"},
{-1, ""},
};
static xf86ConfigSymTabRec ax_feedback[] =
{
{XkbAX_SKPressFBMask, "SlowKeysPress"},
{XkbAX_SKAcceptFBMask, "SlowKeysAccept"},
{XkbAX_FeatureFBMask, "Feature"},
{XkbAX_SlowWarnFBMask, "SlowWarn"},
{XkbAX_IndicatorFBMask, "Indicator"},
{XkbAX_StickyKeysFBMask, "StickyKeys"},
{XkbAX_TwoKeysMask, "TwoKeys"},
{XkbAX_LatchToLockMask, "LatchToLock"},
{XkbAX_SKReleaseFBMask, "SlowKeysRelease"},
{XkbAX_SKRejectFBMask, "SlowkeysReject"},
{XkbAX_BKRejectFBMask, "BounceKeysReject"},
{XkbAX_DumbBellFBMask, "DumbBell"},
{-1, ""},
};
Bool
WriteXKBConfiguration(char *filename, XkbConfigRtrnPtr conf)
{
FILE *fp;
int i, count;
if (filename == NULL || conf == NULL ||
(fp = fopen(filename, "w")) == NULL)
return (False);
if (conf->rules_file != NULL)
fprintf(fp, "Rules = \"%s\"\n",
conf->rules_file);
if (conf->model != NULL)
fprintf(fp, "Model = \"%s\"\n",
conf->model);
if (conf->layout != NULL)
fprintf(fp, "Layout = \"%s\"\n",
conf->layout);
if (conf->variant != NULL)
fprintf(fp, "Variant = \"%s\"\n",
conf->variant);
if (conf->options != NULL)
fprintf(fp, "Options = \"%s\"\n",
conf->options);
if (conf->keymap != NULL)
fprintf(fp, "Keymap = %s\n",
conf->keymap);
if (conf->keycodes != NULL)
fprintf(fp, "Keycodes = %s\n",
conf->keycodes);
if (conf->geometry != NULL)
fprintf(fp, "Geometry = %s\n",
conf->geometry);
if (conf->phys_symbols != NULL)
fprintf(fp, "RealSymbols = %s\n",
conf->phys_symbols);
if (conf->symbols != NULL)
fprintf(fp, "Symbols = %s\n",
conf->symbols);
if (conf->types != NULL)
fprintf(fp, "Types = %s\n",
conf->types);
if (conf->compat != NULL)
fprintf(fp, "Compat = %s\n",
conf->compat);
if (conf->click_volume > 0)
fprintf(fp, "ClickVolume = %d\n",
conf->click_volume);
if (conf->bell_volume > 0)
fprintf(fp, "BellVolume = %d\n",
conf->bell_volume);
if (conf->bell_pitch > 0)
fprintf(fp, "BellPitch = %d\n",
conf->bell_pitch);
if (conf->bell_duration > 0)
fprintf(fp, "BellDuration = %d\n",
conf->bell_duration);
if (conf->repeat_delay > 0)
fprintf(fp, "RepeatDelay = %d\n",
conf->repeat_delay);
if (conf->repeat_interval > 0)
fprintf(fp, "RepeatInterval = %d\n",
conf->repeat_interval);
if (conf->slow_keys_delay > 0)
fprintf(fp, "SlowKeysDelay = %d\n",
conf->slow_keys_delay);
if (conf->debounce_delay > 0)
fprintf(fp, "DebounceDelay = %d\n",
conf->debounce_delay);
if (conf->mk_delay > 0)
fprintf(fp, "MouseKeysDelay = %d\n",
conf->mk_delay);
if (conf->mk_interval > 0)
fprintf(fp, "MouseKeysInterval = %d\n",
conf->mk_interval);
if (conf->mk_time_to_max > 0)
fprintf(fp, "MouseKeysTimeToMax = %d\n",
conf->mk_time_to_max);
if (conf->mk_max_speed > 0)
fprintf(fp, "MouseKeysMaxSpeed = %d\n",
conf->mk_max_speed);
fprintf(fp, "MouseKeysCurve = %d\n", conf->mk_curve);
if (conf->ax_timeout)
fprintf(fp, "AccessXTimeout = %d\n",
conf->ax_timeout);
if (conf->initial_ctrls != 0) {
fprintf(fp, "Controls %c= ",
conf->replace_initial_ctrls ? ' ' : '+');
for (i = count = 0; *ax_controls[i].name; i++)
if ((conf->initial_ctrls & ax_controls[i].token)
== ax_controls[i].token)
fprintf(fp, "%s%s", count++ ? " + " : "",
ax_controls[i].name);
fprintf(fp, "\n");
}
if (conf->axt_ctrls_on != 0) {
fprintf(fp, "AcessXTimeoutCtrlsOn %c= ",
conf->replace_axt_ctrls_on ? ' ' : '+');
for (i = count = 0; *ax_controls[i].name; i++)
if ((conf->axt_ctrls_on & ax_controls[i].token)
== ax_controls[i].token)
fprintf(fp, "%s%s", count++ ? " + " : "",
ax_controls[i].name);
fprintf(fp, "\n");
}
if (conf->axt_ctrls_off != 0) {
fprintf(fp, "AcessXTimeoutCtrlsOff %c= ",
conf->replace_axt_ctrls_off ? ' ' : '-');
for (i = count = 0; *ax_controls[i].name; i++)
if ((conf->axt_ctrls_off & ax_controls[i].token)
== ax_controls[i].token)
fprintf(fp, "%s%s", count++ ? " + " : "",
ax_controls[i].name);
fprintf(fp, "\n");
}
if (conf->initial_opts != 0) {
fprintf(fp, "Feedback %c= ",
conf->replace_initial_opts ? ' ' : '+');
for (i = count = 0; *ax_feedback[i].name; i++)
if ((conf->initial_opts & ax_feedback[i].token)
== ax_feedback[i].token)
fprintf(fp, "%s%s", count++ ? " + " : "",
ax_feedback[i].name);
fprintf(fp, "\n");
}
if (conf->axt_opts_on != 0) {
fprintf(fp, "AcessXTimeoutFeedbackOn %c= ",
conf->replace_axt_opts_on ? ' ' : '+');
for (i = count = 0; *ax_controls[i].name; i++)
if ((conf->axt_opts_on & ax_feedback[i].token)
== ax_feedback[i].token)
fprintf(fp, "%s%s", count++ ? " + " : "",
ax_feedback[i].name);
fprintf(fp, "\n");
}
if (conf->axt_opts_off != 0) {
fprintf(fp, "AcessXTimeoutFeedbackOff%c= ",
conf->replace_axt_opts_off ? ' ' : '-');
for (i = count = 0; *ax_feedback[i].name; i++)
if ((conf->axt_opts_off & ax_feedback[i].token)
== ax_feedback[i].token)
fprintf(fp, "%s%s", count++ ? " + " : "",
ax_feedback[i].name);
fprintf(fp, "\n");
}
fclose(fp);
return (True);
}
Bool
UpdateKeyboard(Bool load)
{
XkbComponentNamesRec comps;
XkbDescPtr xkb;
bzero((char*)&comps, sizeof(XkbComponentNamesRec));
XkbRF_GetComponents(xkb_rules->list, &(xkb_info->defs), &comps);
xkb = XkbGetKeyboardByName(DPY, XkbUseCoreKbd, &comps,
XkbGBN_AllComponentsMask, 0, load);
if (xkb == NULL || xkb->geom == NULL) {
fprintf(stderr, "Couldn't get keyboard\n");
return (False);
}
if (xkb_info->xkb && xkb_info->xkb->names && xkb_info->xkb->geom &&
xkb_info->xkb->names->geometry == 0)
xkb_info->xkb->names->geometry = xkb_info->xkb->geom->name;
XkbFreeKeyboard(xkb_info->xkb, 0, False);
xkb_info->xkb = xkb;
XtFree(comps.keymap);
XtFree(comps.keycodes);
XtFree(comps.compat);
XtFree(comps.types);
XtFree(comps.symbols);
XtFree(comps.geometry);
if (kbd != NULL)
XClearArea(XtDisplay(configp), XtWindow(kbd), 0, 0, 0, 0, True);
return (True);
}
static void
KeyboardRulesCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
int i;
FILE *fp;
Arg args[1];
char filename[1024], *omodel, *olayout, *ovariant, *ooptions,
*dmodel, *dlayout, *dvariant;
XF86XkbRulesDescInfo *oxkb_rules, *info = GetXkbRulesDesc(XtName(w));
if (strcmp(XtName(w), rules) == 0 || info == NULL)
/* a error message was printed */
return;
XmuSnprintf(filename, sizeof(filename), "%s%s",
XkbRulesDir, info->rules);
if ((fp = fopen(filename, "r")) == NULL) {
fprintf(stderr, "Can't open rules file\n");
return;
}
if (!XkbRF_LoadRules(fp, info->list)) {
fclose(fp);
fprintf(stderr, "Can't load rules\n");
return;
}
fclose(fp);
oxkb_rules = xkb_rules;
omodel = xkb_info->defs.model;
olayout = xkb_info->defs.layout;
ovariant = xkb_info->defs.variant;
ooptions = xkb_info->defs.options;
if (omodel) {
for (i = 0; i < info->model.nelem; i++) {
if (strcmp(omodel, info->model.name[i]) == 0)
break;
}
}
else
i = 0;
model = xkb_info->defs.model = info->model.name
[i < info->model.nelem ? i : 0];
dmodel = info->model.desc[i < info->model.nelem ? i : 0];
if (olayout) {
for (i = 0; i < info->layout.nelem; i++) {
if (strcmp(olayout, info->layout.name[i]) == 0)
break;
}
}
else
i = 0;
layout = xkb_info->defs.layout = info->layout.name
[i < info->layout.nelem ? i : 0];
dlayout = info->layout.desc[i < info->layout.nelem ? i : 0];
if (ovariant) {
for (i = 0; i < info->variant.nelem; i++) {
if (strcmp(ovariant, info->variant.name[i]) == 0)
break;
}
}
else
i = info->variant.nelem;
variant = xkb_info->defs.variant = i < info->variant.nelem ?
info->variant.name[i] : NULL;
dvariant = i < info->variant.nelem ?
info->variant.desc[i] : NULL;
if (ooptions) {
char *ptr, *tmp = XtNewString(options);
for (ptr = strtok(tmp, ","); ptr != NULL; ptr = strtok(NULL, ",")) {
if (strchr(ptr, ':') == NULL)
continue;
for (i = 0; i < xkb_rules->option.nelem; i++)
if (strcmp(xkb_rules->option.name[i], ptr) == 0)
break;
if (i == xkb_rules->option.nelem) {
XtFree(options);
options = NULL;
/* no option with the same name */
break;
}
}
XtFree(tmp);
}
else {
XtFree(options);
options = NULL;
}
oxkb_rules = xkb_rules;
xkb_rules = info;
rules = info->rules;
if (!UpdateKeyboard(False)) {
model = xkb_info->defs.model = omodel;
layout = xkb_info->defs.layout = olayout;
variant = xkb_info->defs.variant = ovariant;
options = XtNewString(xkb_info->defs.options = ooptions);
xkb_rules = oxkb_rules;
rules = xkb_rules->rules;
XmuSnprintf(filename, sizeof(filename), "%s%s",
XkbRulesDir, rules);
if ((fp = fopen(filename, "r")) == NULL) {
fprintf(stderr, "Can't open rules file\n");
return;
}
if (!XkbRF_LoadRules(fp, xkb_rules->list)) {
fprintf(stderr, "Can't load rules\n");
}
fclose(fp);
return;
}
UpdateRulesPopups();
XtSetArg(args[0], XtNlabel, rules);
XtSetValues(rulesb, args, 1);
XtSetArg(args[0], XtNlabel, dmodel);
XtSetValues(modelb, args, 1);
XtSetArg(args[0], XtNlabel, dlayout);
XtSetValues(layoutb, args, 1);
XtSetArg(args[0], XtNlabel, dvariant ? dvariant : "");
XtSetValues(variantb, args, 1);
XtSetArg(args[0], XtNlabel, options ? options : "");
XtSetValues(variantb, args, 1);
}
static void
KeyboardModelCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
Arg args[1];
int i;
char *oldval = xkb_info->defs.model;
for (i = 0; i < xkb_rules->model.nelem; i++)
if (strcmp(XtName(w), xkb_rules->model.name[i]) == 0)
break;
model = xkb_info->defs.model = xkb_rules->model.name[i];
if (!UpdateKeyboard(False))
model = xkb_info->defs.model = oldval;
else {
XtSetArg(args[0], XtNlabel, xkb_rules->model.desc[i]);
XtSetValues(modelb, args, 1);
}
}
static void
KeyboardLayoutCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
Arg args[1];
int i;
char *oldval = xkb_info->defs.layout;
for (i = 0; i < xkb_rules->layout.nelem; i++)
if (strcmp(XtName(w), xkb_rules->layout.name[i]) == 0)
break;
layout = xkb_info->defs.layout = xkb_rules->layout.name[i];
if (!UpdateKeyboard(False))
layout = xkb_info->defs.layout = oldval;
else {
XtSetArg(args[0], XtNlabel, xkb_rules->layout.desc[i]);
XtSetValues(layoutb, args, 1);
}
}
static void
KeyboardVariantCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
Arg args[1];
int i;
char *label, *oldval = xkb_info->defs.variant;
for (i = 0; i < xkb_rules->variant.nelem; i++)
if (strcmp(XtName(w), xkb_rules->variant.name[i]) == 0)
break;
variant = i < xkb_rules->variant.nelem ? xkb_rules->variant.name[i] : "";
xkb_info->defs.variant = variant && *variant ? variant : NULL;
if (!UpdateKeyboard(False))
xkb_info->defs.variant = variant = oldval;
else {
label = i < xkb_rules->variant.nelem ? xkb_rules->variant.desc[i] : "";
XtSetArg(args[0], XtNlabel, label);
XtSetValues(variantb, args, 1);
}
}
static void
KeyboardOptionsCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
Arg args[1];
int i;
for (i = 0; i < xkb_rules->option.nelem; i++)
if (strcmp(XtName(w), xkb_rules->option.name[i]) == 0)
break;
if (i < xkb_rules->option.nelem) {
char *delim, *ptr, str[256];
/* remove old string, don't check if the same */
if ((delim = strchr(XtName(w), ':')) != NULL) {
if (delim - XtName(w) >= sizeof(str) - 2)
return;
strncpy(str, XtName(w), delim - XtName(w) + 1);
str[delim - XtName(w) + 1] = '\0';
}
else
XmuSnprintf(str, sizeof(str), "%s:", XtName(w));
if (options && (delim = strstr(options, str)) != NULL) {
if ((ptr = strchr(delim, ',')) != NULL) {
*delim = *ptr = '\0';
XmuSnprintf(str, sizeof(str), "%s%s", options, ptr + 1);
XtFree(options);
options = XtNewString(str);
}
else {
if (delim > options)
delim[-1] = '\0';
else
delim[0] = '\0';
}
}
/* update string, if required */
if ((delim = strchr(XtName(w), ':')) != NULL) {
if (options && *options)
XmuSnprintf(str, sizeof(str), "%s,%s", options, XtName(w));
else
XmuSnprintf(str, sizeof(str), "%s", XtName(w));
XtFree(options);
options = XtNewString(str);
}
}
else {
XtFree(options);
options = XtNewString("");
}
if (options == NULL)
options = XtNewString("");
xkb_info->defs.options = options;
if (!UpdateKeyboard(False)) {
*options = '\0';
xkb_info->defs.options = NULL;
}
XtSetArg(args[0], XtNlabel, options);
XtSetValues(optionsb, args, 1);
XtSetArg(args[0], XtNtip, options);
XtSetValues(optionsb, args, 1);
}
/*ARGSUSED*/
static void
KeyboardApplyCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
(void)UpdateKeyboard(True);
}
static void
UpdateRulesPopups(void)
{
int i;
char *optname;
Widget sme, optpopup = NULL, optparent;
/* MODEL */
if (modelp)
XtDestroyWidget(modelp);
modelp = XtCreatePopupShell("modelP", simpleMenuWidgetClass,
modelb, NULL, 0);
for (i = 0; i < xkb_rules->model.nelem; i++) {
sme = XtVaCreateManagedWidget(xkb_rules->model.name[i], smeBSBObjectClass,
modelp,
XtNlabel, xkb_rules->model.desc[i],
NULL);
XtAddCallback(sme, XtNcallback, KeyboardModelCallback, NULL);
}
/* LAYOUT */
if (layoutp)
XtDestroyWidget(layoutp);
layoutp = XtCreatePopupShell("layoutP", simpleMenuWidgetClass,
layoutb, NULL, 0);
for (i = 0; i < xkb_rules->layout.nelem; i++) {
sme = XtVaCreateManagedWidget(xkb_rules->layout.name[i], smeBSBObjectClass,
layoutp,
XtNlabel, xkb_rules->layout.desc[i],
NULL);
XtAddCallback(sme, XtNcallback, KeyboardLayoutCallback, NULL);
}
/* VARIANT */
if (variantp)
XtDestroyWidget(variantp);
variantp = XtCreatePopupShell("variantP", simpleMenuWidgetClass,
variantb, NULL, 0);
sme = XtVaCreateManagedWidget("None", smeBSBObjectClass,
variantp,
XtNlabel, "None",
NULL);
XtAddCallback(sme, XtNcallback, KeyboardVariantCallback, NULL);
for (i = 0; i < xkb_rules->variant.nelem; i++) {
sme = XtVaCreateManagedWidget(xkb_rules->variant.name[i], smeBSBObjectClass,
variantp,
XtNlabel, xkb_rules->variant.desc[i],
NULL);
XtAddCallback(sme, XtNcallback, KeyboardVariantCallback, NULL);
}
/* OPTIONS */
if (optionsp)
XtDestroyWidget(optionsp);
optionsp = XtCreatePopupShell("optionsP", simpleMenuWidgetClass,
optionsb, NULL, 0);
sme = XtVaCreateManagedWidget("None", smeBSBObjectClass,
optionsp,
XtNlabel, "None",
NULL);
XtAddCallback(sme, XtNcallback, KeyboardOptionsCallback, NULL);
optparent = optionsp;
optname = NULL;
for (i = 0; i < xkb_rules->option.nelem; i++) {
if (!strchr(xkb_rules->option.name[i], ':')) {
optpopup =
XtCreatePopupShell(optname = xkb_rules->option.desc[i],
simpleMenuWidgetClass,
optparent = optionsp, NULL, 0);
sme = XtVaCreateManagedWidget(xkb_rules->option.name[i],
smeBSBObjectClass,
optpopup,
XtNlabel, "None",
NULL);
XtAddCallback(sme, XtNcallback, KeyboardOptionsCallback, NULL);
}
else {
optparent = optpopup;
optname = NULL;
}
sme = XtVaCreateManagedWidget(xkb_rules->option.name[i], smeBSBObjectClass,
optparent,
XtNlabel, xkb_rules->option.desc[i],
XtNmenuName, optname,
XtNleftBitmap, optname ? menuPixmap : None,
NULL);
if (optparent != optionsp)
XtAddCallback(sme, XtNcallback, KeyboardOptionsCallback, NULL);
}
}
void
KeyboardModelAndLayout(XF86SetupInfo *info)
{
static int first = 1;
static Widget kbdml;
Arg args[1];
int i;
if (first) {
Widget popup, sme;
first = 0;
kbdml = XtCreateWidget("keyboardML", formWidgetClass,
configp, NULL, 0);
/* RULES */
XtCreateManagedWidget("labelR", labelWidgetClass, kbdml, NULL, 0);
rulesb = XtVaCreateManagedWidget("rules", menuButtonWidgetClass, kbdml,
XtNmenuName, "rulesP",
NULL);
popup = XtCreatePopupShell("rulesP", simpleMenuWidgetClass,
rulesb, NULL, 0);
{
struct dirent *ent;
DIR *dir;
if ((dir = opendir(XkbRulesDir)) != NULL) {
(void)readdir(dir);
(void)readdir(dir);
while ((ent = readdir(dir)) != NULL) {
if (strchr(ent->d_name, '.'))
continue;
sme = XtVaCreateManagedWidget(ent->d_name, smeBSBObjectClass,
popup,
XtNlabel, ent->d_name,
NULL);
XtAddCallback(sme, XtNcallback, KeyboardRulesCallback, NULL);
}
closedir(dir);
}
}
/* MODEL */
XtCreateManagedWidget("labelM", labelWidgetClass, kbdml, NULL, 0);
modelb = XtVaCreateManagedWidget("model", menuButtonWidgetClass, kbdml,
XtNmenuName, "modelP",
NULL);
/* LAYOUT */
XtCreateManagedWidget("labelL", labelWidgetClass, kbdml, NULL, 0);
layoutb = XtVaCreateManagedWidget("layout", menuButtonWidgetClass, kbdml,
XtNmenuName, "layoutP",
XtNlabel, xkb_rules->layout.desc[0],
NULL);
/* VARIANT */
XtCreateManagedWidget("labelV", labelWidgetClass, kbdml, NULL, 0);
variantb = XtVaCreateManagedWidget("variant", menuButtonWidgetClass, kbdml,
XtNmenuName, "variantP",
XtNlabel, "",
NULL);
/* OPTIONS */
XtCreateManagedWidget("labelO", labelWidgetClass, kbdml, NULL, 0);
optionsb = XtVaCreateManagedWidget("options", menuButtonWidgetClass, kbdml,
XtNmenuName, "optionsP",
XtNlabel, "",
NULL);
UpdateRulesPopups();
kbd = XtCreateManagedWidget("keyboard", coreWidgetClass,
kbdml, NULL, 0);
apply = XtCreateManagedWidget("apply", commandWidgetClass,
kbdml, NULL, 0);
XtAddCallback(apply, XtNcallback, KeyboardApplyCallback, NULL);
XtRealizeWidget(kbdml);
XtAddEventHandler(kbd, ExposureMask, False, XkbUIEventHandler, NULL);
/* Force the first update */
XClearArea(XtDisplay(kbd), XtWindow(kbd), 0, 0, 0, 0, True);
}
XtSetArg(args[0], XtNlabel, xkb_rules->rules);
XtSetValues(rulesb, args, 1);
for (i = 0; i < xkb_rules->model.nelem; i++)
if (strcmp(model, xkb_rules->model.name[i]) == 0) {
XtSetArg(args[0], XtNlabel, xkb_rules->model.desc[i]);
XtSetValues(modelb, args, 1);
break;
}
for (i = 0; i < xkb_rules->layout.nelem; i++)
if (strcmp(layout, xkb_rules->layout.name[i]) == 0) {
XtSetArg(args[0], XtNlabel, xkb_rules->layout.desc[i]);
XtSetValues(layoutb, args, 1);
break;
}
if (variant)
for (i = 0; i < xkb_rules->variant.nelem; i++)
if (strcmp(variant, xkb_rules->variant.name[i]) == 0) {
XtSetArg(args[0], XtNlabel, xkb_rules->variant.desc[i]);
XtSetValues(variantb, args, 1);
break;
}
if (options) {
XtSetArg(args[0], XtNlabel, options);
XtSetValues(optionsb, args, 1);
}
XtChangeManagedSet(&current, 1, NULL, NULL, &kbdml, 1);
current = kbdml;
}
Reference in New Issue View Git Blame Copy Permalink