backup/barrier
1
0
Fork 0
mirror of https://github.com/debauchee/barrier.git synced 2026-02-11 06:05:08 +08:00
Code Issues Projects Releases Wiki Activity

factored common X windows screen stuff into a common base class.

Browse Source
This commit is contained in:
crs
2001-11-11 21:15:30 +00:00
parent 05928f28f8
commit cf4e1fd9ca
7 changed files with 502 additions and 401 deletions
Download Patch File Download Diff File Expand all files Collapse all files

244
synergy/CXWindowsPrimaryScreen.cpp
View File

@@ -1,8 +1,6 @@
#include "CXWindowsPrimaryScreen.h"
#include "CServer.h"
#include "CThread.h"
#include "CLock.h"
#include "TMethodJob.h"
#include "CLog.h"
#include <assert.h>
#include <X11/X.h>
@@ -13,17 +11,15 @@
CXWindowsPrimaryScreen::CXWindowsPrimaryScreen() :
m_server(NULL),
m_display(NULL),
m_w(0), m_h(0),
m_window(None),
m_active(false)
m_active(false),
m_window(None)
{
// do nothing
}
CXWindowsPrimaryScreen::~CXWindowsPrimaryScreen()
{
assert(m_display == NULL);
assert(m_window == None);
}
void CXWindowsPrimaryScreen::open(CServer* server)
@@ -35,90 +31,37 @@ void CXWindowsPrimaryScreen::open(CServer* server)
m_server = server;
// open the display
log((CLOG_DEBUG "XOpenDisplay(%s)", "NULL"));
m_display = XOpenDisplay(NULL); // FIXME -- allow non-default
if (m_display == NULL)
throw int(5); // FIXME -- make exception for this
// get default screen
m_screen = DefaultScreen(m_display);
Screen* screen = ScreenOfDisplay(m_display, m_screen);
// get screen size
m_w = WidthOfScreen(screen);
m_h = HeightOfScreen(screen);
log((CLOG_INFO "primary display size: %dx%d", m_w, m_h));
// get the root window
m_root = RootWindow(m_display, m_screen);
// create the grab window. this window is used to capture user
// input when the user is focussed on another client. don't let
// the window manager mess with it.
XSetWindowAttributes attr;
attr.event_mask = PointerMotionMask |// PointerMotionHintMask |
ButtonPressMask | ButtonReleaseMask |
KeyPressMask | KeyReleaseMask |
KeymapStateMask;
attr.do_not_propagate_mask = 0;
attr.override_redirect = True;
attr.cursor = createBlankCursor();
m_window = XCreateWindow(m_display, m_root, 0, 0, m_w, m_h, 0, 0,
InputOnly, CopyFromParent,
CWDontPropagate | CWEventMask |
CWOverrideRedirect | CWCursor,
&attr);
// start watching for events on other windows
selectEvents(m_root);
// start processing events
m_eventThread = new CThread(new TMethodJob<CXWindowsPrimaryScreen>(
this, &CXWindowsPrimaryScreen::eventThread));
openDisplay();
}
void CXWindowsPrimaryScreen::close()
{
assert(m_server != NULL);
assert(m_window != None);
assert(m_eventThread != NULL);
// stop event thread
log((CLOG_DEBUG "stopping event thread"));
m_eventThread->cancel();
m_eventThread->wait();
delete m_eventThread;
m_eventThread = NULL;
log((CLOG_DEBUG "stopped event thread"));
// destroy window
XDestroyWindow(m_display, m_window);
m_window = None;
// close the display
XCloseDisplay(m_display);
m_display = NULL;
log((CLOG_DEBUG "closed display"));
closeDisplay();
// done with server
m_server = NULL;
}
void CXWindowsPrimaryScreen::enter(SInt32 x, SInt32 y)
{
log((CLOG_INFO "entering primary at %d,%d", x, y));
assert(m_display != NULL);
assert(m_window != None);
assert(m_active == true);
assert(m_active == true);
assert(m_window != None);
CLock lock(&m_mutex);
CDisplayLock display(this);
// warp to requested location
XWarpPointer(m_display, None, m_window, 0, 0, 0, 0, x, y);
XWarpPointer(display, None, m_window, 0, 0, 0, 0, x, y);
// unmap the grab window. this also ungrabs the mouse and keyboard.
XUnmapWindow(m_display, m_window);
XUnmapWindow(display, m_window);
// remove all input events for grab window
XEvent event;
while (XCheckWindowEvent(m_display, m_window,
while (XCheckWindowEvent(display, m_window,
PointerMotionMask |
ButtonPressMask | ButtonReleaseMask |
KeyPressMask | KeyReleaseMask |
@@ -134,14 +77,13 @@ void CXWindowsPrimaryScreen::enter(SInt32 x, SInt32 y)
void CXWindowsPrimaryScreen::leave()
{
log((CLOG_INFO "leaving primary"));
assert(m_display != NULL);
assert(m_window != None);
assert(m_active == false);
assert(m_active == false);
assert(m_window != None);
CLock lock(&m_mutex);
CDisplayLock display(this);
// raise and show the input window
XMapRaised(m_display, m_window);
XMapRaised(display, m_window);
// grab the mouse and keyboard. keep trying until we get them.
// if we can't grab one after grabbing the other then ungrab
@@ -150,7 +92,7 @@ void CXWindowsPrimaryScreen::leave()
do {
// mouse first
do {
result = XGrabPointer(m_display, m_window, True, 0,
result = XGrabPointer(display, m_window, True, 0,
GrabModeAsync, GrabModeAsync,
m_window, None, CurrentTime);
assert(result != GrabNotViewable);
@@ -162,11 +104,12 @@ void CXWindowsPrimaryScreen::leave()
log((CLOG_DEBUG "grabbed pointer"));
// now the keyboard
result = XGrabKeyboard(m_display, m_window, True,
result = XGrabKeyboard(display, m_window, True,
GrabModeAsync, GrabModeAsync, CurrentTime);
assert(result != GrabNotViewable);
if (result != GrabSuccess) {
XUngrabPointer(m_display, CurrentTime);
// back off to avoid grab deadlock
XUngrabPointer(display, CurrentTime);
log((CLOG_DEBUG "ungrabbed pointer, waiting to grab keyboard"));
CThread::sleep(0.25);
}
@@ -174,7 +117,9 @@ void CXWindowsPrimaryScreen::leave()
log((CLOG_DEBUG "grabbed keyboard"));
// move the mouse to the center of grab window
warpCursorNoLock(m_w >> 1, m_h >> 1);
SInt32 w, h;
getScreenSize(&w, &h);
warpCursorNoLock(display, w >> 1, h >> 1);
// local client now active
m_active = true;
@@ -182,21 +127,24 @@ void CXWindowsPrimaryScreen::leave()
void CXWindowsPrimaryScreen::warpCursor(SInt32 x, SInt32 y)
{
CLock lock(&m_mutex);
warpCursorNoLock(x, y);
CDisplayLock display(this);
warpCursorNoLock(display, x, y);
}
void CXWindowsPrimaryScreen::warpCursorNoLock(
SInt32 x, SInt32 y)
Display* display, SInt32 x, SInt32 y)
{
assert(display != NULL);
assert(m_window != None);
// warp the mouse
XWarpPointer(m_display, None, m_root, 0, 0, 0, 0, x, y);
XSync(m_display, False);
XWarpPointer(display, None, getRoot(), 0, 0, 0, 0, x, y);
XSync(display, False);
log((CLOG_DEBUG "warped to %d,%d", x, y));
// discard mouse events since we just added one we don't want
XEvent xevent;
while (XCheckWindowEvent(m_display, m_window,
while (XCheckWindowEvent(display, m_window,
PointerMotionMask, &xevent)) {
// do nothing
}
@@ -205,21 +153,57 @@ void CXWindowsPrimaryScreen::warpCursorNoLock(
void CXWindowsPrimaryScreen::getSize(
SInt32* width, SInt32* height) const
{
assert(m_display != NULL);
assert(width != NULL && height != NULL);
*width = m_w;
*height = m_h;
getScreenSize(width, height);
}
SInt32 CXWindowsPrimaryScreen::getJumpZoneSize() const
{
assert(m_display != NULL);
return 1;
}
void CXWindowsPrimaryScreen::selectEvents(Window w) const
void CXWindowsPrimaryScreen::onOpenDisplay()
{
assert(m_window == None);
CDisplayLock display(this);
// get size of screen
SInt32 w, h;
getScreenSize(&w, &h);
// create the grab window. this window is used to capture user
// input when the user is focussed on another client. don't let
// the window manager mess with it.
XSetWindowAttributes attr;
attr.event_mask = PointerMotionMask |// PointerMotionHintMask |
ButtonPressMask | ButtonReleaseMask |
KeyPressMask | KeyReleaseMask |
KeymapStateMask;
attr.do_not_propagate_mask = 0;
attr.override_redirect = True;
attr.cursor = createBlankCursor();
m_window = XCreateWindow(display, getRoot(), 0, 0, w, h, 0, 0,
InputOnly, CopyFromParent,
CWDontPropagate | CWEventMask |
CWOverrideRedirect | CWCursor,
&attr);
// start watching for events on other windows
selectEvents(display, getRoot());
}
void CXWindowsPrimaryScreen::onCloseDisplay()
{
assert(m_window != None);
// destroy window
CDisplayLock display(this);
XDestroyWindow(display, m_window);
m_window = None;
}
void CXWindowsPrimaryScreen::selectEvents(
Display* display, Window w) const
{
// we want to track the mouse everywhere on the display. to achieve
// that we select PointerMotionMask on every window. we also select
@@ -231,73 +215,31 @@ void CXWindowsPrimaryScreen::selectEvents(Window w) const
return;
// select events of interest
XSelectInput(m_display, w, PointerMotionMask | SubstructureNotifyMask);
XSelectInput(display, w, PointerMotionMask | SubstructureNotifyMask);
// recurse on child windows
Window rw, pw, *cw;
unsigned int nc;
if (XQueryTree(m_display, w, &rw, &pw, &cw, &nc)) {
if (XQueryTree(display, w, &rw, &pw, &cw, &nc)) {
for (unsigned int i = 0; i < nc; ++i)
selectEvents(cw[i]);
selectEvents(display, cw[i]);
XFree(cw);
}
}
Cursor CXWindowsPrimaryScreen::createBlankCursor()
{
// this seems just a bit more complicated than really necessary
// get the closet cursor size to 1x1
unsigned int w, h;
XQueryBestCursor(m_display, m_root, 1, 1, &w, &h);
// make bitmap data for cursor of closet size. since the cursor
// is blank we can use the same bitmap for shape and mask: all
// zeros.
const int size = ((w + 7) >> 3) * h;
char* data = new char[size];
memset(data, 0, size);
// make bitmap
Pixmap bitmap = XCreateBitmapFromData(m_display, m_root, data, w, h);
// need an arbitrary color for the cursor
XColor color;
color.pixel = 0;
color.red = color.green = color.blue = 0;
color.flags = DoRed | DoGreen | DoBlue;
// make cursor from bitmap
Cursor cursor = XCreatePixmapCursor(m_display, bitmap, bitmap,
&color, &color, 0, 0);
// don't need bitmap or the data anymore
delete[] data;
XFreePixmap(m_display, bitmap);
return cursor;
}
void CXWindowsPrimaryScreen::eventThread(void*)
{
for (;;) {
// wait for and then get the next event
m_mutex.lock();
while (XPending(m_display) == 0) {
m_mutex.unlock();
CThread::sleep(0.05);
m_mutex.lock();
}
// wait for and get the next event
XEvent xevent;
XNextEvent(m_display, &xevent);
m_mutex.unlock();
getEvent(&xevent);
// handle event
switch (xevent.type) {
case CreateNotify: {
// select events on new window
CLock lock(&m_mutex);
selectEvents(xevent.xcreatewindow.window);
CDisplayLock display(this);
selectEvents(display, xevent.xcreatewindow.window);
break;
}
@@ -355,19 +297,22 @@ void CXWindowsPrimaryScreen::eventThread(void*)
// get mouse deltas
{
CLock lock(&m_mutex);
CDisplayLock display(this);
Window root, window;
int xRoot, yRoot, xWindow, yWindow;
unsigned int mask;
if (!XQueryPointer(m_display, m_window, &root, &window,
if (!XQueryPointer(display, m_window, &root, &window,
&xRoot, &yRoot, &xWindow, &yWindow, &mask))
break;
x = xRoot - (m_w >> 1);
y = yRoot - (m_h >> 1);
// compute position of center of window
SInt32 w, h;
getScreenSize(&w, &h);
x = xRoot - (w >> 1);
y = yRoot - (h >> 1);
// warp mouse back to center
warpCursorNoLock(m_w >> 1, m_h >> 1);
warpCursorNoLock(display, w >> 1, h >> 1);
}
m_server->onMouseMoveSecondary(x, y);
@@ -422,7 +367,8 @@ KeyID CXWindowsPrimaryScreen::mapKey(
index = 1;
else
index = 0;
return static_cast<KeyID>(XKeycodeToKeysym(m_display, keycode, index));
CDisplayLock display(this);
return static_cast<KeyID>(XKeycodeToKeysym(display, keycode, index));
}
ButtonID CXWindowsPrimaryScreen::mapButton(