add autograb mode and inputlock mode

Fixes #384

You can now toggle between autograb mode by pressing CTRL-ALT-G
(default, can be adjusted in keystrokes.cfg).

You can toogle inputlock mode (pointer stays in the nxagent window) by
pressing CTRL-ALT-C.

Author: uli42

doc/nxagent/README.keystrokes

@@ -103,6 +103,10 @@ reread_keystrokes
   forces nxagent to re-read the keystroke
   configuration. Useful to add/changes keystrokes for a running
   session.
+autograb
+  enable/disable autograb mode
+lockinput
+  lock/unlock pointer within nxagent window
 
 Only in builds with certain debugging options enabled, ignored otherwise:
 force_synchronization

etc/keystrokes.cfg

@@ -17,4 +17,6 @@
 <keystroke action="viewport_move_right" Control="1" AltMeta="1" key="Right" />
 <keystroke action="viewport_move_down" Control="1" AltMeta="1" key="Down" />
 <keystroke action="reread_keystrokes" Control="1" AltMeta="1" key="k" />
+<keystroke action="autograb" Control="1" AltMeta="1" key="g" />
+<keystroke action="lockinput" Control="1" AltMeta="1" key="c" />
 </keystrokes>

nx-X11/programs/Xserver/hw/nxagent/Events.c

@@ -78,6 +78,8 @@
 #undef Atom
 #undef Time
 
+#include <nx-X11/Xatom.h>
+
 #ifdef NXAGENT_FIXKEYS
 #include "inputstr.h"
 #include "input.h"
@@ -690,6 +692,103 @@ static void nxagentSwitchDeferMode(void)
   }
 }
 
+void setWinNameSuffix(const char *suffix)
+{
+  static unsigned char * prev = NULL;
+  char * pre = " (";
+  char * post = ")";
+  char * newname;
+
+  if (suffix) {
+    if (!(newname = calloc(strlen(nxagentWindowName) + strlen(pre) + strlen(suffix) + strlen(post) + 1, sizeof(char))))
+    {
+      fprintf(stderr, "%s: malloc failed", __func__);
+	return;
+    }
+    strcpy(newname, nxagentWindowName);
+    strcpy(newname + strlen(nxagentWindowName), pre);
+    strcpy(newname + strlen(nxagentWindowName) + strlen(pre), suffix);
+    strcpy(newname + strlen(nxagentWindowName) + strlen(pre) + strlen(suffix), post);
+    free(prev);
+    prev = NULL;
+    XFetchName(nxagentDisplay, nxagentDefaultWindows[0], &prev);
+    XStoreName(nxagentDisplay, nxagentDefaultWindows[0], newname);
+    free(newname);
+  }
+  else
+  {
+    if (prev)
+    {
+	XStoreName(nxagentDisplay, nxagentDefaultWindows[0], prev);
+	free(prev);
+	prev = NULL;
+    }
+    else
+    {
+	XStoreName(nxagentDisplay, nxagentDefaultWindows[0], nxagentWindowName);
+    }
+  }
+}
+
+static Bool autograb = False;
+static Bool inputlock = False;
+
+static void nxagentAutoGrab(void)
+{
+  if (!inputlock)
+  {
+    #ifdef DEBUG
+    if (autograb)
+      fprintf(stderr, "disabling autograb\n");
+    else
+      fprintf(stderr, "enabling autograb\n");
+    #endif
+
+    if (!autograb)
+    {
+      nxagentGrabPointerAndKeyboard(NULL);
+      setWinNameSuffix("autograb on");
+    }
+    else
+    {
+      nxagentUngrabPointerAndKeyboard(NULL);
+      setWinNameSuffix(NULL);
+    }
+    autograb = !autograb;
+  }
+}
+
+/* TODO: drop inputlock when switching to Fullscreen */
+static void nxagentLockInput(void)
+{
+  #ifdef DEBUG
+  if (inputlock)
+    fprintf(stderr, "releasing inputlock\n");
+  else
+    fprintf(stderr, "activating inputlock\n");
+  #endif
+
+  if (!inputlock)
+  {
+    setWinNameSuffix("input locked");
+    XGrabPointer(nxagentDisplay,nxagentDefaultWindows[0], True,
+		 ButtonPressMask | ButtonReleaseMask | PointerMotionMask | FocusChangeMask | EnterWindowMask | LeaveWindowMask,
+		 GrabModeAsync, GrabModeAsync, nxagentDefaultWindows[0], None, CurrentTime);
+  }
+  else
+  {
+    nxagentUngrabPointerAndKeyboard(NULL);
+    XTextProperty name = {
+      .value    = (unsigned char *)nxagentWindowName,
+      .encoding = XA_STRING,
+      .format   = 8,
+      .nitems   = strlen((char *) name.value)
+    };
+    setWinNameSuffix(NULL);
+  }
+  inputlock = !inputlock;
+}
+
 static Bool nxagentExposurePredicate(Display *display, XEvent *event, XPointer window)
 {
   /*
@@ -1083,6 +1182,18 @@ void nxagentDispatchEvents(PredicateFuncPtr predicate)
 
             break;
           }
+          case doAutoGrab:
+          {
+            nxagentAutoGrab();
+
+            break;
+          }
+          case doLockInput:
+          {
+            nxagentLockInput();
+
+            break;
+          }
           default:
           {
             FatalError("nxagentDispatchEvent: handleKeyPress returned unknown value\n");
@@ -1537,6 +1648,17 @@ FIXME: Don't enqueue the KeyRelease event if the key was
           }
         }
 
+        /* FIXME: only when in windowed mode! */
+        if (autograb)
+        {
+          if (X.xfocus.window == nxagentDefaultWindows[0] && X.xfocus.mode == NotifyNormal)
+          {
+            #ifdef DEBUG
+            fprintf(stderr, "%s: (FocusIn): grabbing\n", __func__);
+	    #endif
+            nxagentGrabPointerAndKeyboard(NULL);
+          }
+        }
         break;
       }
       case FocusOut:
