Imported nxcompshad-3.2.0-3.tar.gz

nxcompshad/CHANGELOG

 ChangeLog:
 
+nxcompshad-3.2.0-3
+
+- Improved keycode translation.
+
+nxcompshad-3.2.0-2
+
+- Solved a problem when sending fake modifier events.
+
+- Added support for keyboard events handling for the web player.
+
+- Changed keycodes translation for Solaris keyboard.
+
+- Corrected a problem for keycodes translation from Solaris keyboard.
+
+- Fixed TR02F02001. In shadow session the shadower's keyboard layout
+  could be wrong. Now keycodes are correctly translated if master and
+  shadow keyboards have different layouts.
+
+- Added NXShadowGetScreenSize() and NXShadowSetScreenSize() functions,
+  so that the shadow session can handle correctly the resize of the
+  master session window.
+
+- Solved a compilation problem on GCC 4.3.
+
 nxcompshad-3.2.0-1
 
 - Opened the 3.2.0 branch based on nxcompshad-3.1.0-2.

nxcompshad/Core.cpp

@@ -538,6 +538,15 @@ void CorePoller::update(char *src, XRectangle r)
 
   for (unsigned int i = 0; i < r.height; i++)
   {
+    if(((r.x * bpp_ + r.y * bpl_) + bpl) > (bpl_ * height_))
+    {
+      //
+      // Out of bounds. Maybe a resize is going on.
+      //
+
+      continue;
+    }
+
     memcpy(dst, src, bpl);
 
     src += bpl;
@@ -574,6 +583,13 @@ void CorePoller::handleEvent(Display *display, XEvent *event)
   }
 }
 
+void CorePoller::handleWebKeyEvent(KeySym keysym, Bool isKeyPress)
+{
+  logTrace("CorePoller::handleWebKeyEvent");
+
+  handleWebKeyboardEvent(keysym, isKeyPress);
+}
+
 void CorePoller::handleInput()
 {
   while (input_ -> checkIfEvent())

nxcompshad/Core.h

@@ -68,6 +68,8 @@ class CorePoller
 
   void handleEvent(Display *, XEvent *);
 
+  void handleWebKeyEvent(KeySym keysym, Bool isKeyPress);
+
   Display *getShadowDisplay();
 
   void setShadowDisplay(Display *shadowDisplay);
@@ -115,6 +117,8 @@ class CorePoller
 
   virtual void handleKeyboardEvent(Display *, XEvent *) = 0;
 
+  virtual void handleWebKeyboardEvent(KeySym keysym, Bool isKeyPress) = 0;
+
   virtual void handleMouseEvent(Display *, XEvent *) = 0;
 
   Input *input_;

nxcompshad/Misc.h

@@ -18,11 +18,13 @@
 #ifndef Misc_H
 #define Misc_H
 
-#include <iostream.h>
+#include <iostream>
 
 #include <errno.h>
 #include <string.h>
 
+using namespace std;
+
 //
 // Error handling macros.
 //

nxcompshad/Shadow.cpp

@@ -28,6 +28,15 @@
 #include "Poller.h"
 #include "Manager.h"
 
+typedef struct {
+    KeySym  *map;
+    KeyCode minKeyCode,
+            maxKeyCode;
+    int     mapWidth;
+} KeySymsRec, *KeySymsPtr;
+
+KeySymsPtr NXShadowKeymap = NULL;
+
 ShadowOptions NXShadowOptions = {1, 1, -1};
 
 static int mirrorException = 0;
@@ -295,6 +304,16 @@ void NXShadowDisableDamage(void)
   NXShadowOptions.optionDamageExtension = 0;
 }
 
+void NXShadowGetScreenSize(int *w, int *h)
+{
+  poller -> getScreenSize(w, h);
+}
+
+void NXShadowSetScreenSize(int *w, int *h)
+{
+  poller -> setScreenSize(w, h);
+}
+
 #endif
 
 void NXShadowDestroy()
@@ -406,6 +425,11 @@ void NXShadowEvent(Display *display, XEvent event)
   poller -> handleEvent(display, &event);
 }
 
