a synergy client on that OS and pointed it at a system that wasn't
listening for connections then instead of the connection attempt
failing with 'connection refused' the system would claim the
connection succeeded. A subsequent read would reveal the problem
and synergy would "disconnect" and retry, causing the CPU to spin.
The system does correctly set the socket error state so this
workaround checks for socket errors when connecting whether or not
select reports an error state.
Also, sometimes the system doesn't claim success but doesn't report
an error. Synergy eventually times out these attempts.
detect synergy hotkeys but a design flaw in X11 makes it problematic
with many applications. We'll have to fall back to the more
traditional XGrabKey when the time comes.
return 0 when O_NDELAY is set and there is nothing to read. We
want the O_NONBLOCK behavior where read returns -1 and sets
errno to EAGAIN when there is nothing to read.
that to the client. If it did then the user could see the effect of
ctrl+alt+del on both the server and client which we never want. The
user can use ctrl+alt+pause to emulate ctrl+alt+del on the client.
the X11 display connection. The only problematic method was
CXWindowsEventQueueBuffer::addEvent given that the other event queue
methods are only called from the main thread.
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".
didn't support them and the emulated versions were just as good
except for a performance problem with excessive locking and
unlocking of a mutex. So this also changes IArchString to
provide string rather than character conversion so we can lock
the mutex once per string rather than once per character.
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.
in use. The client was being correctly rejected but the already
connected client was being forcefully disconnected too because the
client to disconnect was found by looking up the client by name.
We now instead look up the client by IClient*.
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.
broken when support for binary data was added. The terminating
NUL was included in the string as a character (that's in addition
to the terminating NUL added by std::string).
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.
but making direct calls for other messages from the server. This
could cause messages to be handled out of order. Now making a
direct call for handshake complete.
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.
poll() but there was a race condition where the thread trying
to unblock poll() could send the signal before the polling
thread had entered poll(). Now using a pipe and polling on
that and the client's sockets, and just writing a byte into
the pipe to unblock poll. This persists until the next call
to poll() so we might force poll() to return once unnecessarily
but that's not a problem. This change makes the BSD code
similar to the winsock code, which uses a winsock event instead
of a pipe.
buffer that holds the events and generates system events. This
allows us to switch in/out a platform specific event handler as
necessary without losing our timers and handlers.
event loop model. Streams, stream filters, and sockets are
converted. Client proxies are almost converted. CServer is
in progress. Removed all HTTP code. Haven't converted the
necessary win32 arch stuff.
crs