barrier/CXScreen.cpp

627 lines
13 KiB
C++

#include "CXScreen.h"
#include "CEvent.h"
#include "CEventQueue.h"
#include <assert.h>
#include <unistd.h>
#include <X11/X.h>
#include <X11/extensions/XTest.h>
//
// CXScreen
//
class XClientOpen { }; // FIXME
CXScreen::CXScreen(const CString& name) :
m_name(name),
m_display(NULL),
m_primary(false),
m_w(0), m_h(0),
m_window(None),
m_active(false)
{
// do nothing
}
CXScreen::~CXScreen()
{
assert(m_display == NULL);
}
void CXScreen::open(bool isPrimary)
{
assert(m_display == NULL);
m_primary = isPrimary;
bool opened = false;
try {
// open the display
m_display = ::XOpenDisplay(NULL); // FIXME -- allow non-default
if (m_display == NULL)
throw XClientOpen();
// hook up event handling
onOpen(m_primary);
opened = true;
// 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);
// type specific operations
if (m_primary)
openPrimary();
else
openSecondary();
}
catch (...) {
if (opened)
onClose();
if (m_display != NULL) {
::XCloseDisplay(m_display);
m_display = NULL;
}
throw;
}
}
void CXScreen::close()
{
assert(m_display != NULL);
// type specific operations
if (m_primary)
closePrimary();
else
closeSecondary();
// unhook event handling
onClose();
// close the display
::XCloseDisplay(m_display);
m_display = NULL;
}
void CXScreen::enterScreen(SInt32 x, SInt32 y)
{
assert(m_display != NULL);
if (m_primary)
enterScreenPrimary(x, y);
else
enterScreenSecondary(x, y);
}
void CXScreen::leaveScreen()
{
assert(m_display != NULL);
if (m_primary)
leaveScreenPrimary();
else
leaveScreenSecondary();
}
void CXScreen::warpCursor(SInt32 x, SInt32 y)
{
assert(m_display != NULL);
// warp the mouse
Window root = RootWindow(m_display, m_screen);
::XWarpPointer(m_display, None, root, 0, 0, 0, 0, x, y);
::XSync(m_display, False);
// discard mouse events since we just added one we don't want
XEvent xevent;
while (::XCheckWindowEvent(m_display, m_window,
PointerMotionMask, &xevent))
; // do nothing
}
void CXScreen::setClipboard(
const IClipboard* clipboard)
{
assert(m_display != NULL);
if (m_primary)
setClipboardPrimary(clipboard);
else
setClipboardSecondary(clipboard);
}
void CXScreen::onScreenSaver(bool show)
{
assert(m_display != NULL);
if (m_primary)
onScreenSaverPrimary(show);
else
onScreenSaverSecondary(show);
}
void CXScreen::onKeyDown(KeyID key, KeyModifierMask)
{
assert(m_display != NULL);
assert(m_primary == false);
// FIXME -- use mask
::XTestFakeKeyEvent(m_display, mapKeyToX(key), True, CurrentTime);
::XSync(m_display, False);
}
void CXScreen::onKeyRepeat(KeyID, KeyModifierMask, SInt32)
{
assert(m_display != NULL);
assert(m_primary == false);
// FIXME
}
void CXScreen::onKeyUp(KeyID key, KeyModifierMask)
{
assert(m_display != NULL);
assert(m_primary == false);
// FIXME -- use mask
::XTestFakeKeyEvent(m_display, mapKeyToX(key), False, CurrentTime);
::XSync(m_display, False);
}
void CXScreen::onMouseDown(ButtonID button)
{
assert(m_display != NULL);
assert(m_primary == false);
::XTestFakeButtonEvent(m_display, mapButtonToX(button), True, CurrentTime);
::XSync(m_display, False);
}
void CXScreen::onMouseUp(ButtonID button)
{
assert(m_display != NULL);
assert(m_primary == false);
::XTestFakeButtonEvent(m_display, mapButtonToX(button), False, CurrentTime);
::XSync(m_display, False);
}
void CXScreen::onMouseMove(SInt32 x, SInt32 y)
{
assert(m_display != NULL);
assert(m_primary == false);
::XTestFakeMotionEvent(m_display, m_screen, x, y, CurrentTime);
::XSync(m_display, False);
}
void CXScreen::onMouseWheel(SInt32)
{
assert(m_display != NULL);
assert(m_primary == false);
// FIXME
}
void CXScreen::onClipboardChanged()
{
assert(m_display != NULL);
assert(m_primary == false);
// FIXME
}
CString CXScreen::getName() const
{
return m_name;
}
void CXScreen::getSize(
SInt32* width, SInt32* height) const
{
assert(m_display != NULL);
assert(width != NULL && height != NULL);
*width = m_w;
*height = m_h;
}
void CXScreen::getClipboard(
IClipboard* /*clipboard*/) const
{
assert(m_display != NULL);
// FIXME
}
void CXScreen::openPrimary()
{
// get the root window
Window 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 = None;
m_window = ::XCreateWindow(m_display, root, 0, 0, m_w, m_h, 0, 0,
InputOnly, CopyFromParent,
CWDontPropagate | CWEventMask |
CWOverrideRedirect | CWCursor,
&attr);
// start watching for events on other windows
selectEvents(root);
}
void CXScreen::closePrimary()
{
assert(m_window != None);
// destroy window
::XDestroyWindow(m_display, m_window);
m_window = None;
}
void CXScreen::enterScreenPrimary(SInt32 x, SInt32 y)
{
assert(m_window != None);
assert(m_active == true);
// warp to requested location
::XWarpPointer(m_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);
// remove all input events for grab window
XEvent event;
while (::XCheckWindowEvent(m_display, m_window,
PointerMotionMask |
ButtonPressMask | ButtonReleaseMask |
KeyPressMask | KeyReleaseMask |
KeymapStateMask,
&event))
; // do nothing
// not active anymore
m_active = false;
}
void CXScreen::leaveScreenPrimary()
{
assert(m_window != None);
assert(m_active == false);
// raise and show the input window
::XMapRaised(m_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
// and wait before retrying.
int result;
do {
// mouse first
do {
result = ::XGrabPointer(m_display, m_window, True, 0,
GrabModeAsync, GrabModeAsync,
m_window, None, CurrentTime);
assert(result != GrabNotViewable);
if (result != GrabSuccess)
::sleep(1);
} while (result != GrabSuccess);
// now the keyboard
result = ::XGrabKeyboard(m_display, m_window, True,
GrabModeAsync, GrabModeAsync, CurrentTime);
assert(result != GrabNotViewable);
if (result != GrabSuccess) {
::XUngrabPointer(m_display, CurrentTime);
::sleep(1);
}
} while (result != GrabSuccess);
// move the mouse to the center of grab window
warpCursor(m_w >> 1, m_h >> 1);
// local client now active
m_active = true;
}
void CXScreen::setClipboardPrimary(
const IClipboard* /*clipboard*/)
{
// FIXME
}
void CXScreen::onScreenSaverPrimary(bool /*show*/)
{
// FIXME
}
void CXScreen::openSecondary()
{
// verify the availability of the XTest extension
int majorOpcode, firstEvent, firstError;
if (!::XQueryExtension(m_display, XTestExtensionName,
&majorOpcode, &firstEvent, &firstError))
throw XClientOpen();
// become impervious to server grabs
XTestGrabControl(m_display, True);
}
void CXScreen::closeSecondary()
{
// no longer impervious to server grabs
XTestGrabControl(m_display, False);
}
void CXScreen::enterScreenSecondary(
SInt32 x, SInt32 y)
{
// FIXME
}
void CXScreen::leaveScreenSecondary()
{
// FIXME
}
void CXScreen::setClipboardSecondary(
const IClipboard* /*clipboard*/)
{
// FIXME
}
void CXScreen::onScreenSaverSecondary(bool /*show*/)
{
// FIXME
}
Display* CXScreen::getDisplay() const
{
return m_display;
}
void CXScreen::onEvents()
{
if (m_primary)
onPrimaryEvents();
else
onSecondaryEvents();
}
void CXScreen::selectEvents(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
// SubstructureNotifyMask in order to get CreateNotify events so we
// select events on new windows too.
// we don't want to adjust our grab window
if (w == m_window)
return;
// select events of interest
::XSelectInput(m_display, w, PointerMotionMask | SubstructureNotifyMask);
// recurse on child windows
Window rw, pw, *cw;
unsigned int nc;
if (::XQueryTree(m_display, w, &rw, &pw, &cw, &nc)) {
for (unsigned int i = 0; i < nc; ++i)
selectEvents(cw[i]);
::XFree(cw);
}
}
KeyModifierMask CXScreen::mapModifierFromX(unsigned int state) const
{
// FIXME -- should be configurable
KeyModifierMask mask = 0;
if (state & 1)
mask |= KeyModifierShift;
if (state & 2)
mask |= KeyModifierCapsLock;
if (state & 4)
mask |= KeyModifierControl;
if (state & 8)
mask |= KeyModifierAlt;
if (state & 16)
mask |= KeyModifierNumLock;
if (state & 32)
mask |= KeyModifierMeta;
if (state & 128)
mask |= KeyModifierScrollLock;
return mask;
}
unsigned int CXScreen::mapModifierToX(KeyModifierMask mask) const
{
// FIXME -- should be configurable
unsigned int state = 0;
if (mask & KeyModifierShift)
state |= 1;
if (mask & KeyModifierControl)
state |= 4;
if (mask & KeyModifierAlt)
state |= 8;
if (mask & KeyModifierMeta)
state |= 32;
if (mask & KeyModifierCapsLock)
state |= 2;
if (mask & KeyModifierNumLock)
state |= 16;
if (mask & KeyModifierScrollLock)
state |= 128;
return state;
}
KeyID CXScreen::mapKeyFromX(
KeyCode keycode, KeyModifierMask mask) const
{
int index;
if (mask & KeyModifierShift)
index = 1;
else
index = 0;
return static_cast<KeyID>(::XKeycodeToKeysym(m_display, keycode, index));
}
KeyCode CXScreen::mapKeyToX(KeyID keyID) const
{
return ::XKeysymToKeycode(m_display, static_cast<KeySym>(keyID));
}
ButtonID CXScreen::mapButtonFromX(unsigned int button) const
{
// FIXME -- should use button mapping?
if (button >= 1 && button <= 3)
return static_cast<ButtonID>(button);
else
return kButtonNone;
}
unsigned int CXScreen::mapButtonToX(ButtonID buttonID) const
{
// FIXME -- should use button mapping?
return static_cast<unsigned int>(buttonID);
}
void CXScreen::onPrimaryEvents()
{
while (XPending(m_display) > 0) {
XEvent xevent;
XNextEvent(m_display, &xevent);
switch (xevent.type) {
case KeyPress: {
const KeyModifierMask mask = mapModifierFromX(xevent.xkey.state);
const KeyID key = mapKeyFromX(xevent.xkey.keycode, mask);
if (key != kKeyNone) {
CEvent event;
event.m_key.m_type = CEventBase::kKeyDown;
event.m_key.m_key = key;
event.m_key.m_mask = mask;
event.m_key.m_count = 0;
CEQ->push(&event);
}
break;
}
// FIXME -- simulate key repeat. X sends press/release for
// repeat. must detect auto repeat and use kKeyRepeat.
case KeyRelease: {
const KeyModifierMask mask = mapModifierFromX(xevent.xkey.state);
const KeyID key = mapKeyFromX(xevent.xkey.keycode, mask);
if (key != kKeyNone) {
CEvent event;
event.m_key.m_type = CEventBase::kKeyUp;
event.m_key.m_key = key;
event.m_key.m_mask = mask;
event.m_key.m_count = 0;
CEQ->push(&event);
}
break;
}
case ButtonPress: {
const ButtonID button = mapButtonFromX(xevent.xbutton.button);
if (button != kButtonNone) {
CEvent event;
event.m_mouse.m_type = CEventBase::kMouseDown;
event.m_mouse.m_button = button;
event.m_mouse.m_x = 0;
event.m_mouse.m_y = 0;
CEQ->push(&event);
}
break;
}
case ButtonRelease: {
const ButtonID button = mapButtonFromX(xevent.xbutton.button);
if (button != kButtonNone) {
CEvent event;
event.m_mouse.m_type = CEventBase::kMouseUp;
event.m_mouse.m_button = button;
event.m_mouse.m_x = 0;
event.m_mouse.m_y = 0;
CEQ->push(&event);
}
break;
}
case MotionNotify: {
CEvent event;
event.m_mouse.m_type = CEventBase::kMouseMove;
event.m_mouse.m_button = kButtonNone;
if (!m_active) {
event.m_mouse.m_x = xevent.xmotion.x_root;
event.m_mouse.m_y = xevent.xmotion.y_root;
}
else {
// FIXME -- slurp up all remaining motion events?
// probably not since key strokes may go to wrong place.
// get mouse deltas
Window root, window;
int xRoot, yRoot, xWindow, yWindow;
unsigned int mask;
if (!::XQueryPointer(m_display, m_window, &root, &window,
&xRoot, &yRoot, &xWindow, &yWindow, &mask))
break;
event.m_mouse.m_x = xRoot - (m_w >> 1);
event.m_mouse.m_y = yRoot - (m_h >> 1);
// warp mouse back to center
warpCursor(m_w >> 1, m_h >> 1);
}
CEQ->push(&event);
break;
}
case CreateNotify:
// select events on new window
if (m_primary)
selectEvents(xevent.xcreatewindow.window);
break;
/*
case SelectionClear:
target->XXX(xevent.xselectionclear.);
break;
case SelectionNotify:
target->XXX(xevent.xselection.);
break;
case SelectionRequest:
target->XXX(xevent.xselectionrequest.);
break;
*/
}
}
}
void CXScreen::onSecondaryEvents()
{
while (XPending(m_display) > 0) {
XEvent xevent;
XNextEvent(m_display, &xevent);
// FIXME
}
}