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); }