+void NXShadowWebKeyEvent(KeySym keysym, Bool isKeyPress)
+{
+  poller -> handleWebKeyEvent(keysym, isKeyPress);
+}
+
 #ifdef __CYGWIN32__
 
 int NXShadowCaptureCursor(unsigned int wnd, void *vis)
@@ -437,3 +461,11 @@ void NXShadowUpdateBuffer(void **buffer)
 
   logTest("NXShadowUpdateBuffer","New frame buffer [0x%p]", (void *)*fBuffer);
 }
+
+void NXShadowInitKeymap(void *keysyms)
+{
+  NXShadowKeymap = (KeySymsPtr) keysyms;
+
+  logTest("NXShadowInitKeymap","KeySyms pointer [0x%p] mapWidth [%d]",
+              (void *)NXShadowKeymap, NXShadowKeymap -> mapWidth);
+}

nxcompshad/Shadow.cpp.orig

+/**************************************************************************/
+/*                                                                        */
+/* Copyright (c) 2001, 2007 NoMachine, http://www.nomachine.com.          */
+/*                                                                        */
+/* NXCOMPSHAD, NX protocol compression and NX extensions to this software */
+/* are copyright of NoMachine. Redistribution and use of the present      */
+/* software is allowed according to terms specified in the file LICENSE   */
+/* which comes in the source distribution.                                */
+/*                                                                        */
+/* Check http://www.nomachine.com/licensing.html for applicability.       */
+/*                                                                        */
+/* NX and NoMachine are trademarks of Medialogic S.p.A.                   */
+/*                                                                        */
+/* All rights reserved.                                                   */
+/*                                                                        */
+/**************************************************************************/
+
+#include <signal.h>
+#include <string.h>
+
+#define PANIC
+#define WARNING
+#undef  TEST
+#undef  DEBUG
+
+#include "Logger.h"
+#include "Shadow.h"
+#include "Poller.h"
+#include "Manager.h"
+
+typedef struct {
+    KeySym  *map;
+    KeyCode minKeyCode,
+            maxKeyCode;
+    int     mapWidth;
+} KeySymsRec, *KeySymsPtr;
+
+KeySymsPtr NXShadowKeymap = NULL;
+
+ShadowOptions NXShadowOptions = {1, 1, -1};
+
+static int mirrorException = 0;
+
+static UpdateManager *updateManager;
+static Poller *poller;
+static Input *input;
+
+int NXShadowRemoveAllUpdaters();
+
+inline bool NXShadowNotInitialized()
+{
+  //
+  // updateManager depends on input and poller.
+  // So this test seem redundant.
+  //
+  // return (input == NULL) || (poller == NULL) || (updateManager == NULL);
+  //
+
+  return (updateManager == NULL);
+}
+
+#ifdef NEED_SIGNAL_HANDLER
+static void NXSignalHandler(int signal)
+{
+  logTest("NXSignalHandler", "Got signal [%d]", signal);
+
+  if (signal == SIGINT)
+  {
+    mirrorException = 1;
+  }
+  else if (signal == SIGTERM)
+  {
+    mirrorException = 1;
+  }
+}
+
+static int NXInitSignal()
+{
+  logTrace("NXInitSignal");
+
+  struct sigaction sa;
+
+  sa.sa_handler = NXSignalHandler;
+  sigfillset(&sa.sa_mask);
+  sa.sa_flags = 0;
+
+  int res;
+
+  while ((res = sigaction(SIGINT, &sa, NULL)) == -1 &&
+             errno == EINTR);
+
+  if (res == -1)
+  {
+    logError("NXInitSignal", EGET());
+
+    return -1;
+  }
+
+  return 1;
+}
+#endif
+
+static void NXHandleException()
+{
+  if (mirrorException)
+  {
+    mirrorException = 0;
+
+    NXShadowRemoveAllUpdaters();
+  }
+}
+
+static int NXCreateInput(char *keymap, char *shadowDisplayName)
+{
+  logTrace("NXCreateInput");
+
+  input = new Input;
+
+  if (input == NULL)
+  {
+    logError("NXCreateInput", ESET(ENOMEM));
+
+    return -1;
+  }
+
+  input -> setKeymap(keymap);
+
+  input -> setShadowDisplayName(shadowDisplayName);
+
+  return 1;
+}
+
+static int NXCreatePoller(Display *display, Display **shadowDisplay)
+{
+  logTrace("NXCreatePoller");
+
+  if (input == NULL)
+  {
+    logError("NXCreatePoller", ESET(EBADFD));
+
+    return -1;
+  }
+
+  poller = new Poller(input,display);
+
+  if (poller == NULL)
+  {
+    logError("NXCreatePoller", ESET(ENOMEM));
+
+    return -1;
+  }
+
+  if (poller -> init() == -1)
+  {
+    logTest("NXCreatePoller", "Failed to initialize poller.");
+
+    return -1;
+  }
+
+  *shadowDisplay = poller -> getShadowDisplay();
+
+  logTest("NXCreatePoller", "Poller geometry [%d, %d], ShadowDisplay[%p].", poller -> width(),
+              poller -> height(), (Display *) *shadowDisplay);
+
+  return 1;
+}
+
+static int NXCreateUpdateManager()
+{
+  logTrace("NXCreateUpdateManager");
+
+  if (input == NULL || poller == NULL)
+  {
+    logError("NXCreateUpdateManager", ESET(EBADFD));
+
+    return -1;
+  }
+
+  updateManager = new UpdateManager(poller -> width(), poller -> height(),
+                                        poller -> getFrameBuffer(), input);
+
+  if (updateManager == NULL)
+  {
+    logError("NXCreateUpdateManager", ESET(ENOMEM));
+
+    return -1;
+  }
+
+  return 1;
+}
+
+void  NXShadowResetOptions()
+{
+  NXShadowOptions.optionShmExtension = 1;
+  NXShadowOptions.optionDamageExtension = 1;
+}
+
+//
+// Exported functions.
+//
+
+int NXShadowHasUpdaters()
+{
+  logTrace("NXShadowHasUpdaters");
+
+  return (updateManager && updateManager -> numberOfUpdaters()) ? 1 : 0;
+}
+
+int NXShadowRemoveAllUpdaters()
+{
+  logTrace("NXShadowRemoveAllUpdaters");
+
+  return updateManager ? updateManager -> removeAllUpdaters() : 0;
+}
+
+int NXShadowRemoveUpdater(UpdaterHandle handle)
+{
+  logTrace("NXShadowRemoveUpdater");
+
+  return updateManager ? updateManager -> removeUpdater(handle) : 0;
+}
+
+UpdaterHandle NXShadowAddUpdater(char *displayName)
+{
+  logTrace("NXShadowAddUpdater");
+
+  return updateManager ? updateManager -> addUpdater(displayName, NULL) : NULL;
+}
+
+int NXShadowAddUpdaterDisplay(void *dpy, int *w, int *h, unsigned char *d)
+{
+  Display *display = reinterpret_cast<Display*>(dpy);
+
+  logTrace("NXShadowAddUpdaterDisplay");
+
+  if ((updateManager ? updateManager -> addUpdater(NULL, display) : NULL) == NULL)
+  {
+    logTest("NXShadowAddUpdaterDisplay", "Error");
+
+    return 0;
+  }
+
+  *w = updateManager -> getWidth();
+  *h = updateManager -> getHeight();
+  *d = poller -> depth();
+
+  return 1;
+}
+
+int NXShadowCreate(void *dpy, char *keymap, char* shadowDisplayName, void **shadowDpy)
+{
+  logTrace("NXShadowCreate");
+
+  Display *display = reinterpret_cast<Display*>(dpy);
+  Display **shadowDisplay = reinterpret_cast<Display**>(shadowDpy);
+
+/*  if (NXInitSignal() != 1)
+  {
+    logError("NXShadowCreate", EGET());
+
+    return -1;
+  }*/
+
+  if (NXCreateInput(keymap, shadowDisplayName) != 1)
+  {
+    logError("NXShadowCreate", EGET());
+
+    return -1;
+  }
+
+  if (NXCreatePoller(display, shadowDisplay) != 1)
+  {
+    logTest("NXShadowCreate", "NXCreatePoller failed.");
+
+    return -1;
+  }
+
+  if (NXCreateUpdateManager() != 1)
+  {
+    logError("NXShadowCreate", EGET());
+
+    return -1;
+  }
+
+  return 1;
+}
+
+#if !defined(__CYGWIN32__) && !defined(WIN32)
+
+void NXShadowSetDisplayUid(int uid)
+{
+  NXShadowOptions.optionShadowDisplayUid = uid;
+}
+
+void NXShadowDisableShm(void)
+{
+  logUser("NXShadowDisableShm: Disabling SHM.\n");
+
+  NXShadowOptions.optionShmExtension = 0;
+}
+
+void NXShadowDisableDamage(void)
+{
+  NXShadowOptions.optionDamageExtension = 0;
+}
+
+#endif
+
+void NXShadowDestroy()
+{
+  if (poller)
+  {
+    delete poller;
+
+    poller = NULL;
+  }
+
+  if (updateManager)
+  {
+    delete updateManager;
+
+    updateManager = NULL;
+  }
+
+  if (input)
+  {
+    delete input;
+
+    input = NULL;
+  }
+}
+
+void NXShadowHandleInput()
+{
+  logTrace("NXShadowHandleInput");
+
+  if (NXShadowNotInitialized())
+  {
+    logError("NXShadowHandleInput - NXShadow not properly initialized.", ESET(EBADFD));
+
+    return;
+  }
+
+  NXHandleException();
+
+  updateManager -> handleInput();
+
+  poller -> handleInput();
+}
+
+int NXShadowHasChanged(int (*callback)(void *), void *arg, int *suspended)
+{
+  int result;
+
+  logTrace("NXShadowHasChanged");
+
+  if (NXShadowNotInitialized())
+  {
+    logError("NXShadowHasChanged - NXShadow not properly initialized.", ESET(EBADFD));
+
+    return -1;
+  }
+
+  //
+  // FIXME
+  //updateManager -> destroyUpdateManagerRegion();
+  //
+
+  updateManager -> newRegion();
+
+#if !defined(__CYGWIN32__) && !defined(WIN32)
+  poller -> getEvents();
+#endif
+
+  result = poller -> isChanged(callback, arg, suspended);
+
+  if (result == 1)
+  {
+    updateManager -> addRegion(poller -> lastUpdatedRegion());
+
+    return 1;
+  }
+  else if (result == -1)
+  {
+    logTest("NXShadowHasChanged", "Scanline error.");
+    return -1;
+  }
+
+  return 0;
+}
+
+void NXShadowExportChanges(long *numRects, char **pBox)
+{
+  Region pReg;
+
+  logTrace("NXShadowExportChanges");
+
+  if (NXShadowNotInitialized())
+  {
+    logError("NXShadowExportChanges - NXShadow not properly initialized.", ESET(EBADFD));
+  }
+
+  updateManager -> update();
+  pReg = updateManager -> getUpdateManagerRegion();
+  *numRects = pReg -> numRects;
+  *pBox = (char *)pReg -> rects;
+
+  logTest("NXShadowExportChanges", "numRects [%ld] pBox[%p], pReg->numRects[%ld], rects[%p], size[%lu]",
+              *numRects, *pBox, pReg -> numRects, &(pReg -> rects -> x2),
+                  (unsigned long) sizeof(pReg -> rects -> x2));
+}
+
+void NXShadowEvent(Display *display, XEvent event)
+{
+  poller -> handleEvent(display, &event);
+}
+
+void NXShadowWebKeyEvent(KeySym keysym, Bool isKeyPress)
+{
+  poller -> handleWebKeyEvent(keysym, isKeyPress);
+}
+
+#ifdef __CYGWIN32__
+
+int NXShadowCaptureCursor(unsigned int wnd, void *vis)
+{
+  Window window = (Window)wnd;
+  Visual *visual = reinterpret_cast<Visual*>(vis);
+
+  logTrace("NXShadowCaptureCursor");
+
+  logTest("NXShadowCaptureCursor","Init");
+
+  return poller -> updateCursor(window, visual);
+}
+
+#endif
+
+void NXShadowUpdateBuffer(void **buffer)
+{
+  char **fBuffer = reinterpret_cast<char **>(buffer);
+
+  if (*fBuffer != NULL)
+  {
+    poller -> destroyFrameBuffer();
+
+    poller -> init();
+  }
+
+  *fBuffer = poller -> getFrameBuffer();
+
+  logTest("NXShadowUpdateBuffer","New frame buffer [0x%p]", (void *)*fBuffer);
+}
+
+void NXShadowInitKeymap(void *keysyms)
+{
+  NXShadowKeymap = (KeySymsPtr) keysyms;
+
+  logTest("NXShadowInitKeymap","KeySyms pointer [0x%p] mapWidth [%d]",
+              (void *)NXShadowKeymap, NXShadowKeymap -> mapWidth);
+}

