#include <stdio.h>
#include <stdlib.h>
#include <X11/Xlib.h>
#include <X11/Intrinsic.h>
#include <X11/XKBlib.h>
#include <Xm/MainW.h>
#include <Xm/RowColumn.h>
#include <Xm/ToggleB.h>
Display *theDisplay;
XtAppContext appContext;
int xkbEventBase;
Widget topLevel;
Widget leds[XkbNumIndicators];
Atom ledAtoms[XkbNumIndicators];
XmString ledNames[XkbNumIndicators];
XkbDescPtr xkb_desc;
void valueChangedProc(Widget,XtPointer,XmToggleButtonCallbackStruct *);
XtCallbackRec valueChangedCB[2]={(XtCallbackProc)valueChangedProc,NULL};
/************************************************************************/
/* */
/* Application Resources */
/* */
/************************************************************************/
#define YES 1
#define NO 0
#define DONT_CARE -1
typedef struct
{
int wanted;
int wantAutomatic;
int wantExplicit;
int wantNamed;
int wantReal;
int wantVirtual;
int useUnion;
} OptionsRec;
OptionsRec options;
#define Offset(field) XtOffsetOf(OptionsRec,field)
XtResource resources[] =
{
{"wanted", "Wanted", XtRInt, sizeof(int),
Offset(wanted), XtRImmediate, (XtPointer) DONT_CARE },
{"wantAutomatic", "WantAutomatic", XtRInt, sizeof(int),
Offset(wantAutomatic), XtRImmediate, (XtPointer) DONT_CARE},
{"wantExplicit", "WantExplicit", XtRInt, sizeof(int),
Offset(wantExplicit), XtRImmediate, (XtPointer) DONT_CARE},
{"wantNamed", "WantNamed", XtRInt, sizeof(int),
Offset(wantNamed), XtRImmediate, (XtPointer) DONT_CARE},
{"wantReal", "WantReal", XtRInt, sizeof(int),
Offset(wantReal), XtRImmediate, (XtPointer) DONT_CARE},
{"wantVirtual", "WantVirtual", XtRInt, sizeof(int),
Offset(wantVirtual), XtRImmediate, (XtPointer) DONT_CARE},
{"useUnion", "UseUnion", XtRInt, sizeof(int),
Offset(useUnion), XtRImmediate, (XtPointer) YES},
NULL
};
#undef Offset
String fallbackResources[] =
{
"*mainWindow.width: 100",
"*mainWindow.height: 50",
NULL
};
XrmOptionDescRec optionDesc[] =
{
{"-watch", "*wanted", XrmoptionSepArg, (XtPointer) "0"},
{"-automatic", "*wantAutomatic", XrmoptionNoArg, (XtPointer) "0"},
{"+automatic", "*wantAutomatic", XrmoptionNoArg, (XtPointer) "1"},
{"-explicit", "*wantExplicit", XrmoptionNoArg, (XtPointer) "0"},
{"+explicit", "*wantExplicit", XrmoptionNoArg, (XtPointer) "1"},
{"-named", "*wantNamed", XrmoptionNoArg, (XtPointer) "0"},
{"+named", "*wantNamed", XrmoptionNoArg, (XtPointer) "1"},
{"-real", "*wantReal", XrmoptionNoArg, (XtPointer) "0"},
{"+real", "*wantReal", XrmoptionNoArg, (XtPointer) "1"},
{"-virtual", "*wantVirtual", XrmoptionNoArg, (XtPointer) "0"},
{"+virtual", "*wantVirtual", XrmoptionNoArg, (XtPointer) "1"},
{"-intersection", "*useUnion", XrmoptionNoArg, (XtPointer) "0"},
{"-union", "*useUnion", XrmoptionNoArg, (XtPointer) "1"}
};
/************************************************************************/
/* */
/* usage */
/* */
/************************************************************************/
void usage(char *program)
{
printf("Usage: %s <options>\n",program);
printf("Legal options include the usual X toolkit options plus:\n");
printf(" -help Print this message\n");
printf(" -indpy <name> Name of display to watch\n");
printf(" -watch <leds> Mask of LEDs to watch\n");
printf(" [-+]automatic (Don't) watch automatic LEDs\n");
printf(" [-+]explicit (Don't) watch explicit LEDs\n");
printf(" [-+]named (Don't) watch named LEDs\n");
printf(" [-+]real (Don't) watch real LEDs\n");
printf(" [-+]virtual (Don't) watch virtual LEDs\n");
printf(" -intersection Watch only LEDs in all desired sets\n");
printf(" -union Watch LEDs in any desired sets\n");
printf("The default set of LEDs is -intersection +named +virtual\n");
return;
}
/************************************************************************/
/* */
/* XkbEventHandler */
/* */
/* DESCRIPTION: */
/* */
/* Handles events generated by the Xkb server extension. */
/* */
/************************************************************************/
Boolean XkbEventHandler(XEvent *event)
{
XkbEvent *xkbEv = (XkbEvent *) event;
if (xkbEv->any.xkb_type==XkbIndicatorStateNotify) {
register int i;
register unsigned bit;
for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1)
if ((xkbEv->indicators.changed&bit)&&(leds[i]))
{
if (xkbEv->indicators.state&bit)
XmToggleButtonSetState(leds[i],True,False);
else
XmToggleButtonSetState(leds[i],False,False);
}
}
else if (xkbEv->any.xkb_type==XkbIndicatorMapNotify) {
unsigned change= xkbEv->indicators.changed;
if (XkbGetIndicatorMap(theDisplay,change,xkb_desc)!=Success)
fprintf(stderr,"Couldn't get changed indicator maps\n");
}
return True;
} /* XkbEventHandler */
/************************************************************************/
/* */
/* InitXkb */
/* */
/************************************************************************/
Boolean InitXkb(Display *theDisplay)
{
int i,opcode,errorBase,major,minor;
XkbDescPtr xkb;
unsigned int bit;
unsigned int real,virtual,named,explicit,automatic;
char *name;
if (!XkbQueryExtension(theDisplay,
&opcode,
&xkbEventBase,
&errorBase,
&major,
&minor))
return False;
if (!XkbUseExtension(theDisplay,&major,&minor))
return False;
XkbSelectEvents(theDisplay,
XkbUseCoreKbd,
XkbIndicatorStateNotifyMask|XkbIndicatorMapNotifyMask,
XkbIndicatorStateNotifyMask|XkbIndicatorMapNotifyMask);
XtSetEventDispatcher(theDisplay,
xkbEventBase+XkbEventCode,
XkbEventHandler);
xkb=XkbGetMap(theDisplay,0,XkbUseCoreKbd);
real=virtual=named=explicit=automatic=0;
if (!xkb)
{
fprintf(stderr,"Couldn't get keymap\n");
return False;
}
if (XkbGetIndicatorMap(theDisplay,XkbAllIndicatorsMask,xkb)!=Success)
{
fprintf(stderr,"Couldn't read indicator map\n");
XkbFreeKeyboard(xkb,XkbAllComponentsMask,True);
return False;
}
real=virtual=named=explicit=automatic=0;
if (XkbGetNames(theDisplay,XkbIndicatorNamesMask,xkb)!=Success)
{
fprintf(stderr,"Couldn't read indicator names\n");
XkbFreeKeyboard(xkb,XkbAllComponentsMask,True);
return False;
}
real=virtual=named=explicit=automatic=0;
for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1)
{
XkbIndicatorMapPtr map= &xkb->indicators->maps[i];
name = NULL;
if (xkb->names->indicators[i]!=None)
{
named|= bit;
name = XGetAtomName(theDisplay,xkb->names->indicators[i]);
}
if (name != NULL)
{
ledAtoms[i] = xkb->names->indicators[i];
ledNames[i] = XmStringCreate(name,XmSTRING_DEFAULT_CHARSET);
}
else
{
char temp[12];
sprintf(temp,"led%d\0",i+1);
ledAtoms[i] = None;
ledNames[i] = XmStringCreate(temp,XmSTRING_DEFAULT_CHARSET);
}
if (xkb->indicators->phys_indicators&bit)
real|= bit;
if ((((map->which_groups!=0)&&(map->groups!=0))||
((map->which_mods!=0)&&
((map->mods.real_mods!=0)||(map->mods.vmods!=0)))||
(map->ctrls!=0))&&
((map->flags&XkbIM_NoAutomatic)==0)) {
automatic|= bit;
}
else explicit|= bit;
}
virtual = ~real;
if (options.useUnion)
{
if ((options.wantReal==NO) || (options.wantReal==DONT_CARE))
real = 0;
if ((options.wantVirtual==NO) || (options.wantVirtual==DONT_CARE))
virtual = 0;
if ((options.wantNamed==NO) || (options.wantNamed==DONT_CARE))
named = 0;
if ((options.wantAutomatic==NO) || (options.wantAutomatic==DONT_CARE))
automatic = 0;
if ((options.wantExplicit==NO) || (options.wantExplicit==DONT_CARE))
explicit = 0;
options.wanted |= real|virtual|named|automatic|explicit;
}
else
{
if (options.wanted == DONT_CARE)
options.wanted = ~0;
if (options.wantReal==NO)
real = ~real;
else if (options.wantReal==DONT_CARE)
real = ~0;
if (options.wantVirtual==NO)
virtual = ~virtual;
else if (options.wantVirtual==DONT_CARE)
virtual = ~0;
if (options.wantNamed==NO)
named = ~named;
else if (options.wantNamed==DONT_CARE)
named = ~0;
if (options.wantAutomatic==NO)
automatic = ~automatic;
else if (options.wantAutomatic==DONT_CARE)
automatic = ~0;
if (options.wantExplicit==NO)
explicit = ~explicit;
else if (options.wantExplicit==DONT_CARE)
explicit = ~0;
options.wanted &= real&virtual&named&automatic&explicit;
}
XkbFreeKeyboard(xkb,XkbAllComponentsMask,True);
return True;
} /* InitXkb */
/************************************************************************/
/* */
/* valueChangedProc - called when a toggle button is pressed. */
/* */
/************************************************************************/
void valueChangedProc(Widget w,
XtPointer clientData,
XmToggleButtonCallbackStruct *callbackData)
{
int led = (int) clientData;
XkbDescPtr xkb;
xkb = XkbGetMap(theDisplay,0,XkbUseCoreKbd);
if (!xkb)
{
fprintf(stderr,"XkbGetMap failed\n");
return;
}
if (XkbGetIndicatorMap(theDisplay,XkbAllIndicatorsMask,xkb)!=Success)
{
fprintf(stderr,"GetIndicatorMap failed\n");
XkbFreeKeyboard(xkb,XkbAllComponentsMask,True);
return;
}
/* The 'flags' field tells whether this indicator is automatic
* (XkbIM_NoExplicit - 0x80), explicit (XkbIM_NoAutomatic - 0x40),
* or neither (both - 0xC0).
*
* If NoAutomatic is set, the server ignores the rest of the
* fields in the indicator map (i.e. it disables automatic control
* of the LED). If NoExplicit is set, the server prevents clients
* from explicitly changing the value of the LED (using the core
* protocol *or* XKB). If NoAutomatic *and* NoExplicit are set,
* the LED cannot be changed (unless you change the map first).
* If neither NoAutomatic nor NoExplicit are set, the server will
* change the LED according to the indicator map, but clients can
* override that (until the next automatic change) using the core
* protocol or XKB.
*/
switch (xkb->indicators->maps[led].flags &
(XkbIM_NoExplicit|XkbIM_NoAutomatic))
{
case XkbIM_NoExplicit|XkbIM_NoAutomatic:
{
XmToggleButtonSetState(w,!callbackData->set,FALSE);
XkbFreeKeyboard(xkb,XkbAllComponentsMask,True);
return;
}
case XkbIM_NoAutomatic:
{
if (ledAtoms[led] != None)
XkbSetNamedIndicator(theDisplay,XkbUseCoreKbd,
ledAtoms[led],callbackData->set,
FALSE,NULL);
else
{
XKeyboardControl xkc;
xkc.led= led;
if (callbackData->set)
xkc.led_mode= LedModeOn;
else xkc.led_mode= LedModeOff;
XChangeKeyboardControl(theDisplay,KBLed|KBLedMode,&xkc);
XSync(theDisplay,0);
}
XkbFreeKeyboard(xkb,XkbAllComponentsMask,True);
return;
}
case XkbIM_NoExplicit:
break;
}
/* The 'ctrls' field tells what controls tell this indicator to
* to turn on: RepeatKeys (0x1), SlowKeys (0x2), BounceKeys (0x4),
* StickyKeys (0x8), MouseKeys (0x10), AccessXKeys (0x20),
* TimeOut (0x40), Feedback (0x80), ToggleKeys (0x100),
* Overlay1 (0x200), Overlay2 (0x400), GroupsWrap (0x800),
* InternalMods (0x1000), IgnoreLockMods (0x2000),
* PerKeyRepeat (0x3000), or ControlsEnabled (0x4000)
*/
if (xkb->indicators->maps[led].ctrls)
{
unsigned long which = xkb->indicators->maps[led].ctrls;
XkbGetControls(theDisplay,XkbAllControlsMask,xkb);
if (callbackData->set)
xkb->ctrls->enabled_ctrls |= which;
else
xkb->ctrls->enabled_ctrls &= ~which;
XkbSetControls(theDisplay,which|XkbControlsEnabledMask,xkb);
}
/* The 'which_groups' field tells when this indicator turns on
* for the 'groups' field: base (0x1), latched (0x2), locked (0x4),
* or effective (0x8).
*/
if (xkb->indicators->maps[led].groups)
{
int i;
unsigned int group = 1;
/* Turning on a group indicator is kind of tricky. For
* now, we will just Latch or Lock the first group we find
* if that is what this indicator does. Otherwise, we're
* just going to punt and get out of here.
*/
if (callbackData->set)
{
for (i = XkbNumKbdGroups-1; i >= 0; i--)
if ((1 << i) &
xkb->indicators->maps[led].groups)
group = i;
if (xkb->indicators->maps[led].which_groups &
(XkbIM_UseLocked | XkbIM_UseEffective))
XkbLockGroup(theDisplay,XkbUseCoreKbd,group);
else if (xkb->indicators->maps[led].which_groups&XkbIM_UseLatched)
XkbLatchGroup(theDisplay,XkbUseCoreKbd,group);
else
{
XmToggleButtonSetState(w,!callbackData->set,FALSE);
XkbFreeKeyboard(xkb,XkbAllComponentsMask,True);
return;
}
}
/* Turning off a group indicator will mean that we just
* Lock the first group that this indicator doesn't watch.
*/
else
{
for (i = XkbNumKbdGroups-1; i >= 0; i--)
if (!((1 << i) &
xkb->indicators->maps[led].groups))
group = i;
XkbLockGroup(theDisplay,XkbUseCoreKbd,group);
}
}
/* The 'which_mods' field tells when this indicator turns on
* for the modifiers: base (0x1), latched (0x2), locked (0x4),
* or effective (0x8).
*
* The 'real_mods' field tells whether this turns on when one of
* the real X modifiers is set: Shift (0x1), Lock (0x2), Control (0x4),
* Mod1 (0x8), Mod2 (0x10), Mod3 (0x20), Mod4 (0x40), or Mod5 (0x80).
*
* The 'virtual_mods' field tells whether this turns on when one of
* the virtual modifiers is set.
*
* The 'mask' field tells what real X modifiers the virtual_modifiers
* map to?
*/
if (xkb->indicators->maps[led].mods.real_mods ||
xkb->indicators->maps[led].mods.mask)
{
XkbStateRec state;
unsigned int affect,mods;
affect = (xkb->indicators->maps[led].mods.real_mods |
xkb->indicators->maps[led].mods.mask);
if (callbackData->set)
mods = affect;
else
mods = 0;
if (xkb->indicators->maps[led].which_mods &
(XkbIM_UseLocked | XkbIM_UseEffective))
XkbLockModifiers(theDisplay,XkbUseCoreKbd,affect,mods);
else if (xkb->indicators->maps[led].which_mods &
XkbIM_UseLatched)
XkbLatchModifiers(theDisplay,XkbUseCoreKbd,affect,mods);
else
{
XmToggleButtonSetState(w,!callbackData->set,FALSE);
XkbFreeKeyboard(xkb,XkbAllComponentsMask,True);
return;
}
}
XkbFreeKeyboard(xkb,XkbAllComponentsMask,True);
} /* valueChangedProc */
/************************************************************************/
/* */
/* InitializeUI */
/* */
/************************************************************************/
void InitializeUI(Widget topLevel)
{
Arg argList[3];
char buf[256];
int i;
unsigned int bit,n;
Widget mainWindow,rowColumn;
XmString tempString;
mainWindow = (Widget) XmCreateMainWindow(topLevel,"mainWindow",NULL,0);
XtManageChild(mainWindow);
rowColumn = (Widget) XmCreateRowColumn(mainWindow,"rowColumn",NULL,0);
XtManageChild(rowColumn);
XkbGetIndicatorState(theDisplay,XkbUseCoreKbd,&n);
for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1)
{
if (options.wanted&bit)
{
/* [[[ WDW - If we wanted to be really fancy, we
* would look for a "*ledxx.labelString" value
* in the resource database so the I18N dudes
* can see localized strings. ]]]
*/
XtSetArg(argList[0], XmNlabelString,ledNames[i]);
if (n&bit) XtSetArg(argList[1], XmNset, True);
else XtSetArg(argList[1], XmNset, False);
sprintf(buf,"led%d\0",i);
valueChangedCB[0].closure = (XtPointer) i;
XtSetArg(argList[2], XmNvalueChangedCallback, valueChangedCB);
leds[i]= XmCreateToggleButton(rowColumn,buf,argList,3);
XtManageChild(leds[i]);
}
else
leds[i]=0;
}
} /* InitializeUI */
/************************************************************************/
/* */
/* main */
/* */
/************************************************************************/
#if NeedFunctionPrototypes
int main(int argc,
char *argv[])
#else
int main(argc, argv)
int argc;
char *argv[];
#endif
{
/********************************************************************/
/* */
/* Initialize the toolkit */
/* */
/********************************************************************/
Arg argList[2];
topLevel = XtAppInitialize(&appContext, "xkbleds",
optionDesc, XtNumber(optionDesc),
&argc, argv,
fallbackResources,
NULL, 0);
XtSetArg(argList[0], XtNallowShellResize, TRUE);
XtSetValues(topLevel,argList,1);
XtGetApplicationResources(topLevel, (XtPointer)&options, resources,
XtNumber(resources), NULL, 0);
if (argc > 1)
{
usage(argv[0]);
exit(0);
}
/* Defaults
*/
if ((options.wanted == DONT_CARE) &&
(options.wantReal == DONT_CARE) &&
(options.wantVirtual == DONT_CARE) &&
(options.wantNamed == DONT_CARE) &&
(options.wantAutomatic == DONT_CARE) &&
(options.wantExplicit == DONT_CARE) &&
(options.useUnion == YES))
{
options.wanted = 0;
options.wantReal = YES;
options.wantNamed = YES;
options.wantAutomatic = YES;
}
/********************************************************************/
/* */
/* See if the server has XKB. */
/* */
/********************************************************************/
theDisplay = XtDisplay(topLevel);
if (!InitXkb(theDisplay))
{
fprintf(stderr,"Could not initialize XKB extension.\n");
exit(0);
}
if (options.wanted == 0)
{
fprintf(stderr,"No LED's were selected.\n\n");
usage(argv[0]);
exit(0);
}
/********************************************************************/
/* */
/* Set up the UI and go. */
/* */
/********************************************************************/
XtRealizeWidget(topLevel);
InitializeUI(topLevel);
XtAppMainLoop(appContext);
/* NOT REACHED */
exit(0L);
}