@@ -1615,6 +1737,19 @@ FIXME: Don't enqueue the KeyRelease event if the key was
 
         #endif /* NXAGENT_FIXKEYS */
 
+        if (autograb)
+        {
+          XlibWindow w = NULL;
+          int revert_to;
+          XGetInputFocus(nxagentDisplay, &w, &revert_to);
+          if (w != nxagentDefaultWindows[0] && X.xfocus.mode == NotifyWhileGrabbed)
+          {
+            #ifdef DEBUG
+            fprintf(stderr, "%s: (FocusOut): ungrabbing\n", __func__);
+            #endif
+            nxagentUngrabPointerAndKeyboard(NULL);
+          }
+        }
         break;
       }
       case KeymapNotify:
@@ -3876,13 +4011,26 @@ void nxagentGrabPointerAndKeyboard(XEvent *X)
   fprintf(stderr, "nxagentGrabPointerAndKeyboard: Going to grab the keyboard in context [B1].\n");
   #endif
 
-  result = XGrabKeyboard(nxagentDisplay, nxagentFullscreenWindow,
-                             True, GrabModeAsync, GrabModeAsync, now);
+  if (nxagentFullscreenWindow)
+    result = XGrabKeyboard(nxagentDisplay, nxagentFullscreenWindow,
+      True, GrabModeAsync, GrabModeAsync, now);
+  else
+    result = XGrabKeyboard(nxagentDisplay, RootWindow(nxagentDisplay, DefaultScreen(nxagentDisplay)),
+      True, GrabModeAsync, GrabModeAsync, now);
 
   if (result != GrabSuccess)
   {
+    #ifdef DEBUG
+    fprintf(stderr, "%s: keyboard grab failed.\n", __func__);
+    #endif
     return;
   }