nxcompshad/Shadow.h

@@ -81,12 +81,18 @@ extern void          NXShadowColorCorrect(int, int, unsigned int, unsigned int,
 extern void          NXShadowUpdateBuffer(void **);
 
 extern void          NXShadowEvent(Display *, XEvent);
+extern void          NXShadowWebKeyEvent(KeySym keysym, Bool isKeyPress);
 
 extern void          NXShadowSetDisplayUid(int uid);
 
 extern void          NXShadowDisableShm(void);
 extern void          NXShadowDisableDamage(void);
 
+extern void          NXShadowGetScreenSize(int *width, int *height);
+extern void          NXShadowSetScreenSize(int *width, int *height);
+
+extern void          NXShadowInitKeymap(void *keysyms);
+
 #ifdef __cplusplus
 }
 #endif

nxcompshad/Win.cpp

@@ -479,6 +479,13 @@ void Poller::handleKeyboardEvent(Display *display, XEvent *event)
   delete[] keyname;
 }
 
+void Poller::handleWebKeyboardEvent(KeySym keysym, Bool isKeyPress)
+{
+/*
+FIXME
+*/
+}
+
 void Poller::handleMouseEvent(Display *display, XEvent *event)
 {
   DWORD flg = 0;

nxcompshad/Win.h

@@ -72,6 +72,7 @@ class Poller : public CorePoller
   
   int Poller::updateShadowFrameBuffer(void);
   void handleKeyboardEvent(Display *, XEvent *);
+  void handleWebKeyboardEvent(KeySym keysym, Bool isKeyPress);
   void addToKeymap(char *keyname, unsigned char scancode, unsigned short modifiers, char *mapname);
   int xkeymapRead(char *mapname);
   FILE *xkeymapOpen(char *filename);

nxcompshad/X11.h

@@ -41,6 +41,10 @@ class Poller : public CorePoller
 
   void getEvents(void);
 
+  void getScreenSize(int *width, int *height);
+
+  void setScreenSize(int *width, int *height);
+
   private:
 
   Display *display_;
@@ -77,8 +81,34 @@ class Poller : public CorePoller
 
   char *getRect(XRectangle);
 
+  void keymapShadowInit(Display *display);
+
+  void keymapMasterInit();
+
+  KeySym keymapKeycodeToKeysym(KeyCode keycode, KeySym *keysyms,
+                                   int minKey, int per, int col);
+
+  KeyCode keymapKeysymToKeycode(KeySym keysym, KeySym *keysyms,
+                                    int minKey, int maxKey, int per, int *col);
+
+  KeyCode translateKeysymToKeycode(KeySym keysym, int *col);
+
+  Bool checkModifierKeys(KeySym keysym, Bool isKeyPress);
+
+  void sendFakeModifierEvents(int pos, Bool skip);
+
+  void cancelFakeModifierEvents();
+
+  Bool keyIsDown(KeyCode keycode);
+
+  void addKeyPressed(KeyCode received, KeyCode sent);
+
+  KeyCode getKeyPressed(KeyCode received);
+
   void handleKeyboardEvent(Display *display, XEvent *);
 
+  void handleWebKeyboardEvent(KeySym keysym, Bool isKeyPress);
+
   void handleMouseEvent(Display *, XEvent *);
 
   void xtestInit(void);