bool isCapsLockOn()
{
Display *display = XOpenDisplay( NULL );
bool caps_state = false;
unsigned n;
XkbGetIndicatorState( display, XkbUseCoreKbd, &n );
caps_state = ( n & 0x01 ) == 1;
XCloseDisplay( display );
return caps_state;
}
bool LxQtKbIndicator::getLockStatus(int bit)
{
bool state = false;
if (mDisplay)
{
unsigned n;
XkbGetIndicatorState(mDisplay, XkbUseCoreKbd, &n);
state = (n & (1 << bit));
}
return state;
}
bool RazorKbIndicatorEventFilter::getLockStatus(int bit)
{
bool state = false;
if (display)
{
unsigned n;
XkbGetIndicatorState(display, XkbUseCoreKbd, &n);
state = (n & (1 << bit));
}
return state;
}
bool Platform::capsLockEnabled()
{
Display* d = X11Display::lock();
bool caps_state = false;
if (d) {
unsigned n;
XkbGetIndicatorState(d, XkbUseCoreKbd, &n);
caps_state = (n & 0x01) == 1;
}
X11Display::unlock();
return caps_state;
}
// Initialize the modifier lock masks.
static void initialize_locks() {
#ifdef USE_XKBCOMMON
if (xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS)) {
set_modifier_mask(MASK_CAPS_LOCK);
}
else {
unset_modifier_mask(MASK_CAPS_LOCK);
}
if (xkb_state_led_name_is_active(state, XKB_LED_NAME_NUM)) {
set_modifier_mask(MASK_NUM_LOCK);
}
else {
unset_modifier_mask(MASK_NUM_LOCK);
}
if (xkb_state_led_name_is_active(state, XKB_LED_NAME_SCROLL)) {
set_modifier_mask(MASK_SCROLL_LOCK);
}
else {
unset_modifier_mask(MASK_SCROLL_LOCK);
}
#else
unsigned int led_mask = 0x00;
if (XkbGetIndicatorState(hook->ctrl.display, XkbUseCoreKbd, &led_mask) == Success) {
if (led_mask & 0x01) {
set_modifier_mask(MASK_CAPS_LOCK);
}
else {
unset_modifier_mask(MASK_CAPS_LOCK);
}
if (led_mask & 0x02) {
set_modifier_mask(MASK_NUM_LOCK);
}
else {
unset_modifier_mask(MASK_NUM_LOCK);
}
if (led_mask & 0x04) {
set_modifier_mask(MASK_SCROLL_LOCK);
}
else {
unset_modifier_mask(MASK_SCROLL_LOCK);
}
}
else {
logger(LOG_LEVEL_WARN, "%s [%u]: XkbGetIndicatorState failed to get current led mask!\n",
__FUNCTION__, __LINE__);
}
#endif
}
bool Platform::capsLockEnabled()
{
Display* d = XOpenDisplay((char*)0);
bool caps_state = false;
if (d) {
unsigned n;
XkbGetIndicatorState(d, XkbUseCoreKbd, &n);
caps_state = (n & 0x01) == 1;
XCloseDisplay(d);
}
return caps_state;
}
void UserPromptView::CheckIfCapsLockOn()
{
Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
unsigned int state = 0;
XkbGetIndicatorState(dpy, XkbUseCoreKbd, &state);
// Caps is on 0x1, couldn't find any #define in /usr/include/X11
if ((state & 0x1) == 1)
caps_lock_on_ = true;
else
caps_lock_on_ = false;
}
// TRUE - success
gboolean xkbleds_get_state() {
d = XOpenDisplay(NULL);
if (!d)
return FALSE;
if(XkbGetIndicatorState(d, XkbUseCoreKbd, &states) != Success) {
XCloseDisplay(d);
return FALSE;
}
XCloseDisplay(d);
old_xkb_state=xkb_state;
xkb_state=states;
for(i = 0; i < NUM_LEDS; i++) {
xkb_leds[i]=((states & masks[i])!=0);
}
return TRUE;
}
bool checkCapsLock(Display* d) {
// platform dependent method of determining if CAPS LOCK is on
/*#ifdef Q_OS_WIN32 // MS Windows version
return GetKeyState(VK_CAPITAL) == 1;
#else // X11 version (Linux/Unix/Mac OS X/etc...)*/
//Display* d = XOpenDisplay((char*)0);
bool caps_state = false;
if (d) {
unsigned n;
XkbGetIndicatorState(d, XkbUseCoreKbd, &n);
//printf("Indicator State: %u\n",n);
caps_state = (n & 0x01) == 1;
}
return caps_state;
//#endif
}
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 handle_key(XCape_t *self, KeyMap_t *key,
Bool mouse_pressed, int key_event) {
if (key_event == KeyRelease) {
unsigned n;
int caps_state = 0;
int num_state = 0;
char msg[18] = "";
char *key_name = XKeysymToString(key->ks);
XkbGetIndicatorState(self->ctrl_conn, XkbUseCoreKbd, &n);
if (self->debug)
fprintf(stdout, "%s key state %d\n", key_name, n);
caps_state = (n & 0x01) == 1;
num_state = (n & 0x02) == 2;
if (strcmp(key_name, "Num_Lock") == 0) {
if (num_state) {
strcpy(msg, "Num Lock is on");
} else {
strcpy(msg, "Num Lock is off");
}
}
if (strcmp(key_name, "Caps_Lock") == 0) {
if (caps_state) {
strcpy(msg, "Caps Lock is on");
} else {
strcpy(msg, "Caps Lock is off");
}
}
notify_init("Lock key pressed");
NotifyNotification * notification = notify_notification_new(
"Lock key pressed", msg, "dialog-information");
notify_notification_show(notification, NULL);
g_object_unref(G_OBJECT(notification));
notify_uninit();
}
XFlush(self->ctrl_conn);
}
int xMaskedState( unsigned mask )
{
unsigned int state = 0;
XkbGetIndicatorState(display, XkbUseCoreKbd, &state);
return state & mask;
}
/* 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);
}
}
