on a secondary screen when there's no physical mouse attached to
the system. Kinda flaky when a mouse is attached or detached but
seems to work well enough when the device is not attached to start
with and not attached while running synergy.
and on a secondary screen and locked to the screen (via scroll lock)
mouse motion is sent as motion deltas. When true and scroll lock
is toggled off the mouse is warped to the secondary screen's center
so the server knows where it is. This option is intended to support
games and other programs that repeatedly warp the mouse to the center
of the screen. This change adds general and X11 support but not
win32. The option name is "relativeMouseMoves".
multiple systems with automake, with X Windows and Carbon window
system APIs supported. It's also a starting port for supporting
win32 builds using mingw. OS X support is incomplete; the tree
will compile and link but the binaries will not function.
The low-level hook can report mouse positions outside the boundaries
of the screen and bogus retrograde motion. This messes up switch on
double tap. This change attempts to detect and suppress the bogus
events.
changed locking to screen so that keys no longer count (only
mouse buttons and scroll lock toggled on). This is to deal
with the unreliability of key event reporting which can leave
us locked to a screen with no key physically pressed. The
result of this is that clients get key repeats and releases
without the corresponding key press. CKeyState handles this
by discarding repeat/release events on keys it hasn't seen go
down. Also made a few other minor fixes to win32 keyboard
handling.
This new design is simpler. For keyboard support, clients need only
implement 4 virtual methods on a class derived from CKeyState and
one trivial method in the class derived from CPlatformScreen, which
is now the superclass of platform screens instead of IPlatformScreen.
Keyboard methods have been removed from IPlatformScreen, IPrimaryScreen
and ISecondaryScreen. Also, all keyboard state tracking is now in
exactly one place (the CKeyState subclass) rather than in CScreen,
the platform screen, and the key mapper. Still need to convert Win32.
on every key press and release so we don't have to updateKeys()
in isLockedToScreen(). However, if any key appears to be down
we still call updateKeys() to double check that it's really down.
If not we note the spurious lock and don't lock to the screen.
takes activation so the previously active window doesn't pop to
the top of the window stack when it regains activation. One
drawback of this is that the mouse cursor isn't shown when
a window (other than synergy's) is activated. However, synergy
does detect mouse motion as before and shows the cursor when it
sees any.
that allows you to power down the display. Previously, synergy
would not power on the display if DPMS was enabled and activated
and xscreensaver was not running. It also wouldn't disable DPMS
so the display would power down normally on a synergy client if
there was no input activity.
of that file in existance, not all of which have all the symbols we
require and none of which provide any convenient means of telling
what groups of symbols they define.
absolute mouse_event(). Improved keyboard handling: now using
keyboard layout of last foreground window when leaving server
so users can meaningfully choose the locale, moved dead key
handling into hook library so there should be no more race
conditions involving the keyboard dead key buffer, simplified
keyboard and cursor handling by using a full screen transparent
window when not using low level hooks, fixed error in restoring
buffered dead key when checking for dead keys. This hopefully
fixes all known keyboard bugs on win32.
an event queue and events, TCP sockets converted to use events,
unix multithreading and network stuff converted, and an X Windows
event queue subclass.
doesn't map to anything via AltGr. This is an improvement over
the previous code which would simply discard the key but it
still behaves slightly differently than pressing ctrl+alt+<key>
on the server: if that combination is a hotkey on the server
then the hotkey is performed, even if the combination is also
a valid AltGr combination; on the client, we'll get the AltGr
combination in preference to the hotkey.
using low-level keyboard hooks, fixed handling of the global
keyboard layout dead key buffer, fixed identification of dead
keys, fixed synthesis of AltGr (now using right-alt instead
of left-alt), now using VK_DECIMAL for Separator key, fixed
bug where an unmappable key was treated as virtual key 0xff,
and added support for shift-space (shift was being discarded).
Also fixed failure to hide cursor when leaving primary screen
and added support for handling PrintScreen key.
and then space should convert the dead key to a non-dead key but
previous the key was discarded. Fixed that but VkKeyScan() fails
in this case so added special case to fix that (assuming AltGr is
required). VkKeyScan() can return the wrong result for characters
that have more than one virtual key mapped to them. AltGr+9 (^)
on the French layout has this problem. Now detecting that problem
and using the current keyboard state to decide if AltGr is
required.
doesn't appear to have any negative consequences and may prevent
synergy from freezing when some X client (probably the window
manager) grabs the server.
to connect. This prevents a log from filling up while the client
can't connect for no useful reason. Also removed --camp option
and cleaned up handling of client connection. Users must now use
--restart instead of --camp.
sending a key that requires AltGr. That's because AltGr *is*
ctrl and alt but AltGr should be seen on clients as mode
switch without the ctrl and alt. I can't think of a better
way to do this other than to not send modifier keystrokes to
the clients at all.
with applying the incorrect shift and mode switch modifiers to
some keycodes, such as getting Pointer_EnableKeys when pressing
shift with NumLock enabled.
need a precompose area or status area. This includes IMs that
do simple dead key composition. This only changes the server.
The client still does not decompose a character it cannot
generate directly into the keysyms to compose the character.
family because nt automatically converts to and from the unicode
format. This may fix text encoding errors when synergy puts
non-ascii text on the clipboard and other clients prefer CF_TEXT
to CF_UNICODE (which they should not because synergy lists
CF_UNICODE first).
is accessible (was already fixed when inaccessible). This change
also ignores press and release of virtual key 0, which should never
happen but does according to one user.
warping on screen 0. That just doesn't work if screen 0 is not at
0,0. So now always use XWarpPointer() if there are multiple
xinerama screens and the appropriate option is enabled.
true, faking a mouse motion outside screen 0 is clamped onto screen 0.
When the workaround is enabled, we use XWarpPointer() instead of an
XTest fake motion. This isn't perfect but the only real fix requires
patching XTest.
Some users requested this. Also, the hider window is mapped before
warping the mouse so the active window shouldn't change if the focus
policy is point-to-focus. Showing the window first can also reduce
the likelihood of seeing the cursor briefly in its hidden position.
the server from auto-repeating fake events, which is undesired
since synergy will do the auto-repeating itself. This also
disables auto-repeat on any keys locally configured on X11 to not
auto-repeat. That's mainly to suppress auto-repeat on modifier
keys, which auto-repeat on win32 but not X11.
now captures non-client area mouse messages. Previously, these
were ignored (because i forgot about them) and they caused all
kinds of problems because they weren't forwarded. For example,
clicking on a window border would cause the window to start
resizing when the mouse came back to the server screen. Moving
inside a title bar meant that the mouse wouldn't move on the
client screen.
Second, because non-client messages are now handled, the full
screen transparent window is no longer necessary to capture
input so it's never displayed. (The window is still necessary
for clipboard ownership so it's still created.) No transparent
window means no screen flashing. It also means we don't have to
become the foreground and active window. This plays better with
apps that minimize or restore when they're no longer the
foreground application/active window.
Third, fixed the low level keyboard hook to forward toggle key
updates, which it was neglecting to do.
Finally, keyboard and mouse input is always forwarded from the hook
to the primary screen handler which then shadows the current key
and mouse button state. If we're using low level hooks then this
isn't really necessary and GetKeyState() always returns the right
info but without low level hooks it means we can just use the
shadow state. It also means we don't have to show our window in
order to get the system's key state table up to date, fixing the
screen flash when checking for the scroll lock state.
key handling to win32 on both client and server. It also changes
the protocol and adds code to ensure every key pressed also gets
released and that that doesn't get confused when the KeyID for
the press is different from the KeyID of the release (or repeat).
screen saver from activating. It was unnecessary since the built-in
screen saver is disabled as appropriate; this call was just to
ensure that the screen saver wouldn't start if an external program
reactivated the screen saver after synergy disabled it.
It's possible that this was causing screen flicker under gnome, though
i don't know why. It's also possible that periodically sending events
to xscreensaver is causing the flicker but removing that code is more
difficult because xscreensaver can't be disabled, only deactivated or
killed.
events to other hook functions, which broke some tools like objectbar.
Second, windows key processing was fixed. Previously pressing and
release the key would only send a press event, locking the user onto
the client window; also, the win32 server treated as a Meta modifier
instead of a Super modifier, which broke any use of it as any kind of
modifier key. Third, added hacks to support several key combinations
on windows 95/98/me that are treated specially by windows, including
Alt+Tab, Alt+Shift+Tab, Alt+Esc, Alt+Shift+Esc, Ctrl+Esc, and any
combination using the windows key like Win+E and Win+F but not
Ctrl+Alt+Del. Fourth, scroll lock only locking to the client (which
only happened when using a synergy server on windows) has been fixed;
unfortunately the solution causes a lot of screen redraws for some
reason. Finally, there's been a fix to clipboard handling that may
or may not fix a problem where the clipboard would stop transferring
between systems after a little while. I can't be sure if it fixes
the problem because I can't reproduce the problem.
entering the loop waiting for it to deactivate. The failure
to check was causing the screen saver code to kick in when
the screen saver timeout occurred, even if the screen saver
wasn't enabled (because Windows still sends the screen saver
activating message for no good reason when the screen saver
is disabled).
crs