+  #ifdef DEBUG
+  else
+  {
+    fprintf(stderr, "%s: keyboard grab successful.\n", __func__);
+  }
+  #endif
 
   /*
    * The smart scheduler could be stopped while
@@ -3900,7 +4048,8 @@ void nxagentGrabPointerAndKeyboard(XEvent *X)
   resource = nxagentWaitForResource(NXGetCollectGrabPointerResource,
                                         nxagentCollectGrabPointerPredicate);
 
-  NXCollectGrabPointer(nxagentDisplay, resource,
+  if (nxagentFullscreenWindow)
+     NXCollectGrabPointer(nxagentDisplay, resource,
                            nxagentFullscreenWindow, True, NXAGENT_POINTER_EVENT_MASK,
                                GrabModeAsync, GrabModeAsync, None, None, now);
 

nx-X11/programs/Xserver/hw/nxagent/Events.h

@@ -51,7 +51,9 @@ enum HandleEventResult
   doViewportRight,
   doViewportDown,
   doSwitchResizeMode,
-  doSwitchDeferMode
+  doSwitchDeferMode,
+  doAutoGrab,
+  doLockInput
 };
 
 extern CARD32 nxagentLastEventTime;

nx-X11/programs/Xserver/hw/nxagent/Keystroke.c

@@ -91,6 +91,10 @@ char * nxagentSpecialKeystrokeNames[] = {
        "viewport_move_down",
 
        "reread_keystrokes",
+
+       "autograb",
+       "lockinput",
+
        NULL,
 };
 
@@ -126,6 +130,8 @@ struct nxagentSpecialKeystrokeMap default_map[] = {
   {KEYSTROKE_VIEWPORT_MOVE_DOWN, ControlMask | ShiftMask, True, XK_Down},
   {KEYSTROKE_VIEWPORT_MOVE_DOWN, ControlMask | ShiftMask, True, XK_KP_Down},
   {KEYSTROKE_REREAD_KEYSTROKES, ControlMask, True, XK_k},
+  {KEYSTROKE_AUTOGRAB, ControlMask, True, XK_g},
+  {KEYSTROKE_LOCKINPUT, ControlMask, True, XK_c},
   {KEYSTROKE_END_MARKER, 0, False, NoSymbol},
 };
 struct nxagentSpecialKeystrokeMap *map = default_map;
@@ -411,7 +417,7 @@ static enum nxagentSpecialKeystroke find_keystroke(XKeyEvent *X)
   #endif
   while (cur->stroke != KEYSTROKE_END_MARKER) {
     #ifdef DEBUG
-    fprintf(stderr, "%s: checking keysym '%c' (%d)\n", __func__, cur->keysym, cur->keysym);
+    fprintf(stderr,"%s: keysym %d stroke %d, type %d\n", __func__, cur->keysym, cur->stroke, X->type);
     #endif
     if (cur->keysym == keysym[0] && modifier_matches(cur->modifierMask, cur->modifierAltMeta, X->state)) {
       #ifdef DEBUG
@@ -588,6 +594,12 @@ Bool nxagentCheckSpecialKeystroke(XKeyEvent *X, enum HandleEventResult *result)
       if (X->type == KeyRelease)
 	parse_keystroke_file(True);
       break;
+    case KEYSTROKE_AUTOGRAB:
+      *result = doAutoGrab;
+      break;
+    case KEYSTROKE_LOCKINPUT:
+      *result = doLockInput;
+      break;
     case KEYSTROKE_NOTHING: /* do nothing. difference to KEYSTROKE_IGNORE is the return value */
     case KEYSTROKE_END_MARKER: /* just to make gcc STFU */
     case KEYSTROKE_MAX:

nx-X11/programs/Xserver/hw/nxagent/Keystroke.h

@@ -66,12 +66,15 @@ enum nxagentSpecialKeystroke {
 
        KEYSTROKE_REREAD_KEYSTROKES = 21,
 
-       KEYSTROKE_NOTHING = 22,
+       KEYSTROKE_AUTOGRAB = 22,
+       KEYSTROKE_LOCKINPUT = 23,
+
+       KEYSTROKE_NOTHING = 24,
 
        /* insert more here, increment KEYSTROKE_MAX accordingly.
         * then update string translation below */
 
-       KEYSTROKE_MAX = 23,
+       KEYSTROKE_MAX = 25,
 };
 
 struct nxagentSpecialKeystrokeMap {