void initialize_watch_bell(void) {
if (! xkb_present) {
if (! quiet) {
rfbLog("warning: disabling bell. XKEYBOARD ext. "
"not present.\n");
}
watch_bell = 0;
sound_bell = 0;
return;
}
RAWFB_RET_VOID
XkbSelectEvents(dpy, XkbUseCoreKbd, XkbBellNotifyMask, 0);
if (! watch_bell) {
return;
}
if (! XkbSelectEvents(dpy, XkbUseCoreKbd, XkbBellNotifyMask,
XkbBellNotifyMask) ) {
if (! quiet) {
rfbLog("warning: disabling bell. XkbSelectEvents"
" failed.\n");
}
watch_bell = 0;
sound_bell = 0;
}
}
gboolean
meta_bell_init (MetaDisplay *display)
{
int xkb_base_error_type, xkb_opcode;
if (!XkbQueryExtension (display->xdisplay, &xkb_opcode,
&display->xkb_base_event_type,
&xkb_base_error_type,
NULL, NULL))
{
display->xkb_base_event_type = -1;
g_message ("could not find XKB extension.");
return FALSE;
}
else
{
unsigned int mask = XkbBellNotifyMask;
gboolean visual_bell_auto_reset = FALSE;
/* TRUE if and when non-broken version is available */
XkbSelectEvents (display->xdisplay,
XkbUseCoreKbd,
XkbBellNotifyMask,
XkbBellNotifyMask);
meta_bell_set_audible (display, meta_prefs_bell_is_audible ());
if (visual_bell_auto_reset) {
XkbSetAutoResetControls (display->xdisplay,
XkbAudibleBellMask,
&mask,
&mask);
}
return TRUE;
}
return FALSE;
}
LOCAL_SYMBOL gboolean
meta_bell_init (MetaDisplay *display)
{
#ifdef HAVE_XKB
int xkb_base_error_type, xkb_opcode;
if (!XkbQueryExtension (display->xdisplay, &xkb_opcode,
&display->xkb_base_event_type,
&xkb_base_error_type,
NULL, NULL))
{
display->xkb_base_event_type = -1;
g_message ("could not find XKB extension.");
return FALSE;
}
else
{
XkbSelectEvents (display->xdisplay,
XkbUseCoreKbd,
XkbBellNotifyMask,
XkbBellNotifyMask);
return TRUE;
}
#endif
return FALSE;
}
int main(void) {
int evCode, errRet, rsnRet;
int maj = XkbMajorVersion;
int min = XkbMinorVersion;
Display* disp = XkbOpenDisplay("", &evCode, &errRet, &maj, &min, &rsnRet);
// State
XkbStatePtr state = calloc(1, sizeof(XkbStateRec));
XkbGetState(disp, 0x100, state);
// Names
XkbDescPtr desc = XkbAllocKeyboard();
XkbGetNames(disp, XkbSymbolsNameMask, desc);
Atom symNameAtom = desc->names->symbols;
char* layouts = XGetAtomName(disp, symNameAtom);
printf("%s\n", getActiveLayout(layouts, state->group));
unsigned int mask = XkbStateNotifyMask;
XkbSelectEvents(disp, XkbUseCoreKbd, mask, mask);
XkbEvent event;
while (1) {
XNextEvent(disp, &event.core);
if (event.state.changed & 0x90)
printf("%s\n", getActiveLayout(layouts, event.state.group));
}
}
static gboolean accessx_status_applet_xkb_select(AccessxStatusApplet* sapplet)
{
int opcode_rtn, error_rtn;
gboolean retval = FALSE;
GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(sapplet->applet));
g_assert(sapplet && sapplet->applet && window);
Display* display = GDK_WINDOW_XDISPLAY(window);
g_assert(display);
retval = XkbQueryExtension(display, &opcode_rtn, &xkb_base_event_type, &error_rtn, NULL, NULL);
if (retval)
{
retval = XkbSelectEvents(display, XkbUseCoreKbd, XkbAllEventsMask, XkbAllEventsMask);
sapplet->xkb = accessx_status_applet_get_xkb_desc(sapplet);
}
else
{
sapplet->error_type = ACCESSX_STATUS_ERROR_XKB_DISABLED;
}
return retval;
}
int XEventNotifier::registerForXkbEvents(Display* display)
{
int eventMask = XkbNewKeyboardNotifyMask | XkbStateNotifyMask;
if( ! XkbSelectEvents(display, XkbUseCoreKbd, eventMask, eventMask) ) {
qCWarning(KCM_KEYBOARD) << "Couldn't select desired XKB events";
return false;
}
return true;
}
KeyboardLayoutWidget::KeyboardLayoutWidget(QWidget* parent): QWidget(parent),
ratio(1.0),
trackModifiers(false )
{
uint i = 0;
for (i = 0; i < sizeof(deadMapData) / sizeof(deadMapData[0]); i ++)
deadMap[deadMapData[i].dead] = deadMapData[i].nondead;
xkb = XkbGetKeyboard (QX11Info::display(),
XkbGBN_GeometryMask |
XkbGBN_KeyNamesMask |
XkbGBN_OtherNamesMask |
XkbGBN_SymbolsMask |
XkbGBN_IndicatorMapMask,
XkbUseCoreKbd);
if (!xkb)
return;
groupLevels = pGroupsLevels;
XkbGetNames (QX11Info::display(), XkbAllNamesMask, xkb);
l3mod = XkbKeysymToModifiers (QX11Info::display(),
XK_ISO_Level3_Shift);
XkbSelectEventDetails (QX11Info::display(), XkbUseCoreKbd,
XkbIndicatorStateNotify,
xkb->indicators->phys_indicators,
xkb->indicators->phys_indicators);
xkbOnDisplay = true;
int mask = (XkbStateNotifyMask | XkbNamesNotifyMask |
XkbControlsNotifyMask | XkbIndicatorMapNotifyMask |
XkbNewKeyboardNotifyMask);
XkbSelectEvents (QX11Info::display(), XkbUseCoreKbd, mask, mask);
mask = XkbGroupStateMask | XkbModifierStateMask;
XkbSelectEventDetails (QX11Info::display(), XkbUseCoreKbd,
XkbStateNotify, mask, mask);
mask = (XkbGroupNamesMask | XkbIndicatorNamesMask);
XkbSelectEventDetails (QX11Info::display(), XkbUseCoreKbd,
XkbNamesNotify, mask, mask);
alloc ();
init();
initColors();
setFocusPolicy(Qt::StrongFocus);
}
static void
clutter_keymap_x11_constructed (GObject *gobject)
{
ClutterKeymapX11 *keymap_x11 = CLUTTER_KEYMAP_X11 (gobject);
ClutterBackendX11 *backend_x11;
g_assert (keymap_x11->backend != NULL);
backend_x11 = CLUTTER_BACKEND_X11 (keymap_x11->backend);
#ifdef HAVE_XKB
{
gint xkb_major = XkbMajorVersion;
gint xkb_minor = XkbMinorVersion;
if (XkbLibraryVersion (&xkb_major, &xkb_minor))
{
xkb_major = XkbMajorVersion;
xkb_minor = XkbMinorVersion;
if (XkbQueryExtension (backend_x11->xdpy,
NULL,
&keymap_x11->xkb_event_base,
NULL,
&xkb_major, &xkb_minor))
{
Bool detectable_autorepeat_supported;
backend_x11->use_xkb = TRUE;
XkbSelectEvents (backend_x11->xdpy,
XkbUseCoreKbd,
XkbNewKeyboardNotifyMask | XkbMapNotifyMask | XkbStateNotifyMask,
XkbNewKeyboardNotifyMask | XkbMapNotifyMask | XkbStateNotifyMask);
XkbSelectEventDetails (backend_x11->xdpy,
XkbUseCoreKbd, XkbStateNotify,
XkbAllStateComponentsMask,
XkbGroupLockMask | XkbModifierLockMask);
/* enable XKB autorepeat */
XkbSetDetectableAutoRepeat (backend_x11->xdpy,
True,
&detectable_autorepeat_supported);
backend_x11->have_xkb_autorepeat = detectable_autorepeat_supported;
CLUTTER_NOTE (BACKEND, "Detectable autorepeat: %s",
backend_x11->have_xkb_autorepeat ? "supported"
: "not supported");
}
}
}
#endif /* HAVE_XKB */
}
void init_X(void) {
int major, minor;
/* open the X display */
disp = XOpenDisplay(display);
if (!disp)
error("unable to open display");
major = XkbMajorVersion;
minor = XkbMinorVersion;
if (!XkbQueryExtension(disp, NULL, &xkb_event, NULL, &major, &minor))
error("XKB extension not supported");
XkbSelectEvents(disp, XkbUseCoreKbd, XkbBellNotifyMask, XkbBellNotifyMask);
}
RazorKbIndicatorEventFilter::RazorKbIndicatorEventFilter(QObject *parent):
QObject(parent),
oldEventFilter(0)
{
if (!filterObject)
{
filterObject = this;
display = QX11Info::display();
if (initXkbExtension())
if (XkbSelectEvents(display, XkbUseCoreKbd, XkbIndicatorStateNotifyMask, XkbIndicatorStateNotifyMask))
oldEventFilter = QAbstractEventDispatcher::instance()->setEventFilter(::X11_eventFilter);
}
}
int main(void) {
Display *disp;
int opcode;
unsigned int state;
int maj = XkbMajorVersion;
int min = XkbMinorVersion;
XkbEvent ev;
/* Open Display */
if ( !(disp = XOpenDisplay(NULL))) {
fprintf(stderr, "Can't open display: CHECK DISPLAY VARIABLE\n");
exit(1);
}
if (!XkbLibraryVersion(&maj, &min)) {
fprintf(stderr, "Couldn't get Xkb library version\n");
exit(1);
}
if (!XkbQueryExtension(disp, &opcode, &xkb_event_base, &xkb_error_base, &maj, &min)) {
fprintf(stderr, "XkbQueryExtension error\n");
exit(1);
}
if (!XkbSelectEvents(disp, XkbUseCoreKbd, XkbIndicatorStateNotifyMask,
XkbIndicatorStateNotifyMask)) {
fprintf(stderr, "XkbSelectEvents\n");
exit(1);
}
XkbGetIndicatorState(disp, XkbUseCoreKbd, &state);
displayState(state);
/*
win = XCreateSimpleWindow(disp, DefaultRootWindow(display), 0, 0, 200, 300, 5, white,
black);
*/
while (1) {
XNextEvent(disp, &ev.core);
if (ev.type == xkb_event_base && ev.any.xkb_type == XkbIndicatorStateNotify) {
displayState(ev.indicators.state);
}
}
return 0;
}
void KbdStateListener::run()
{
#ifdef USE_XCB
conn = xcb_connect(0,0);
xcb_void_cookie_t ck = xcb_xkb_select_events(conn, XCB_XKB_ID_USE_CORE_KBD, XCB_EVENT_MASK_KEYMAP_STATE, 0,0,XCB_EVENT_MASK_KEYMAP_STATE,0,0);
xcb_request_check(conn,ck);
forever{ break; //something is wrong, probably xcb_xkb_select_events is not used properly (any docs somewhere???)
xcb_wait_for_event(conn);
#else
dpy = XOpenDisplay(0);
XkbSelectEvents((Display *)dpy, XkbUseCoreKbd, XkbStateNotifyMask, XkbStateNotifyMask);
forever{
XEvent xev;
XNextEvent((Display *)dpy,&xev);
#endif
emit eventRecived();
}
}
static void
xfce_accessibility_helper_init (XfceAccessibilityHelper *helper)
{
gint dummy;
helper->channel = NULL;
#ifdef HAVE_LIBNOTIFY
helper->notification = NULL;
#endif /* !HAVE_LIBNOTIFY */
if (XkbQueryExtension (GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), &dummy, &dummy, &dummy, &dummy, &dummy))
{
/* open the channel */
helper->channel = xfconf_channel_get ("accessibility");
/* monitor channel changes */
g_signal_connect (G_OBJECT (helper->channel), "property-changed", G_CALLBACK (xfce_accessibility_helper_channel_property_changed), helper);
/* restore the xbd configuration */
xfce_accessibility_helper_set_xkb (helper, XkbStickyKeysMask | XkbSlowKeysMask | XkbBounceKeysMask | XkbMouseKeysMask | XkbAccessXKeysMask);
#ifdef HAVE_LIBNOTIFY
/* setup a connection with the notification daemon */
if (!notify_init ("xfce4-settings-helper"))
g_critical ("Failed to connect to the notification daemon.");
/* add event filter */
XkbSelectEvents (GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), XkbUseCoreKbd, XkbControlsNotifyMask, XkbControlsNotifyMask);
/* monitor all window events */
gdk_window_add_filter (NULL, xfce_accessibility_helper_event_filter, helper);
#endif /* !HAVE_LIBNOTIFY */
}
else
{
/* warning */
g_critical ("Failed to initialize the Accessibility extension.");
}
}
LxQtKbIndicator::LxQtKbIndicator(const ILxQtPanelPluginStartupInfo &startupInfo):
QObject(),
ILxQtPanelPlugin(startupInfo),
mContent(new QLabel())
{
connect(this, SIGNAL(indicatorsChanged(uint,uint)), this, SLOT(setIndicators(uint,uint)));
mContent->setAlignment(Qt::AlignCenter);
int code;
int major = XkbMajorVersion;
int minor = XkbMinorVersion;
int XkbErrorBase;
mDisplay = QX11Info::display();
if (XkbLibraryVersion(&major, &minor))
if (XkbQueryExtension(mDisplay, &code, &mXkbEventBase, &XkbErrorBase, &major, &minor))
if (XkbUseExtension(mDisplay, &major, &minor))
XkbSelectEvents(mDisplay, XkbUseCoreKbd, XkbIndicatorStateNotifyMask, XkbIndicatorStateNotifyMask);
QTimer::singleShot(0, this, SLOT(delayedInit()));
}
static void
spi_controller_register_with_devices (SpiDEController *controller)
{
DEControllerPrivateData *priv;
int event_base, error_base, major_version, minor_version;
priv = controller->priv;
if (XTestQueryExtension (spi_get_display(), &event_base, &error_base, &major_version, &minor_version))
{
XTestGrabControl (spi_get_display (), True);
}
/* calls to device-specific implementations and routines go here */
/* register with: keyboard hardware code handler */
/* register with: (translated) keystroke handler */
priv->have_xkb = XkbQueryExtension (spi_get_display (),
&priv->xkb_major_extension_opcode,
&priv->xkb_base_event_code,
&priv->xkb_base_error_code, NULL, NULL);
if (priv->have_xkb)
{
gint i;
guint64 reserved = 0;
priv->xkb_desc = XkbGetMap (spi_get_display (), XkbKeySymsMask, XkbUseCoreKbd);
XkbSelectEvents (spi_get_display (),
XkbUseCoreKbd,
XkbStateNotifyMask, XkbStateNotifyMask);
_numlock_physical_mask = XkbKeysymToModifiers (spi_get_display (),
XK_Num_Lock);
for (i = priv->xkb_desc->max_key_code; i >= priv->xkb_desc->min_key_code; --i)
{
if (priv->xkb_desc->map->key_sym_map[i].kt_index[0] == XkbOneLevelIndex)
{
if (XkbKeycodeToKeysym (spi_get_display (), i, 0, 0) != 0)
{
/* don't use this one if there's a grab client! */
/* Runtime errors are generated from these functions,
* that are then quashed. Equivalent to:
* try
* {Blah}
* except
* {;}
*/
spi_x_error_trap ();
XGrabKey (spi_get_display (), i, 0,
spi_get_root_window (),
TRUE,
GrabModeSync, GrabModeSync);
XSync (spi_get_display (), TRUE);
XUngrabKey (spi_get_display (), i, 0,
spi_get_root_window ());
if (!spi_x_error_release ())
{
reserved = i;
break;
}
}
}
}
if (reserved)
{
priv->reserved_keycode = reserved;
priv->reserved_keysym = XkbKeycodeToKeysym (spi_get_display (), reserved, 0, 0);
}
else
{
priv->reserved_keycode = XKeysymToKeycode (spi_get_display (), XK_numbersign);
priv->reserved_keysym = XK_numbersign;
}
#ifdef SPI_RESERVED_DEBUG
unsigned sym = 0;
sym = XKeycodeToKeysym (spi_get_display (), reserved, 0);
fprintf (stderr, "%x\n", sym);
fprintf (stderr, "setting the reserved keycode to %d (%s)\n",
reserved,
XKeysymToString (XKeycodeToKeysym (spi_get_display (),
reserved, 0)));
#endif
}
spi_set_filter (global_filter_fn, controller);
spi_set_events (KeyPressMask | KeyReleaseMask);
x_default_error_handler = XSetErrorHandler (_spi_controller_device_error_handler);
}
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)
/* main program (and loop) */
int main(int argc, char **argv)
{
char s[1024];
char batstat[1024];
int i;
struct tm ts;
time_t t;
int screen;
int xkb_ext = -1;
int xkbev, xkberr;
/* install exit() handler */
if(atexit(killemall))
{
fprintf(stderr, "Cannot install exit handler.\n");
exit(1);
}
if(argc > 1)
{
for(i = 1; i < argc; i++)
{
if(argv[i][0] != '-'
|| !argv[i][1]
|| argv[i][2])
{
fprintf(stderr, "Unrecognized option '%s'.\n", argv[i]);
exit(1);
}
switch(argv[i][1])
{
case 'd':
fprintf(stderr, "debug mode.\n");
debug_mode = 1;
break;
case 'c':
fprintf(stderr, "stdout mode -- no print to X.\n");
stdout_mode = 1;
break;
default:
fprintf(stderr, "Unrecognized option '%s'.\n", argv[i]);
exit(1);
}
}
}
/* Get X11 root window and screen */
if(!(dpy = XOpenDisplay(0)))
{
fprintf(stderr, "Cannot open display\n");
exit(1);
}
screen = DefaultScreen(dpy);
rootwin = RootWindow(dpy, screen);
/* Initialize ACPI */
battery_status_init();
/* keyboard sexy leds initialization (this sentence has no sense) */
if (!init_xkb_extension(&xkbev, &xkberr))
{
fprintf(stderr, "warning: no sexy kbd extension found.\n");
xkb_ext = 0;
} else {
if(!XkbSelectEvents(dpy, XkbUseCoreKbd, XkbIndicatorStateNotifyMask, XkbIndicatorStateNotifyMask))
{
fprintf(stderr, "warning: no sexy kbd event filter.\n");
xkb_ext = 0;
}
}
/* main loop */
while(1)
{
/* read ac/battery state */
battery_status_get();
/* print report */
*batstat = '\0';
if(energy.batn > 0)
{
if(energy.on_ac)
strcat(batstat, "AC");
if(energy.batn > 1)
{
char s = '(';
for(i = 0; i < energy.batn; i++)
{
sprintf(batstat + strlen(batstat),
"%c%s%.0f%%",
s,
energy.batt[i].status == BATTSTAT_ST_NOTCHARGING ? "!" :
energy.batt[i].status == BATTSTAT_ST_CHARGING ? "+" :
energy.batt[i].status == BATTSTAT_ST_DISCHARGING ? "-" :
energy.batt[i].status == BATTSTAT_ST_FULL ? "" : "?",
energy.batt[i].charge_level);
s = ',';
}
strcat(batstat, ")");
}
switch(energy.status)
{
case BATTSTAT_ST_NOTCHARGING: strcat(batstat, " NOT charging "); break;
case BATTSTAT_ST_DISCHARGING: break;
case BATTSTAT_ST_CHARGING: strcat(batstat, " charging "); break;
case BATTSTAT_ST_FULL: strcat(batstat, " full "); break;
default:
case BATTSTAT_ST_UNKNOWN: strcat(batstat, " unknown "); break;
}
if(energy.rem_time > 0)
sprintf(batstat + strlen(batstat), "%.0f%%, %d:%02d",
energy.charge_level,
(energy.rem_time / 60) / 60,
(energy.rem_time / 60) % 60);
else
sprintf(batstat + strlen(batstat), "%.0f%%",
energy.charge_level);
}
/* what time is it? [TIME TO DIE M**********R!!!] */
time(&t);
localtime_r(&t, &ts);
/* format msg */
sprintf(s, "%02d:%02d %02d/%02d/%d ",
ts.tm_hour, ts.tm_min,
ts.tm_mday, ts.tm_mon + 1, ts.tm_year + 1900);
/* add ac/battery status report */
if(strlen(batstat) > 0)
{
strcat(s, "[");
strcat(s, batstat);
strcat(s, "] ");
}
/* get key status */
if(xkb_ext)
{
unsigned int state;
char *t = s + strlen(s);
XkbGetIndicatorState(dpy, XkbUseCoreKbd, &state);
*t++ = state & (1 << 0) ? 'M' : '_';
*t++ = state & (1 << 1) ? 'N' : '_';
*t++ = state & (1 << 2) ? 'S' : '_';
*t = '\0';
}
/* update dwm title */
if(stdout_mode)
{
printf("%s\n", s);
} else {
XStoreName(dpy, rootwin, s);
XFlush(dpy);
}
/* wait a little before repeat */
sleep(1);
}
}
int
main(int argc, char *argv[])
{
Widget toplevel;
XtAppContext app_con;
Widget panel;
Widget base[XkbNumModifiers];
Widget latched[XkbNumModifiers];
Widget locked[XkbNumModifiers];
Widget effective[XkbNumModifiers];
Widget compat[XkbNumModifiers];
Widget baseBox, latchBox, lockBox, effBox, compatBox;
register int i;
unsigned bit;
XkbEvent ev;
XkbStateRec state;
static Arg hArgs[] = { {XtNorientation, (XtArgVal) XtorientHorizontal} };
static Arg vArgs[] = { {XtNorientation, (XtArgVal) XtorientVertical} };
static Arg onArgs[] = { {XtNon, (XtArgVal) True} };
static Arg offArgs[] = { {XtNon, (XtArgVal) False} };
static char *fallback_resources[] = {
"*Box*background: grey50",
"*Box*borderWidth: 0",
"*Box*vSpace: 1",
NULL
};
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-version") == 0) {
printf("xkbwatch (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION);
exit(0);
}
}
uSetErrorFile(NullString);
toplevel = XtOpenApplication(&app_con, "XkbWatch",
options, XtNumber(options), &argc, argv,
fallback_resources,
sessionShellWidgetClass, NULL, ZERO);
if (toplevel == NULL) {
uFatalError("Couldn't create application top level\n");
exit(1);
}
inDpy = outDpy = XtDisplay(toplevel);
if (inDpy) {
int i1, mn, mj;
mj = XkbMajorVersion;
mn = XkbMinorVersion;
if (!XkbQueryExtension(inDpy, &i1, &evBase, &errBase, &mj, &mn)) {
uFatalError("Server doesn't support a compatible XKB\n");
exit(1);
}
}
panel =
XtCreateManagedWidget("xkbwatch", boxWidgetClass, toplevel, vArgs, 1);
if (panel == NULL) {
uFatalError("Couldn't create top level box\n");
exit(1);
}
baseBox = XtCreateManagedWidget("base", boxWidgetClass, panel, hArgs, 1);
if (baseBox == NULL)
uFatalError("Couldn't create base modifiers box\n");
latchBox =
XtCreateManagedWidget("latched", boxWidgetClass, panel, hArgs, 1);
if (latchBox == NULL)
uFatalError("Couldn't create latched modifiers box\n");
lockBox = XtCreateManagedWidget("locked", boxWidgetClass, panel, hArgs, 1);
if (lockBox == NULL)
uFatalError("Couldn't create locked modifiers box\n");
effBox =
XtCreateManagedWidget("effective", boxWidgetClass, panel, hArgs, 1);
if (effBox == NULL)
uFatalError("Couldn't create effective modifiers box\n");
compatBox =
XtCreateManagedWidget("compat", boxWidgetClass, panel, hArgs, 1);
if (compatBox == NULL)
uFatalError("Couldn't create compatibility state box\n");
XkbSelectEvents(inDpy, XkbUseCoreKbd, XkbStateNotifyMask,
XkbStateNotifyMask);
XkbGetState(inDpy, XkbUseCoreKbd, &state);
for (i = XkbNumModifiers - 1, bit = 0x80; i >= 0; i--, bit >>= 1) {
ArgList list;
char buf[30];
sprintf(buf, "base%d", i);
if (state.base_mods & bit)
list = onArgs;
else
list = offArgs;
base[i] = XtCreateManagedWidget(buf, ledWidgetClass, baseBox, list, 1);
sprintf(buf, "latched%d", i);
if (state.latched_mods & bit)
list = onArgs;
else
list = offArgs;
latched[i] =
XtCreateManagedWidget(buf, ledWidgetClass, latchBox, list, 1);
sprintf(buf, "locked%d", i);
if (state.locked_mods & bit)
list = onArgs;
else
list = offArgs;
locked[i] =
XtCreateManagedWidget(buf, ledWidgetClass, lockBox, list, 1);
sprintf(buf, "effective%d", i);
if (state.mods & bit)
list = onArgs;
else
list = offArgs;
effective[i] =
XtCreateManagedWidget(buf, ledWidgetClass, effBox, list, 1);
sprintf(buf, "compat%d", i);
if (state.compat_state & bit)
list = onArgs;
else
list = offArgs;
compat[i] =
XtCreateManagedWidget(buf, ledWidgetClass, compatBox, list, 1);
}
XtRealizeWidget(toplevel);
while (1) {
XtAppNextEvent(app_con, &ev.core);
if (ev.core.type == evBase + XkbEventCode) {
if (ev.any.xkb_type == XkbStateNotify) {
unsigned changed;
if (ev.state.changed & XkbModifierBaseMask) {
changed = ev.state.base_mods ^ state.base_mods;
state.base_mods = ev.state.base_mods;
for (i = 0, bit = 1; i < XkbNumModifiers; i++, bit <<= 1) {
if (changed & bit) {
ArgList list;
if (state.base_mods & bit)
list = onArgs;
else
list = offArgs;
XtSetValues(base[i], list, 1);
}
}
}
if (ev.state.changed & XkbModifierLatchMask) {
changed = ev.state.latched_mods ^ state.latched_mods;
state.latched_mods = ev.state.latched_mods;
for (i = 0, bit = 1; i < XkbNumModifiers; i++, bit <<= 1) {
if (changed & bit) {
ArgList list;
if (state.latched_mods & bit)
list = onArgs;
else
list = offArgs;
XtSetValues(latched[i], list, 1);
}
}
}
if (ev.state.changed & XkbModifierLockMask) {
changed = ev.state.locked_mods ^ state.locked_mods;
state.locked_mods = ev.state.locked_mods;
for (i = 0, bit = 1; i < XkbNumModifiers; i++, bit <<= 1) {
if (changed & bit) {
ArgList list;
if (state.locked_mods & bit)
list = onArgs;
else
list = offArgs;
XtSetValues(locked[i], list, 1);
}
}
}
if (ev.state.changed & XkbModifierStateMask) {
changed = ev.state.mods ^ state.mods;
state.mods = ev.state.mods;
for (i = 0, bit = 1; i < XkbNumModifiers; i++, bit <<= 1) {
if (changed & bit) {
ArgList list;
if (state.mods & bit)
list = onArgs;
else
list = offArgs;
XtSetValues(effective[i], list, 1);
}
}
}
if (ev.state.changed & XkbCompatStateMask) {
changed = ev.state.compat_state ^ state.compat_state;
state.compat_state = ev.state.compat_state;
for (i = 0, bit = 1; i < XkbNumModifiers; i++, bit <<= 1) {
if (changed & bit) {
ArgList list;
if (state.compat_state & bit)
list = onArgs;
else
list = offArgs;
XtSetValues(compat[i], list, 1);
}
}
}
}
}
else
XtDispatchEvent(&ev.core);
}
/* BAIL: */
if (inDpy)
XCloseDisplay(inDpy);
if (outDpy != inDpy)
XCloseDisplay(outDpy);
inDpy = outDpy = NULL;
return 0;
}
int main(void) {
Display *xdisplay;
XkbEvent xevent;
int opcode, xkbEventBase, xkbErrorBase, major, minor;
int currentLayout = 0;
time_t timestamp;
char datetime[DATETIME_BUFFER + 1];
int status;
snd_mixer_t *amixer;
snd_mixer_elem_t *amixer_elem;
snd_mixer_selem_id_t *amixer_selem;
long int volume, volumeMin, volumeMax, volumePercent;
struct udev *udev;
struct udev_monitor *udev_monitor;
struct udev_device *udev_device;
int udev_fd;
int ps_current = 0, ps_total = 0;
openlog(NULL, LOG_CONS|LOG_PERROR|LOG_PID, LOG_DAEMON);
if (!(xdisplay = XOpenDisplay(NULL))) {
syslog(LOG_ERR, "Can't open display: %s!\n", strerror(errno));
return EXIT_FAILURE;
}
if (!XkbQueryExtension(xdisplay, &opcode, &xkbEventBase, &xkbErrorBase, &major, &minor)) {
syslog(LOG_ERR, "X doesn't support a compatible Xkb!\n");
return EXIT_FAILURE;
}
if (!XkbSelectEvents(xdisplay, XkbUseCoreKbd, XkbStateNotifyMask, XkbStateNotifyMask)) {
syslog(LOG_ERR, "Could not set Xkb event mask!\n");
return EXIT_FAILURE;
}
if ((status = snd_mixer_open(&amixer, 0)) < 0 || (status = snd_mixer_selem_register(amixer, NULL, NULL)) < 0 || (status = snd_mixer_attach(amixer, "default")) < 0) {
syslog(LOG_ERR, "Alsa failed: %s!\n", snd_strerror(status));
return EXIT_FAILURE;
}
if ((status = snd_mixer_load(amixer)) || (status = snd_mixer_selem_id_malloc(&amixer_selem)) < 0) {
syslog(LOG_ERR, "Alsa failed: %s!\n", snd_strerror(status));
return EXIT_FAILURE;
}
snd_mixer_selem_id_set_index(amixer_selem, 0);
snd_mixer_selem_id_set_name(amixer_selem, "Master");
amixer_elem = snd_mixer_find_selem(amixer, amixer_selem);
snd_mixer_selem_get_playback_volume_range(amixer_elem, &volumeMin, &volumeMax);
if (amixer_elem == NULL) {
syslog(LOG_ERR, "Mixer simple element handle not found!\n");
return EXIT_FAILURE;
}
udev = udev_new();
if (udev == NULL) {
syslog(LOG_ERR, "Can't create udev object!\n");
return EXIT_FAILURE;
}
udev_monitor = udev_monitor_new_from_netlink(udev, "udev");
if (udev_monitor == NULL) {
syslog(LOG_ERR, "Can't create udev monitor!\n");
return EXIT_SUCCESS;
}
if (udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "power_supply", NULL) < 0) {
syslog(LOG_ERR, "Could't watch power_supply events!\n");
return EXIT_FAILURE;
}
if (udev_monitor_enable_receiving(udev_monitor) < 0) {
syslog(LOG_ERR, "Could't bind udev monitor event!\n");
return EXIT_FAILURE;
}
udev_fd = udev_monitor_get_fd(udev_monitor);
while(1) {
time(×tamp);
strftime(datetime, DATETIME_BUFFER, DATETIME_FORMAT, localtime(×tamp));
while(XPending(xdisplay)) {
XNextEvent(xdisplay, &xevent.core);
if (xevent.type == xkbEventBase && xevent.any.xkb_type == XkbStateNotify) {
currentLayout = xevent.state.group;
}
}
if ((status = snd_mixer_handle_events(amixer)) < 0) {
syslog(LOG_ERR, "Alsa failed: %s!\n", snd_strerror(status));
return EXIT_FAILURE;
}
if ((status = snd_mixer_selem_get_playback_volume(amixer_elem, SND_MIXER_SCHN_MONO, &volume)) < 0) {
syslog(LOG_ERR, "Alsa failed: %s!\n", snd_strerror(status));
return EXIT_FAILURE;
}
volumePercent = (volume * 100) / volumeMax;
fd_set fds;
int ret;
struct timeval tv = {.tv_sec = 0, .tv_usec = 0};
FD_ZERO(&fds);
FD_SET(udev_fd, &fds);
ret = select(udev_fd + 1, &fds, NULL, NULL, &tv);
if (ret > 0 && FD_ISSET(udev_fd, &fds)) {
udev_device = udev_monitor_receive_device(udev_monitor);
if (udev_device == NULL) {
syslog(LOG_ERR, "Can't get udev device!\n");
return EXIT_SUCCESS;
}
printf("Name: %s\n", udev_device_get_sysname(udev_device));
printf("Node: %s\n", udev_device_get_devnode(udev_device));
printf("Subsystem: %s\n", udev_device_get_subsystem(udev_device));
printf("Devtype: %s\n", udev_device_get_devtype(udev_device));
printf("Action: %s\n", udev_device_get_action(udev_device));
/*ps_current = atoi(udev_device_get_property_value(udev_device, "POWER_SUPPLY_CHARGE_NOW"));*/
/*ps_total = atoi(udev_device_get_property_value(udev_device, "POWER_SUPPLY_CHARGE_FULL"));*/
printf("%s\n", udev_device_get_sysattr_value(udev_device, "energy_now"));
printf("%s\n", udev_device_get_sysattr_value(udev_device, "energy_full"));
udev_device_unref(udev_device);
}
printf("%s %s\t%s %li\t%s %i\t%s %s\n",
GLYPH_KEYBOARD, layouts[currentLayout],
GLYPH_VOLUME, volumePercent,
GLYPH_BATTERY, ps_current,
GLYPH_CLOCK, datetime
);
usleep(SLEEP_MSECONDS * 1000);
}
snd_mixer_selem_id_free(amixer_selem);
snd_mixer_close(amixer);
XCloseDisplay(xdisplay);
closelog();
return EXIT_SUCCESS;
}
void XWindow::init(const XDisplay &d)
{
windowMutex = new Mutex(true);
delegationsToExecute = new Collection<void *>();
controls = new Collection<Control *>();
windowDisplay = d.d;
windowScreen = XDefaultScreen(windowDisplay);
windowParent = XRootWindow(windowDisplay, windowScreen);
windowVisual = DefaultVisual(windowDisplay, windowScreen);
area = new NRectangle(0, 0, 400, 300);
borderwidth = 1;
colordepth = DefaultDepth(windowDisplay, windowScreen);
visible = false;
backcolor = new NColor(0.95, 0.95, 0.97, 1.0);
font = new NFont("Ubuntu Mono", NFont::FontWeightBold, 10);
drawEnabled = true;
composeKeySymBuffer = new Text("");
// Creates delegates
dOnWindowKeyPress = new NDelegationManager();
dOnWindowKeyRelease = new NDelegationManager();
dOnWindowKeySymbol = new NDelegationManager();
dOnWindowKeymap = new NDelegationManager();
dOnWindowKeyboardMapping = new NDelegationManager();
dOnWindowMouseDown = new NDelegationManager();
dOnWindowMouseUp = new NDelegationManager();
dOnWindowMouseMove = new NDelegationManager();
dOnWindowEnterLeave = new NDelegationManager();
dOnWindowDraw = new NDelegationManager();
dOnWindowShow = new NDelegationManager();
dOnWindowMove = new NDelegationManager();
dOnWindowResize = new NDelegationManager();
dOnWindowFocus = new NDelegationManager();
dOnWindowPropertyChange = new NDelegationManager();
dOnWindowColormapChange = new NDelegationManager();
dOnWindowGrabButton = new NDelegationManager();
dOnWindowVisibilityChange = new NDelegationManager();
XSetWindowAttributes attrs;
memset(&attrs, 0, sizeof(attrs));
attrs.background_pixel = XWhitePixel(windowDisplay, windowScreen);
attrs.border_pixel = XBlackPixel(windowDisplay, windowScreen);
attrs.override_redirect = 0;
// Create window
window = XCreateWindow(
windowDisplay, windowParent, area->GetX(), area->GetY(),
area->GetWidth(), area->GetHeight(), borderwidth, colordepth, InputOutput,
windowVisual, CWBackPixel | CWBorderPixel | CWOverrideRedirect, &attrs);
XException::CheckResult(window);
// Select events
int res = XSelectInput(windowDisplay, window,
KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
EnterWindowMask | LeaveWindowMask | PointerMotionMask | ButtonMotionMask |
KeymapStateMask | ExposureMask | VisibilityChangeMask | StructureNotifyMask |
FocusChangeMask | PropertyChangeMask | ColormapChangeMask | OwnerGrabButtonMask);
XException::CheckResult(res);
// Select Xkb events
if (!XkbSelectEvents(windowDisplay, XkbUseCoreKbd,
XkbNewKeyboardNotifyMask | XkbMapNotifyMask | XkbStateNotifyMask,
XkbNewKeyboardNotifyMask | XkbMapNotifyMask | XkbStateNotifyMask))
throw new XException("Cannot select Xkb events", __FILE__, __LINE__, __func__);
if (!XkbSelectEvents(windowDisplay, XkbUseCoreKbd, XkbAllEventsMask, XkbAllEventsMask))
throw new XException("Cannot select Xkb events", __FILE__, __LINE__, __func__);
// Create a graphics context
gc = new XWindowGraphics(*this);
// Show window
SetVisible(true);
}
