StreetLight
/
libxkbcommon
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
libxkbcommon/src/xkbcomp/indicators.c

569 lines
18 KiB
C
Raw Normal View History

Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
/************************************************************
Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
Permission to use, copy, modify, and distribute this
software and its documentation for any purpose and without
fee is hereby granted, provided that the above copyright
notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting
documentation, and that the name of Silicon Graphics not be
used in advertising or publicity pertaining to distribution
of the software without specific prior written permission.
Silicon Graphics makes no representation about the suitability
of this software for any purpose. It is provided "as is"
without any express or implied warranty.
SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
THE USE OR PERFORMANCE OF THIS SOFTWARE.
********************************************************/
#include "xkbcomp.h"
#include "misc.h"
#include "tokens.h"
#include "expr.h"
#include "vmod.h"
#include "indicators.h"
#include "action.h"
#include "compat.h"
/***====================================================================***/
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
#define ReportIndicatorBadType(d,l,f,w) \
ReportBadType("indicator map", (f), XkbcAtomText((l)->name), (w))
#define ReportIndicatorNotArray(d,l,f) \
ReportNotArray("indicator map", (f), XkbcAtomText((l)->name))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
/***====================================================================***/
void
ClearIndicatorMapInfo(Display * dpy, LEDInfo * info)
{
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
info->name = XkbcInternAtom("default", False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
info->indicator = _LED_NotBound;
info->flags = info->which_mods = info->real_mods = 0;
info->vmods = 0;
info->which_groups = info->groups = 0;
info->ctrls = 0;
return;
}
LEDInfo *
AddIndicatorMap(LEDInfo * oldLEDs, LEDInfo * new)
{
LEDInfo *old, *last;
unsigned collide;
last = NULL;
for (old = oldLEDs; old != NULL; old = (LEDInfo *) old->defs.next)
{
if (old->name == new->name)
{
if ((old->real_mods == new->real_mods) &&
(old->vmods == new->vmods) &&
(old->groups == new->groups) &&
(old->ctrls == new->ctrls) &&
(old->which_mods == new->which_mods) &&
(old->which_groups == new->which_groups))
{
old->defs.defined |= new->defs.defined;
return oldLEDs;
}
if (new->defs.merge == MergeReplace)
{
CommonInfo *next = old->defs.next;
if (((old->defs.fileID == new->defs.fileID)
&& (warningLevel > 0)) || (warningLevel > 9))
{
WARN1("Map for indicator %s redefined\n",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(old->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION("Earlier definition ignored\n");
}
*old = *new;
old->defs.next = next;
return oldLEDs;
}
collide = 0;
if (UseNewField(_LED_Index, &old->defs, &new->defs, &collide))
{
old->indicator = new->indicator;
old->defs.defined |= _LED_Index;
}
if (UseNewField(_LED_Mods, &old->defs, &new->defs, &collide))
{
old->which_mods = new->which_mods;
old->real_mods = new->real_mods;
old->vmods = new->vmods;
old->defs.defined |= _LED_Mods;
}
if (UseNewField(_LED_Groups, &old->defs, &new->defs, &collide))
{
old->which_groups = new->which_groups;
old->groups = new->groups;
old->defs.defined |= _LED_Groups;
}
if (UseNewField(_LED_Ctrls, &old->defs, &new->defs, &collide))
{
old->ctrls = new->ctrls;
old->defs.defined |= _LED_Ctrls;
}
if (UseNewField(_LED_Explicit, &old->defs, &new->defs, &collide))
{
old->flags &= ~XkbIM_NoExplicit;
old->flags |= (new->flags & XkbIM_NoExplicit);
old->defs.defined |= _LED_Explicit;
}
if (UseNewField(_LED_Automatic, &old->defs, &new->defs, &collide))
{
old->flags &= ~XkbIM_NoAutomatic;
old->flags |= (new->flags & XkbIM_NoAutomatic);
old->defs.defined |= _LED_Automatic;
}
if (UseNewField(_LED_DrivesKbd, &old->defs, &new->defs, &collide))
{
old->flags &= ~XkbIM_LEDDrivesKB;
old->flags |= (new->flags & XkbIM_LEDDrivesKB);
old->defs.defined |= _LED_DrivesKbd;
}
if (collide)
{
WARN1("Map for indicator %s redefined\n",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(old->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION1("Using %s definition for duplicate fields\n",
(new->defs.merge == MergeAugment ? "first" : "last"));
}
return oldLEDs;
}
if (old->defs.next == NULL)
last = old;
}
/* new definition */
old = uTypedAlloc(LEDInfo);
if (!old)
{
WSGO("Couldn't allocate indicator map\n");
ACTION1("Map for indicator %s not compiled\n",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(new->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
return NULL;
}
*old = *new;
old->defs.next = NULL;
if (last)
{
last->defs.next = &old->defs;
return oldLEDs;
}
return old;
}
static LookupEntry modComponentNames[] = {
{"base", XkbIM_UseBase}
,
{"latched", XkbIM_UseLatched}
,
{"locked", XkbIM_UseLocked}
,
{"effective", XkbIM_UseEffective}
,
{"compat", XkbIM_UseCompat}
,
{"any", XkbIM_UseAnyMods}
,
{"none", 0}
,
{NULL, 0}
};
static LookupEntry groupComponentNames[] = {
{"base", XkbIM_UseBase}
,
{"latched", XkbIM_UseLatched}
,
{"locked", XkbIM_UseLocked}
,
{"effective", XkbIM_UseEffective}
,
{"any", XkbIM_UseAnyGroup}
,
{"none", 0}
,
{NULL, 0}
};
int
SetIndicatorMapField(LEDInfo * led,
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
XkbcDescPtr xkb,
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
char *field, ExprDef * arrayNdx, ExprDef * value)
{
ExprResult rtrn;
Bool ok;
ok = True;
if ((uStrCaseCmp(field, "modifiers") == 0)
|| (uStrCaseCmp(field, "mods") == 0))
{
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
libxkbcomp: s/XPointer/char */ Replace XPointer with its definition since we don't have the privilege of using Xlib.h. Why this is char * and not void *, I'll never know.
2009-03-27 21:13:22 -06:00
if (!ExprResolveModMask(value, &rtrn, LookupVModMask, (char *) xkb))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
return ReportIndicatorBadType(xkb->dpy, led, field,
"modifier mask");
led->real_mods = rtrn.uval & 0xff;
led->vmods = (rtrn.uval >> 8) & 0xff;
led->defs.defined |= _LED_Mods;
}
else if (uStrCaseCmp(field, "groups") == 0)
{
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
if (!ExprResolveMask
libxkbcomp: s/XPointer/char */ Replace XPointer with its definition since we don't have the privilege of using Xlib.h. Why this is char * and not void *, I'll never know.
2009-03-27 21:13:22 -06:00
(value, &rtrn, SimpleLookup, (char *) groupNames))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
return ReportIndicatorBadType(xkb->dpy, led, field, "group mask");
led->groups = rtrn.uval;
led->defs.defined |= _LED_Groups;
}
else if ((uStrCaseCmp(field, "controls") == 0) ||
(uStrCaseCmp(field, "ctrls") == 0))
{
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
if (!ExprResolveMask
libxkbcomp: s/XPointer/char */ Replace XPointer with its definition since we don't have the privilege of using Xlib.h. Why this is char * and not void *, I'll never know.
2009-03-27 21:13:22 -06:00
(value, &rtrn, SimpleLookup, (char *) ctrlNames))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
return ReportIndicatorBadType(xkb->dpy, led, field,
"controls mask");
led->ctrls = rtrn.uval;
led->defs.defined |= _LED_Ctrls;
}
else if (uStrCaseCmp(field, "allowexplicit") == 0)
{
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
if (!ExprResolveBoolean(value, &rtrn, NULL, NULL))
return ReportIndicatorBadType(xkb->dpy, led, field, "boolean");
if (rtrn.uval)
led->flags &= ~XkbIM_NoExplicit;
else
led->flags |= XkbIM_NoExplicit;
led->defs.defined |= _LED_Explicit;
}
else if ((uStrCaseCmp(field, "whichmodstate") == 0) ||
(uStrCaseCmp(field, "whichmodifierstate") == 0))
{
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
if (!ExprResolveMask(value, &rtrn, SimpleLookup,
libxkbcomp: s/XPointer/char */ Replace XPointer with its definition since we don't have the privilege of using Xlib.h. Why this is char * and not void *, I'll never know.
2009-03-27 21:13:22 -06:00
(char *) modComponentNames))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
return ReportIndicatorBadType(xkb->dpy, led, field,
"mask of modifier state components");
}
led->which_mods = rtrn.uval;
}
else if (uStrCaseCmp(field, "whichgroupstate") == 0)
{
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
if (!ExprResolveMask(value, &rtrn, SimpleLookup,
libxkbcomp: s/XPointer/char */ Replace XPointer with its definition since we don't have the privilege of using Xlib.h. Why this is char * and not void *, I'll never know.
2009-03-27 21:13:22 -06:00
(char *) groupComponentNames))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
return ReportIndicatorBadType(xkb->dpy, led, field,
"mask of group state components");
}
led->which_groups = rtrn.uval;
}
else if ((uStrCaseCmp(field, "driveskbd") == 0) ||
(uStrCaseCmp(field, "driveskeyboard") == 0) ||
(uStrCaseCmp(field, "leddriveskbd") == 0) ||
(uStrCaseCmp(field, "leddriveskeyboard") == 0) ||
(uStrCaseCmp(field, "indicatordriveskbd") == 0) ||
(uStrCaseCmp(field, "indicatordriveskeyboard") == 0))
{
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
if (!ExprResolveBoolean(value, &rtrn, NULL, NULL))
return ReportIndicatorBadType(xkb->dpy, led, field, "boolean");
if (rtrn.uval)
led->flags |= XkbIM_LEDDrivesKB;
else
led->flags &= ~XkbIM_LEDDrivesKB;
led->defs.defined |= _LED_DrivesKbd;
}
else if (uStrCaseCmp(field, "index") == 0)
{
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
if (!ExprResolveInteger(value, &rtrn, NULL, NULL))
return ReportIndicatorBadType(xkb->dpy, led, field,
"indicator index");
if ((rtrn.uval < 1) || (rtrn.uval > 32))
{
ERROR2("Illegal indicator index %d (range 1..%d)\n",
rtrn.uval, XkbNumIndicators);
ACTION1("Index definition for %s indicator ignored\n",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(led->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
return False;
}
led->indicator = rtrn.uval;
led->defs.defined |= _LED_Index;
}
else
{
ERROR2("Unknown field %s in map for %s indicator\n", field,
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(led->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION("Definition ignored\n");
ok = False;
}
return ok;
}
LEDInfo *
HandleIndicatorMapDef(IndicatorMapDef * def,
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
XkbcDescPtr xkb,
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
LEDInfo * dflt, LEDInfo * oldLEDs, unsigned merge)
{
LEDInfo led, *rtrn;
VarDef *var;
Bool ok;
if (def->merge != MergeDefault)
merge = def->merge;
led = *dflt;
led.defs.merge = merge;
led.name = def->name;
ok = True;
for (var = def->body; var != NULL; var = (VarDef *) var->common.next)
{
ExprResult elem, field;
ExprDef *arrayNdx;
if (!ExprResolveLhs(var->name, &elem, &field, &arrayNdx))
{
ok = False;
continue;
}
if (elem.str != NULL)
{
ERROR1
("Cannot set defaults for \"%s\" element in indicator map\n",
elem.str);
ACTION2("Assignment to %s.%s ignored\n", elem.str, field.str);
ok = False;
}
else
{
ok = SetIndicatorMapField(&led, xkb, field.str, arrayNdx,
var->value) && ok;
}
}
if (ok)
{
rtrn = AddIndicatorMap(oldLEDs, &led);
return rtrn;
}
return NULL;
}
Bool
libxkbcomp: Eradicate XkbFileInfo usage The only real usage was in the frontend to generate a .xkm file. The rest of the code just operated on the attached XkbDescPtr. Note that here we've replaced the usage of the defined field in CompileKeymap with the equivalent field in a XkbcDescPtr.
2009-03-27 20:54:50 -06:00
CopyIndicatorMapDefs(XkbcDescPtr xkb, LEDInfo *leds, LEDInfo **unboundRtrn)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
LEDInfo *led, *next;
LEDInfo *unbound, *last;
if (XkbAllocNames(xkb, XkbIndicatorNamesMask, 0, 0) != Success)
{
WSGO("Couldn't allocate names\n");
ACTION("Indicator names may be incorrect\n");
}
if (XkbAllocIndicatorMaps(xkb) != Success)
{
WSGO("Can't allocate indicator maps\n");
ACTION("Indicator map definitions may be lost\n");
return False;
}
last = unbound = (unboundRtrn ? *unboundRtrn : NULL);
while ((last != NULL) && (last->defs.next != NULL))
{
last = (LEDInfo *) last->defs.next;
}
for (led = leds; led != NULL; led = next)
{
next = (LEDInfo *) led->defs.next;
if ((led->groups != 0) && (led->which_groups == 0))
led->which_groups = XkbIM_UseEffective;
if ((led->which_mods == 0) && ((led->real_mods) || (led->vmods)))
led->which_mods = XkbIM_UseEffective;
if ((led->indicator == _LED_NotBound) || (!xkb->indicators))
{
if (unboundRtrn != NULL)
{
led->defs.next = NULL;
if (last != NULL)
last->defs.next = (CommonInfo *) led;
else
unbound = led;
last = led;
}
else
uFree(led);
}
else
{
register XkbIndicatorMapPtr im;
im = &xkb->indicators->maps[led->indicator - 1];
im->flags = led->flags;
im->which_groups = led->which_groups;
im->groups = led->groups;
im->which_mods = led->which_mods;
im->mods.mask = led->real_mods;
im->mods.real_mods = led->real_mods;
im->mods.vmods = led->vmods;
im->ctrls = led->ctrls;
if (xkb->names != NULL)
xkb->names->indicators[led->indicator - 1] = led->name;
uFree(led);
}
}
if (unboundRtrn != NULL)
{
*unboundRtrn = unbound;
}
return True;
}
Bool
libxkbcomp: Eradicate XkbFileInfo usage The only real usage was in the frontend to generate a .xkm file. The rest of the code just operated on the attached XkbDescPtr. Note that here we've replaced the usage of the defined field in CompileKeymap with the equivalent field in a XkbcDescPtr.
2009-03-27 20:54:50 -06:00
BindIndicators(XkbcDescPtr xkb, Bool force, LEDInfo *unbound,
LEDInfo **unboundRtrn)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
register int i;
register LEDInfo *led, *next, *last;
if (xkb->names != NULL)
{
for (led = unbound; led != NULL; led = (LEDInfo *) led->defs.next)
{
if (led->indicator == _LED_NotBound)
{
for (i = 0; i < XkbNumIndicators; i++)
{
if (xkb->names->indicators[i] == led->name)
{
led->indicator = i + 1;
break;
}
}
}
}
if (force)
{
for (led = unbound; led != NULL; led = (LEDInfo *) led->defs.next)
{
if (led->indicator == _LED_NotBound)
{
for (i = 0; i < XkbNumIndicators; i++)
{
if (xkb->names->indicators[i] == None)
{
xkb->names->indicators[i] = led->name;
led->indicator = i + 1;
xkb->indicators->phys_indicators &= ~(1 << i);
break;
}
}
if (led->indicator == _LED_NotBound)
{
ERROR("No unnamed indicators found\n");
ACTION1
("Virtual indicator map \"%s\" not bound\n",
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
XkbcAtomGetString(led->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
continue;
}
}
}
}
}
for (last = NULL, led = unbound; led != NULL; led = next)
{
next = (LEDInfo *) led->defs.next;
if (led->indicator == _LED_NotBound)
{
if (force)
{
unbound = next;
uFree(led);
}
else
{
if (last)
last->defs.next = &led->defs;
else
unbound = led;
last = led;
}
}
else
{
if ((xkb->names != NULL) &&
(xkb->names->indicators[led->indicator - 1] != led->name))
{
Atom old = xkb->names->indicators[led->indicator - 1];
ERROR1("Multiple names bound to indicator %d\n",
(unsigned int) led->indicator);
ACTION2("Using %s, ignoring %s\n",
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
XkbcAtomGetString(old),
XkbcAtomGetString(led->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
led->indicator = _LED_NotBound;
if (force)
{
uFree(led);
unbound = next;
}
else
{
if (last)
last->defs.next = &led->defs;
else
unbound = led;
last = led;
}
}
else
{
XkbIndicatorMapPtr map;
map = &xkb->indicators->maps[led->indicator - 1];
map->flags = led->flags;
map->which_groups = led->which_groups;
map->groups = led->groups;
map->which_mods = led->which_mods;
map->mods.mask = led->real_mods;
map->mods.real_mods = led->real_mods;
map->mods.vmods = led->vmods;
map->ctrls = led->ctrls;
if (last)
last->defs.next = &next->defs;
else
unbound = next;
led->defs.next = NULL;
uFree(led);
}
}
}
if (unboundRtrn)
{
*unboundRtrn = unbound;
}
else if (unbound)
{
for (led = unbound; led != NULL; led = next)
{
next = (LEDInfo *) led->defs.next;
uFree(led);
}
}
return True;
}