/* _xwin_set_mouse_speed:
* The actual function that sets the speed of the mouse cursor.
* Each step slows down or speeds the mouse up by 0.5x.
*/
static void _xwin_set_mouse_speed(int xspeed, int yspeed)
{
int speed;
int hundredths;
XLOCK();
if (mouse_mult < 0)
XGetPointerControl(_xwin.display, &mouse_mult, &mouse_div,
&mouse_threshold);
speed = MAX(1, (xspeed + yspeed) / 2);
if (mouse_div == 0)
hundredths = mouse_mult * 100;
else
hundredths = (mouse_mult * 100 / mouse_div);
hundredths -= (speed - 2) * 50;
if (hundredths < 0)
hundredths = 0;
XChangePointerControl(_xwin.display, 1, 1, hundredths,
100, mouse_threshold);
XUNLOCK();
}
static void on_mouse_threshold_changed(GtkRange* range, gpointer user_data)
{
/* threshold = 110 - sensitivity. The lower the threshold, the higher the sensitivity */
threshold = (int)gtk_range_get_value(range);
XChangePointerControl(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), False, True,
0, 10, threshold);
}
/* Sets the mouse acceleration from a string of the form:
2/1/0
The first number is the numerator, followed by the acceleration
denumenator and threshold.
*/
static void SetMouseAccel(_THIS, const char *accel_param)
{
int i;
size_t len;
int accel_value[3];
char *mouse_param, *mouse_param_buf, *pin;
len = SDL_strlen(accel_param)+1;
mouse_param_buf = SDL_stack_alloc(char, len);
if ( ! mouse_param_buf ) {
return;
}
SDL_strlcpy(mouse_param_buf, accel_param, len);
mouse_param = mouse_param_buf;
for ( i=0; (i < 3) && mouse_param; ++i ) {
pin = SDL_strchr(mouse_param, '/');
if ( pin ) {
*pin = '\0';
}
accel_value[i] = atoi(mouse_param);
if ( pin ) {
mouse_param = pin+1;
} else {
mouse_param = NULL;
}
}
if ( mouse_param_buf ) {
XChangePointerControl(SDL_Display, True, True,
accel_value[0], accel_value[1], accel_value[2]);
SDL_free(mouse_param_buf);
}
}
void UXViewport::ReleaseInputs()
{
guard(UXViewport::ReleaseInputs);
// Restore DGA mode.
if (UseDGA)
{
UseDGA = false;
XF86DGADirectVideo(XDisplay, DefaultScreen(XDisplay), 0);
}
// Restore acceleration.
XChangePointerControl(XDisplay, True, True, MouseAccel_N, MouseAccel_D, MouseThreshold);
// Restore pointer and keyboard.
XUngrabPointer( XDisplay, CurrentTime );
XUngrabKeyboard( XDisplay, CurrentTime );
// Restore cursor.
XUndefineCursor( XDisplay, XWindow );
// Restore Keyboard AutoRepeat
if( RestoreAutoRepeat )
{
RestoreAutoRepeat = false;
XAutoRepeatOn( XDisplay );
}
unguard;
}
static void install_grabs(void)
{
XSync(dpy, False);
hildon_set_non_compositing();
XDefineCursor(dpy, win, CreateNullCursor(dpy, win));
XGrabPointer(dpy, win, False, MOUSE_MASK, GrabModeAsync, GrabModeAsync,
win, None, CurrentTime);
XGetPointerControl(dpy, &mouse_accel_numerator,
&mouse_accel_denominator, &mouse_threshold);
XChangePointerControl(dpy, True, True, 1, 1, 0);
XSync(dpy, False);
mwx = glConfig.vidWidth / 2;
mwy = glConfig.vidHeight / 2;
mx = my = 0;
XGrabKeyboard(dpy, win, False, GrabModeAsync, GrabModeAsync,
CurrentTime);
XSync(dpy, False);
}
static void setMouseAccel(WMScreen * scr, float accel, int threshold)
{
int n, d;
d = 10;
n = accel * d;
XChangePointerControl(WMScreenDisplay(scr), True, True, n, d, threshold);
}
/* _xwin_mouse_leave_notify:
* Reset the mouse speed to its original value when the cursor leave the
* Allegro window.
*/
void _xwin_mouse_leave_notify(void)
{
if (mouse_mult >= 0) {
XLOCK();
XChangePointerControl(_xwin.display, 1, 1, mouse_mult,
mouse_div, mouse_threshold);
XUNLOCK();
}
}
static void install_grabs(void)
{
// inviso cursor
XWarpPointer(dpy, None, win,
0, 0, 0, 0,
glConfig.vidWidth / 2, glConfig.vidHeight / 2);
XSync(dpy, False);
XDefineCursor(dpy, win, CreateNullCursor(dpy, win));
XGrabPointer(dpy, win, // bk010108 - do this earlier?
False,
MOUSE_MASK,
GrabModeAsync, GrabModeAsync,
win,
None,
CurrentTime);
XGetPointerControl(dpy, &mouse_accel_numerator, &mouse_accel_denominator,
&mouse_threshold);
XChangePointerControl(dpy, True, True, 1, 1, 0);
XSync(dpy, False);
mouseResetTime = Sys_Milliseconds ();
#ifdef HAVE_XF86DGA
if (in_dgamouse->value)
{
int MajorVersion, MinorVersion;
if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion))
{
// unable to query, probalby not supported, force the setting to 0
ri.Printf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" );
ri.Cvar_Set( "in_dgamouse", "0" );
} else
{
XF86DGADirectVideo(dpy, DefaultScreen(dpy), XF86DGADirectMouse);
XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
}
} else
#endif /* HAVE_XF86DGA */
{
mwx = glConfig.vidWidth / 2;
mwy = glConfig.vidHeight / 2;
mx = my = 0;
}
XGrabKeyboard(dpy, win,
False,
GrabModeAsync, GrabModeAsync,
CurrentTime);
XSync(dpy, False);
}
static void uninstall_grabs(void)
{
XChangePointerControl(dpy, qtrue, qtrue, mouse_accel_numerator,
mouse_accel_denominator, mouse_threshold);
XUngrabPointer(dpy, CurrentTime);
XUngrabKeyboard(dpy, CurrentTime);
XUndefineCursor(dpy, win);
}
static void Sys_XInstallGrabs( void ) {
assert( dpy );
XWarpPointer( dpy, None, win,
0, 0, 0, 0,
glConfig.vidWidth / 2, glConfig.vidHeight / 2 );
XSync( dpy, False );
XDefineCursor( dpy, win, Sys_XCreateNullCursor( dpy, win ) );
XGrabPointer( dpy, win,
False,
MOUSE_MASK,
GrabModeAsync, GrabModeAsync,
win,
None,
CurrentTime );
XGetPointerControl( dpy, &mouse_accel_numerator, &mouse_accel_denominator,
&mouse_threshold );
XChangePointerControl( dpy, True, True, 1, 1, 0 );
XSync( dpy, False );
mouse_reset_time = Sys_Milliseconds ();
if ( in_dgamouse.GetBool() && !dga_found ) {
common->Printf("XF86DGA not available, forcing DGA mouse off\n");
in_dgamouse.SetBool( false );
}
if ( in_dgamouse.GetBool() ) {
#if defined( ID_ENABLE_DGA )
XF86DGADirectVideo( dpy, DefaultScreen( dpy ), XF86DGADirectMouse );
XWarpPointer( dpy, None, win, 0, 0, 0, 0, 0, 0 );
#endif
} else {
mwx = glConfig.vidWidth / 2;
mwy = glConfig.vidHeight / 2;
mx = my = 0;
}
XGrabKeyboard( dpy, win,
False,
GrabModeAsync, GrabModeAsync,
CurrentTime );
XSync( dpy, False );
mouse_active = true;
}
/* _xwin_mousedrv_exit:
* Shuts down the mickey-mode driver.
*/
static void _xwin_mousedrv_exit(void)
{
XLOCK();
if (mouse_mult >= 0)
XChangePointerControl(_xwin.display, 1, 1, mouse_mult,
mouse_div, mouse_threshold);
_xwin_mouse_interrupt = 0;
XUNLOCK();
}
/* Check to see if we need to enter or leave mouse relative mode */
void X11_CheckMouseModeNoLock(_THIS)
{
const Uint8 full_focus = (SDL_APPACTIVE|SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
char *env_override;
int enable_relative = 1;
/* Allow the user to override the relative mouse mode.
They almost never want to do this, as it seriously affects
applications that rely on continuous relative mouse motion.
*/
env_override = SDL_getenv("SDL_MOUSE_RELATIVE");
if ( env_override ) {
enable_relative = atoi(env_override);
}
/* If the mouse is hidden and input is grabbed, we use relative mode */
if ( enable_relative &&
!(SDL_cursorstate & CURSOR_VISIBLE) &&
(this->input_grab != SDL_GRAB_OFF) &&
(SDL_GetAppState() & full_focus) == full_focus ) {
if ( ! mouse_relative ) {
X11_EnableDGAMouse(this);
if ( ! (using_dga & DGA_MOUSE) ) {
char *xmouse_accel;
SDL_GetMouseState(&mouse_last.x, &mouse_last.y);
/* Use as raw mouse mickeys as possible */
XGetPointerControl(SDL_Display,
&mouse_accel.numerator,
&mouse_accel.denominator,
&mouse_accel.threshold);
xmouse_accel=SDL_getenv("SDL_VIDEO_X11_MOUSEACCEL");
if ( xmouse_accel ) {
SetMouseAccel(this, xmouse_accel);
}
}
mouse_relative = 1;
}
} else {
if ( mouse_relative ) {
if ( using_dga & DGA_MOUSE ) {
X11_DisableDGAMouse(this);
} else {
XChangePointerControl(SDL_Display, True, True,
mouse_accel.numerator,
mouse_accel.denominator,
mouse_accel.threshold);
}
mouse_relative = 0;
}
}
}
static void
get_default_mouse_info (int *default_numerator, int *default_denominator, int *default_threshold)
{
int numerator, denominator;
int threshold;
int tmp_num, tmp_den, tmp_threshold;
/* Query X for the default value */
XGetPointerControl (GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), &numerator, &denominator,
&threshold);
XChangePointerControl (GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), True, True, -1, -1, -1);
XGetPointerControl (GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), &tmp_num, &tmp_den, &tmp_threshold);
XChangePointerControl (GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), True, True, numerator, denominator, threshold);
if (default_numerator)
*default_numerator = tmp_num;
if (default_denominator)
*default_denominator = tmp_den;
if (default_threshold)
*default_threshold = tmp_threshold;
}
static void install_grabs(void)
{
// inviso cursor
XDefineCursor(dpy, win, CreateNullCursor(dpy, win));
XGrabPointer(dpy, win,
False,
MOUSE_MASK,
GrabModeAsync, GrabModeAsync,
win,
None,
CurrentTime);
XGetPointerControl(dpy, &mouse_accel_numerator, &mouse_accel_denominator,
&mouse_threshold);
XChangePointerControl(dpy, qtrue, qtrue, 2, 1, 0);
if (in_dgamouse->value) {
int MajorVersion, MinorVersion;
if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion)) {
// unable to query, probalby not supported
ri.Printf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" );
ri.Cvar_Set( "in_dgamouse", "0" );
} else {
dgamouse = qtrue;
XF86DGADirectVideo(dpy, DefaultScreen(dpy), XF86DGADirectMouse);
XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
}
} else {
XWarpPointer(dpy, None, win,
0, 0, 0, 0,
glConfig.vidWidth / 2, glConfig.vidHeight / 2);
}
XGrabKeyboard(dpy, win,
False,
GrabModeAsync, GrabModeAsync,
CurrentTime);
// XSync(dpy, True);
}
static void uninstall_grabs( void ) {
if ( dgamouse ) {
dgamouse = qfalse;
XF86DGADirectVideo( dpy, DefaultScreen( dpy ), 0 );
}
XChangePointerControl( dpy, qtrue, qtrue, mouse_accel_numerator,
mouse_accel_denominator, mouse_threshold );
XUngrabPointer( dpy, CurrentTime );
XUngrabKeyboard( dpy, CurrentTime );
XWarpPointer( dpy, None, win,
0, 0, 0, 0,
glConfig.vidWidth / 2, glConfig.vidHeight / 2 );
// inviso cursor
XUndefineCursor( dpy, win );
}
static void uninstall_grabs(void)
{
if (dgamouse) {
dgamouse = qfalse;
XF86DGADirectVideo(dpy, DefaultScreen(dpy), 0);
}
XChangePointerControl(dpy, qtrue, qtrue, mouse_accel_numerator,
mouse_accel_denominator, mouse_threshold);
XUngrabPointer(dpy, CurrentTime);
XUngrabKeyboard(dpy, CurrentTime);
// inviso cursor
XUndefineCursor(dpy, win);
// XAutoRepeatOn(dpy);
// XSync(dpy, True);
}
static void uninstall_grabs( void ) {
if ( in_dgamouse->value ) {
if ( com_developer->value ) {
ri.Printf( PRINT_ALL, "DGA Mouse - Disabling DGA DirectVideo\n" );
}
XF86DGADirectVideo( dpy, DefaultScreen( dpy ), 0 );
}
XChangePointerControl( dpy, qtrue, qtrue, mouse_accel_numerator,
mouse_accel_denominator, mouse_threshold );
XUngrabPointer( dpy, CurrentTime );
XUngrabKeyboard( dpy, CurrentTime );
XWarpPointer( dpy, None, win,
0, 0, 0, 0,
glConfig.vidWidth / 2, glConfig.vidHeight / 2 );
// inviso cursor
XUndefineCursor( dpy, win );
}
/*
* Close the display etc.
*/
void Platform_specific_cleanup(void)
{
/* Here we restore the mouse to its former self */
/* the option may have been toggled in game to */
/* off so we cant trust that */
if (dpy != NULL) {
if (pre_exists)
XChangePointerControl(dpy, True, True, pre_acc_num,
pre_acc_denom, pre_threshold);
XAutoRepeatOn(dpy);
Colors_cleanup();
XCloseDisplay(dpy);
dpy = NULL;
if (kdpy) {
XAutoRepeatOn(kdpy);
XCloseDisplay(kdpy);
kdpy = NULL;
}
}
Widget_cleanup();
}
void Sys_XUninstallGrabs(void) {
assert( dpy );
#if defined( ID_ENABLE_DGA )
if ( in_dgamouse.GetBool() ) {
common->DPrintf( "DGA Mouse - Disabling DGA DirectVideo\n" );
XF86DGADirectVideo( dpy, DefaultScreen( dpy ), 0 );
}
#endif
XChangePointerControl( dpy, true, true, mouse_accel_numerator,
mouse_accel_denominator, mouse_threshold );
XUngrabPointer( dpy, CurrentTime );
XUngrabKeyboard( dpy, CurrentTime );
XWarpPointer( dpy, None, win,
0, 0, 0, 0,
glConfig.vidWidth / 2, glConfig.vidHeight / 2);
XUndefineCursor( dpy, win );
mouse_active = false;
}
void UXViewport::CaptureInputs()
{
guard(UXViewport::CaptureInputs);
// Check keyboard state.
XKeyboardState KeyState;
XGetKeyboardControl(XDisplay, &KeyState);
if( KeyState.global_auto_repeat == AutoRepeatModeOn )
{
RestoreAutoRepeat = true;
XAutoRepeatOff( XDisplay );
}
// Examine root window.
Window RootRoot;
int r_x, r_y;
unsigned int r_width, r_height, r_border, r_depth;
XGetGeometry(
XDisplay, DefaultRootWindow(XDisplay), &RootRoot,
&r_x, &r_y, &r_width, &r_height, &r_border, &r_depth
);
XWarpPointer(XDisplay, None, XWindow,
0, 0, 0, 0, r_width/2, r_height/2);
XSync(XDisplay, False);
//XDefineCursor(XDisplay, XWindow, GetNullCursor());
// Capture the pointer.
XGrabPointer(XDisplay, XWindow, False,
ButtonPressMask | ButtonReleaseMask |
PointerMotionMask | ButtonMotionMask,
GrabModeAsync, GrabModeAsync, XWindow, None, CurrentTime );
// Control acceleration.
XChangePointerControl(XDisplay, True, True, 2, 1, 0);
XSync(XDisplay, False);
// Query DGA capabilities.
UXClient* C = GetOuterUXClient();
if (C->DGAMouseEnabled)
{
INT VersionMajor, VersionMinor;
if (!XF86DGAQueryVersion(XDisplay, &VersionMajor, &VersionMinor))
{
debugf( TEXT("XF86DGA disabled.") );
UseDGA = false;
} else {
debugf( TEXT("XF86DGA enabled.") );
UseDGA = true;
XF86DGADirectVideo(XDisplay, DefaultScreen(XDisplay), XF86DGADirectMouse);
XWarpPointer(XDisplay, None, XWindow, 0, 0, 0, 0, 0, 0);
}
} else
UseDGA = false;
XGrabKeyboard(XDisplay, XWindow, False, GrabModeAsync, GrabModeAsync, CurrentTime);
XSync(XDisplay, False);
unguard;
}
main()
{
Window w2;
Display *dpy = XOpenDisplay(NIL);
assert(dpy);
Screen *scr = DefaultScreenOfDisplay(dpy);
// CreateWindow
Window w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent,
CopyFromParent, CopyFromParent,
0, NIL);
XDestroyWindow(dpy, w);
// CreateWindow with arguments
XSetWindowAttributes swa;
swa.background_pixel = WhitePixelOfScreen(scr);
swa.bit_gravity = NorthWestGravity;
swa.border_pixel = BlackPixelOfScreen(scr);
swa.colormap = DefaultColormapOfScreen(scr);
swa.cursor = None;
swa.win_gravity = NorthGravity;
w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent,
CopyFromParent, CopyFromParent,
CWBackPixel | CWBitGravity | CWBorderPixel | CWColormap | CWCursor | CWWinGravity,
&swa);
// CreateWindow with other arguments
XDestroyWindow(dpy, w);
Pixmap pixmap = XCreatePixmap(dpy, RootWindowOfScreen(scr), 45, 25, DefaultDepthOfScreen(scr));
assert(pixmap);
swa.background_pixmap = pixmap;
swa.border_pixmap = pixmap;
w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent,
CopyFromParent, CopyFromParent,
CWBackPixmap | CWBorderPixmap,
&swa);
// ChangeWindowAttributes
swa.backing_planes = 0x1;
swa.backing_pixel = WhitePixelOfScreen(scr);
swa.save_under = True;
swa.event_mask = KeyPressMask | KeyReleaseMask;
swa.do_not_propagate_mask = ButtonPressMask | Button4MotionMask;
swa.override_redirect = False;
XChangeWindowAttributes(dpy, w, CWBackingPlanes | CWBackingPixel | CWSaveUnder | CWEventMask
| CWDontPropagate | CWOverrideRedirect, &swa);
// GetWindowAttributes
XWindowAttributes wa;
Status success = XGetWindowAttributes(dpy, w, &wa);
// DestroyWindow (done)
// DestroySubwindows
w2 = XCreateWindow(dpy, w, 20, 30, 40, 50, 3, CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL);
XDestroySubwindows(dpy, w);
// ChangeSaveSet
// Display *dpy2 = XOpenDisplay(NIL);
// assert(dpy2);
// XAddToSaveSet(dpy2, w);
// XCloseDisplay(dpy2);
// ReparentWindow
w2 = XCreateWindow(dpy, RootWindowOfScreen(scr), 20, 30, 40, 50, 3,
CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL);
XReparentWindow(dpy, w2, w, 10, 5);
// MapWindow
XMapWindow(dpy, w);
// MapSubwindows
XMapSubwindows(dpy, w);
// UnmapWindow
XUnmapWindow(dpy, w);
// UnmapSubwindows
XMapWindow(dpy, w);
XUnmapSubwindows(dpy, w2);
XMapSubwindows(dpy, w);
// ConfigureWindow
Window w3 = XCreateWindow(dpy, w, 10, 50, 100, 10, 2,
CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL);
XMapWindow(dpy, w3);
XWindowChanges wc;
wc.x = -5;
wc.y = -10;
wc.width = 50;
wc.height = 40;
wc.border_width = 7;
wc.sibling = w2;
wc.stack_mode = Opposite;
XConfigureWindow(dpy, w3,
CWX | CWY | CWWidth | CWHeight | CWBorderWidth | CWSibling | CWStackMode,
&wc);
// CirculateWindow
XCirculateSubwindows(dpy, w, RaiseLowest);
// GetGeometry
Window root;
int x, y;
unsigned width, height, border_width, depth;
XGetGeometry(dpy, w, &root, &x, &y, &width, &height, &border_width, &depth);
// QueryTree
Window parent;
Window *children;
unsigned nchildren;
success = XQueryTree(dpy, w, &root, &parent, &children, &nchildren);
XFree(children);
// InternAtom
Atom a = XInternAtom(dpy, "WM_PROTOCOLS", True);
// GetAtomName
char *string = XGetAtomName(dpy, XA_PRIMARY);
XFree(string);
// ChangeProperty
XStoreName(dpy, w, "test window");
// DeleteProperty
XDeleteProperty(dpy, w, XA_WM_NAME);
// GetProperty
// TODO
// ListProperties
int num_prop;
Atom *list = XListProperties(dpy, w, &num_prop);
XFree(list);
// SetSelectionOwner
XSetSelectionOwner(dpy, XA_PRIMARY, w, 12000);
XSetSelectionOwner(dpy, XA_SECONDARY, w, CurrentTime);
// GetSelectionOwner
Window wx = XGetSelectionOwner(dpy, XA_PRIMARY);
// ConvertSelection
XConvertSelection(dpy, XA_SECONDARY, XA_CURSOR, XA_POINT, w, CurrentTime);
// SendEvent
// GrabPointer
std::cerr << "Grabbing" << std::endl;
int res = XGrabPointer(dpy, w, False, Button5MotionMask | PointerMotionHintMask,
GrabModeSync, GrabModeAsync, w, None, CurrentTime);
XSync(dpy, False);
// sleep(5);
// UngrabPointer
std::cerr << "Ungrabbing" << std::endl;
XUngrabPointer(dpy, CurrentTime);
// GrabButton
XGrabButton(dpy, 3, ShiftMask | ControlMask, w, False, PointerMotionHintMask | Button2MotionMask,
GrabModeAsync, GrabModeSync, None, None);
XGrabButton(dpy, 2, AnyModifier, w, False, PointerMotionHintMask | Button2MotionMask,
GrabModeAsync, GrabModeSync, None, None);
// UngrabButton
XUngrabButton(dpy, 2, LockMask, w);
// ChangeActivePointerGrab
XChangeActivePointerGrab(dpy, ButtonPressMask, None, CurrentTime);
// GrabKeyboard
XGrabKeyboard(dpy, w, True, GrabModeSync, GrabModeSync, 12000);
// UngrabKeyboard
XUngrabKeyboard(dpy, 13000);
// GrabKey
XGrabKey(dpy, XKeysymToKeycode(dpy, XK_Tab), ShiftMask | Mod3Mask, w, True, GrabModeSync,
GrabModeSync);
// UngrabKey
XUngrabKey(dpy, AnyKey, AnyModifier, w);
// AllowEvents
XAllowEvents(dpy, AsyncPointer, 14000);
// GrabServer
XGrabServer(dpy);
// UngrabServer
XUngrabServer(dpy);
// QueryPointer
Window child;
int root_x, root_y, win_x, win_y;
unsigned mask;
Bool bres = XQueryPointer(dpy, w, &root, &child, &root_x, &root_y, &win_x, &win_y, &mask);
// GetMotionEvents
int nevents;
XGetMotionEvents(dpy, w, 15000, 16000, &nevents);
// TranslateCoordinates
int dest_x, dest_y;
XTranslateCoordinates(dpy, w, w2, 10, 20, &dest_x, &dest_y, &child);
// WarpPointer
XWarpPointer(dpy, w, w2, 0, 0, 100, 100, 20, 30);
// SetInputFocus
XSetInputFocus(dpy,w, RevertToPointerRoot, 17000);
XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, 17000);
// GetInputFocus
Window focus;
int revert_to;
XGetInputFocus(dpy, &focus, &revert_to);
// QueryKeymap
char keys_return[32];
XQueryKeymap(dpy, keys_return);
// OpenFont
Font fid = XLoadFont(dpy, "cursor");
// CloseFont
XUnloadFont(dpy, fid);
// QueryFont
XFontStruct *fs = XLoadQueryFont(dpy, "cursor");
assert(fs);
// QueryTextExtents
int direction, font_ascent, font_descent;
XCharStruct overall;
XQueryTextExtents(dpy, fs -> fid, "toto", 4, &direction, &font_ascent, &font_descent, &overall);
XQueryTextExtents(dpy, fs -> fid, "odd__length", 11, &direction, &font_ascent, &font_descent, &overall);
XChar2b c2bs;
c2bs.byte1 = '$';
c2bs.byte2 = 'B';
XQueryTextExtents16(dpy, fs -> fid, &c2bs, 1, &direction, &font_ascent, &font_descent, &overall);
XQueryTextExtents(dpy, fs -> fid, longString, strlen(longString), &direction, &font_ascent,
&font_descent, &overall);
// ListFonts
int actual_count;
char **fontList = XListFonts(dpy, "*", 100, &actual_count);
XFree((char *)fontList);
// ListFontsWithInfo
int count;
XFontStruct *info;
char **names = XListFontsWithInfo(dpy, "*", 100, &count, &info);
XFreeFontInfo(names, info, count);
// SetFontPath
// GetFontPath
int npaths;
char **charList = XGetFontPath(dpy, &npaths);
char **charList2 = new char *[npaths + 1];
memcpy(charList2, charList, npaths * sizeof(char *));
charList2[npaths] = charList2[0];
XSetFontPath(dpy, charList2, npaths + 1);
XSetFontPath(dpy, charList, npaths); // Reset to some reasonnable value
XFreeFontPath(charList);
delete [] charList2;
// CreatePixmap
Pixmap pix2 = XCreatePixmap(dpy, w, 100, 200, DefaultDepthOfScreen(scr));
// FreePixmap
XFreePixmap(dpy, pix2);
// CreateGC
Pixmap bitmap = XCreateBitmapFromData(dpy, RootWindowOfScreen(scr),
"\000\000\001\000\000\001\000\000\001\377\377\377", 3, 4);
XGCValues gcv;
gcv.function = GXand;
gcv.plane_mask = 0x1;
gcv.foreground = WhitePixelOfScreen(scr);
gcv.background = BlackPixelOfScreen(scr);
gcv.line_width = 2;
gcv.line_style = LineDoubleDash;
gcv.cap_style = CapProjecting;
gcv.join_style = JoinRound;
gcv.fill_style = FillStippled;
gcv.fill_rule = EvenOddRule;
gcv.arc_mode = ArcPieSlice;
gcv.tile = pixmap;
gcv.stipple = bitmap;
gcv.ts_x_origin = 3;
gcv.ts_y_origin = 4;
gcv.font = fs -> fid;
gcv.subwindow_mode = ClipByChildren;
gcv.graphics_exposures = True;
gcv.clip_x_origin = 5;
gcv.clip_y_origin = 6;
gcv.clip_mask = bitmap;
gcv.dash_offset = 1;
gcv.dashes = 0xc2;
GC gc = XCreateGC(dpy, w,
GCFunction | GCPlaneMask | GCForeground | GCBackground | GCLineWidth
| GCLineStyle | GCCapStyle | GCJoinStyle | GCFillStyle | GCFillRule | GCTile
| GCStipple | GCTileStipXOrigin | GCTileStipYOrigin | GCFont | GCSubwindowMode
| GCGraphicsExposures | GCClipXOrigin | GCClipYOrigin | GCClipMask | GCDashOffset
| GCDashList | GCArcMode,
&gcv);
// ChangeGC
gcv.function = GXandReverse;
// Only a few of these should appear, since the values are cached on the client side by the Xlib.
XChangeGC(dpy, gc, GCFunction | GCLineStyle | GCStipple | GCGraphicsExposures | GCDashList, &gcv);
// CopyGC
GC gc2 = XCreateGC(dpy, w, 0, NIL);
XCopyGC(dpy, gc, GCFunction | GCLineStyle | GCStipple | GCGraphicsExposures | GCDashList, gc2);
// SetDashes
XSetDashes(dpy, gc, 3, "\001\377\001", 3);
// SetClipRectangles
XRectangle rectangles[] = { { 10, 20, 30, 40 }, { 100, 200, 5, 3 }, { -5, 1, 12, 24 } };
XSetClipRectangles(dpy, gc, 12, 9, rectangles, SIZEOF(rectangles), Unsorted);
// FreeGC
// done already
// ClearArea
XClearArea(dpy, w, 30, 10, 10, 100, False);
// CopyArea
XCopyArea(dpy, w, pixmap, gc, 0, 0, 100, 100, 10, 10);
// CopyPlane
// This won't work if the Screen doesn't have at least 3 planes
XCopyPlane(dpy, pixmap, w, gc, 20, 10, 40, 30, 0, 0, 0x4);
// PolyPoint
XDrawPoint(dpy, w, gc, 1, 2);
XPoint points[] = { { 3, 4 }, { 5, 6 } };
XDrawPoints(dpy, w, gc, points, SIZEOF(points), CoordModeOrigin);
// PolyLine
XDrawLines(dpy, w, gc, points, SIZEOF(points), CoordModePrevious);
// PolySegment
XSegment segments[] = { { 7, 8, 9, 10 }, { 11, 12, 13, 14 }, { 15, 16, 17, 18 } };
XDrawSegments(dpy, w, gc, segments, SIZEOF(segments));
// PolyRectangle
XDrawRectangles(dpy, w, gc, rectangles, SIZEOF(rectangles));
// PolyArc
XArc arcs[] = { { 10, 20, 30, 40, 50, 60 }, { -70, 80, 90, 100, 110, 120 },
{ 10, 20, 30, 40, 50, -30 } };
XDrawArcs(dpy, w, gc, arcs, SIZEOF(arcs));
// FillPoly
XFillPolygon(dpy, w, gc, points, SIZEOF(points), Convex, CoordModePrevious);
// PolyFillRectangle
XFillRectangles(dpy, w, gc, rectangles, SIZEOF(rectangles));
// PolyFillArc
XFillArcs(dpy, w, gc, arcs, SIZEOF(arcs));
// PutImage
// GetImage
XImage *image = XGetImage(dpy, w, 10, 20, 40, 30, AllPlanes, ZPixmap);
XPutImage(dpy, w, gc, image, 0, 0, 50, 60, 40, 30);
XSync(dpy, False); // Make the next request starts at the beginning of a packet
// PolyText8
XTextItem textItems[3];
textItems[0].chars = "toto";
textItems[0].nchars = strlen(textItems[0].chars);
textItems[0].delta = -3;
textItems[0].font = fs->fid;
textItems[1].chars = "titi";
textItems[1].nchars = strlen(textItems[1].chars);
textItems[1].delta = 3;
textItems[1].font = None;
textItems[2].chars = "tutu";
textItems[2].nchars = strlen(textItems[2].chars);
textItems[2].delta = 0;
textItems[2].font = fs->fid;
XDrawText(dpy, w, gc, 10, 10, textItems, 3);
XTextItem textItems2[3];
textItems2[0].chars = "totox";
textItems2[0].nchars = strlen(textItems2[0].chars);
textItems2[0].delta = -3;
textItems2[0].font = fs->fid;
textItems2[1].chars = "titi";
textItems2[1].nchars = strlen(textItems2[1].chars);
textItems2[1].delta = 3;
textItems2[1].font = None;
textItems2[2].chars = "tutu";
textItems2[2].nchars = strlen(textItems2[2].chars);
textItems2[2].delta = 0;
textItems2[2].font = fs->fid;
XDrawText(dpy, w, gc, 10, 10, textItems2, 3);
// PolyText16
XChar2b c2b2[] = { 0, 't', 0, 'x' };
XTextItem16 items16[] = { { &c2bs, 1, -5, None }, { NULL, 0, 0, None }, { c2b2, 2, 0, fs -> fid } };
XDrawText16(dpy, w, gc, 10, 0, items16, SIZEOF(items16));
// ImageText8
XDrawImageString(dpy, w, gc, 10, 10, "toto", 4);
// ImageText16
XDrawImageString16(dpy, w, gc, 10, 10, &c2bs, 1);
XDrawImageString16(dpy, w, gc, 10, 20, c2b2, 2);
// CreateColormap
// Don't forget to tell the kids how it was when we had only 8 bits per pixel.
Colormap colormap = XCreateColormap(dpy, w, DefaultVisualOfScreen(scr), None);
// FreeColormap
XFreeColormap(dpy, colormap);
colormap = XCreateColormap(dpy, w, DefaultVisualOfScreen(scr), None);
// CopyColormapAndFree
Colormap colormap2 = XCopyColormapAndFree(dpy, colormap);
// InstallColormap
XInstallColormap(dpy, colormap2);
// UninstallColormap
XUninstallColormap(dpy, colormap2);
// ListInstalledColormaps
int num;
Colormap *colormapList = XListInstalledColormaps(dpy, w, &num);
// AllocColor
XColor screen;
screen.red = 0;
screen.green = 32767;
screen.blue = 65535;
screen.flags = DoRed | DoGreen | DoBlue;
success = XAllocColor(dpy, colormap, &screen);
// AllocNamedColor
XColor screen2, exact;
success = XAllocNamedColor(dpy, colormap, "Wheat", &screen2, &exact);
// AllocColorCells
unsigned long plane_masks, pixels;
success = XAllocColorCells(dpy, colormap, False, &plane_masks, 1, &pixels, 1);
// AllocColorPlanes
unsigned long rmask, gmask, bmask;
success = XAllocColorPlanes(dpy, colormap, False, &pixels, 1, 0, 0, 0, &rmask, &gmask, &bmask);
// FreeColors
unsigned long pixels2[2] = { screen.pixel, screen2.pixel };
XFreeColors(dpy, colormap, pixels2, 2, 0);
// StoreColors
success = XAllocColorCells(dpy, colormap, False, NIL, 0, pixels2, 2);
// On many contemporary (that is, year 2000) video cards, you can't allocate read / write cells
// I want my requests to be sent, however.
if (!success) {
XSetErrorHandler(errorHandler);
}
XColor colors[2];
colors[0] = screen; colors[0].pixel = pixels2[0];
colors[1] = screen2; colors[1].pixel = pixels2[1];
XStoreColors(dpy, colormap, colors, 2);
// StoreNamedColor
XStoreNamedColor(dpy, colormap, "Wheat", colors[0].pixel, DoBlue);
XSync(dpy, False);
XSetErrorHandler(NIL); // Restore the default handler
// QueryColors
screen2.pixel = WhitePixelOfScreen(scr);
XQueryColor(dpy, colormap, &screen2);
// LookupColor
success = XLookupColor(dpy, colormap, "DarkCyan", &exact, &screen);
// CreateCursor
Cursor cursor = XCreatePixmapCursor(dpy, pixmap, None, &exact, colors, 10, 10);
// CreateGlyphCursor
Cursor cursor2 = XCreateGlyphCursor(dpy, fs -> fid, fs -> fid, 'X', 0, &exact, colors);
// FreeCursor
XFreeCursor(dpy, cursor2);
// RecolorCursor
XRecolorCursor(dpy, cursor, colors, &exact);
// QueryBestSize
success = XQueryBestSize(dpy, CursorShape, RootWindowOfScreen(scr), 100, 20, &width, &height);
// QueryExtension
int major_opcode, first_event, first_error;
XQueryExtension(dpy, "toto", &major_opcode, &first_event, &first_error);
// ListExtensions
int nextensions;
char **extensionList = XListExtensions(dpy, &nextensions);
for(char **p = extensionList; nextensions; nextensions--, p++) std::cout << *p << std::endl;
XFree(extensionList);
// ChangeKeyboardMapping
// GetKeyboardMapping
int min_keycodes, max_keycodes;
XDisplayKeycodes(dpy, &min_keycodes, &max_keycodes);
int keysyms_per_keycode;
KeySym *keysyms = XGetKeyboardMapping(dpy, min_keycodes, max_keycodes - min_keycodes + 1,
&keysyms_per_keycode);
XChangeKeyboardMapping(dpy, min_keycodes, keysyms_per_keycode, keysyms,
max_keycodes - min_keycodes + 1);
// ChangeKeyboardControl
// GetKeyboardControl
XKeyboardState keyboardState;
XGetKeyboardControl(dpy, &keyboardState);
XKeyboardControl keyboardValues;
keyboardValues.key_click_percent = keyboardState.key_click_percent;
keyboardValues.bell_percent = keyboardState.bell_percent;
keyboardValues.bell_pitch = keyboardState.bell_pitch;
keyboardValues.bell_duration = keyboardState.bell_duration;
keyboardValues.led = 1;
keyboardValues.led_mode = LedModeOn;
keyboardValues.key = min_keycodes;
keyboardValues.auto_repeat_mode = AutoRepeatModeDefault;
XChangeKeyboardControl(dpy,
KBKeyClickPercent | KBBellPercent | KBBellPitch | KBBellDuration
| KBLed | KBLedMode | KBKey | KBAutoRepeatMode,
&keyboardValues);
// Bell
XBell(dpy, 90);
// ChangePointerControl
// GetPointerControl
int accel_numerator, accel_denominator, threshold;
XGetPointerControl(dpy, &accel_numerator, &accel_denominator, &threshold);
XChangePointerControl(dpy, True, True, accel_numerator, accel_denominator, threshold);
// SetScreenSaver
// GetScreenSaver
int timeout, interval, prefer_blanking, allow_exposures;
XGetScreenSaver(dpy, &timeout, &interval, &prefer_blanking, &allow_exposures);
XSetScreenSaver(dpy, timeout, interval, prefer_blanking, allow_exposures);
// ChangeHosts
// ListHosts
int nhosts;
Bool state;
XHostAddress *hostList = XListHosts(dpy, &nhosts, &state);
XHostAddress host;
host.family = FamilyInternet;
host.length = 4;
host.address = "\001\002\003\004";
XAddHost(dpy, &host);
// SetAccessControl
XSetAccessControl(dpy, EnableAccess);
// SetCloseDownMode
XSetCloseDownMode(dpy, RetainTemporary);
// KillClient
XKillClient(dpy, AllTemporary);
// RotateProperties
Atom properties[] = { XInternAtom(dpy, "CUT_BUFFER0", False),
XInternAtom(dpy, "CUT_BUFFER1", False),
XInternAtom(dpy, "CUT_BUFFER2", False) };
XRotateWindowProperties(dpy, RootWindowOfScreen(scr), properties, SIZEOF(properties), -1);
// ForceScreenSaver
XForceScreenSaver(dpy, ScreenSaverReset);
// SetPointerMapping
// GetPointerMapping
unsigned char map[64];
int map_length = XGetPointerMapping(dpy, map, 64);
XSetPointerMapping(dpy, map, map_length);
// SetModifierMapping
// GetModifierMapping
XModifierKeymap *modmap = XGetModifierMapping(dpy);
XSetModifierMapping(dpy, modmap);
// NoOperation
XNoOp(dpy);
for(;;) {
XEvent e;
XNextEvent(dpy, &e);
std::cout << "Got an event of type " << e.type << std::endl;
}
}
void VID_SetMouse(qboolean fullscreengrab, qboolean relative, qboolean hidecursor)
{
static int originalmouseparms_num;
static int originalmouseparms_denom;
static int originalmouseparms_threshold;
static qboolean restore_spi;
#ifdef USEDGA
qboolean usedgamouse;
#endif
if (!vidx11_display || !win)
return;
if (relative)
fullscreengrab = true;
if (!mouse_avail)
fullscreengrab = relative = hidecursor = false;
#ifdef USEDGA
usedgamouse = relative && vid_dgamouse.integer;
if (!vid_x11_dgasupported)
usedgamouse = false;
if (fullscreengrab && vid_usingmouse && (vid_usingdgamouse != usedgamouse))
VID_SetMouse(false, false, false); // ungrab first!
#endif
if (vid_usingmousegrab != fullscreengrab)
{
vid_usingmousegrab = fullscreengrab;
cl_ignoremousemoves = 2;
if (fullscreengrab)
{
XGrabPointer(vidx11_display, win, True, 0, GrabModeAsync, GrabModeAsync, win, None, CurrentTime);
if (vid_grabkeyboard.integer || vid_isoverrideredirect)
XGrabKeyboard(vidx11_display, win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
}
else
{
XUngrabPointer(vidx11_display, CurrentTime);
XUngrabKeyboard(vidx11_display, CurrentTime);
}
}
if (relative)
{
if (!vid_usingmouse)
{
XWindowAttributes attribs_1;
XSetWindowAttributes attribs_2;
XGetWindowAttributes(vidx11_display, win, &attribs_1);
attribs_2.event_mask = attribs_1.your_event_mask | KEY_MASK | MOUSE_MASK;
XChangeWindowAttributes(vidx11_display, win, CWEventMask, &attribs_2);
#ifdef USEDGA
vid_usingdgamouse = usedgamouse;
if (usedgamouse)
{
XF86DGADirectVideo(vidx11_display, DefaultScreen(vidx11_display), XF86DGADirectMouse);
XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, 0, 0);
}
else
#endif
XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, vid.width / 2, vid.height / 2);
// COMMANDLINEOPTION: X11 Input: -noforcemparms disables setting of mouse parameters (not used with DGA, windows only)
#ifdef USEDGA
if (!COM_CheckParm ("-noforcemparms") && !usedgamouse)
#else
if (!COM_CheckParm ("-noforcemparms"))
#endif
{
XGetPointerControl(vidx11_display, &originalmouseparms_num, &originalmouseparms_denom, &originalmouseparms_threshold);
XChangePointerControl (vidx11_display, true, false, 1, 1, -1); // TODO maybe change threshold here, or remove this comment
restore_spi = true;
}
else
restore_spi = false;
cl_ignoremousemoves = 2;
vid_usingmouse = true;
}
}
else
{
if (vid_usingmouse)
{
#ifdef USEDGA
if (vid_usingdgamouse)
XF86DGADirectVideo(vidx11_display, DefaultScreen(vidx11_display), 0);
vid_usingdgamouse = false;
#endif
cl_ignoremousemoves = 2;
if (restore_spi)
XChangePointerControl (vidx11_display, true, true, originalmouseparms_num, originalmouseparms_denom, originalmouseparms_threshold);
restore_spi = false;
vid_usingmouse = false;
}
}
if (vid_usinghidecursor != hidecursor)
{
vid_usinghidecursor = hidecursor;
if (hidecursor)
XDefineCursor(vidx11_display, win, CreateNullCursor(vidx11_display, win));
else
XUndefineCursor(vidx11_display, win);
}
}
static void on_mouse_accel_changed(GtkRange* range, gpointer user_data)
{
accel = (int)(gtk_range_get_value(range) * 10);
XChangePointerControl(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), True, False,
accel, 10, 0);
}
void
xnestChangePointerControl(DeviceIntPtr pDev, PtrCtrl *ctrl)
{
XChangePointerControl(xnestDisplay, True, True,
ctrl->num, ctrl->den, ctrl->threshold);
}
int main(int argc, char** argv)
{
GtkBuilder* builder;
char* str = NULL;
GKeyFile* kf = g_key_file_new();
const char* session_name = g_getenv("DESKTOP_SESSION");
/* load settings from current session config files */
if(!session_name)
session_name = "LXDE";
char* rel_path = g_strconcat("lxsession/", session_name, "/desktop.conf", NULL);
char* user_config_file = g_build_filename(g_get_user_config_dir(), rel_path, NULL);
#ifdef ENABLE_NLS
bindtextdomain ( GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR );
bind_textdomain_codeset ( GETTEXT_PACKAGE, "UTF-8" );
textdomain ( GETTEXT_PACKAGE );
#endif
gtk_init(&argc, &argv);
gtk_icon_theme_prepend_search_path(gtk_icon_theme_get_default(), PACKAGE_DATA_DIR);
/* build the UI */
builder = gtk_builder_new();
gtk_builder_add_from_file( builder, PACKAGE_DATA_DIR "/lxinput.ui", NULL );
dlg = (GtkWidget*)gtk_builder_get_object( builder, "dlg" );
gtk_dialog_set_alternative_button_order( (GtkDialog*)dlg, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 );
mouse_accel = (GtkRange*)gtk_builder_get_object(builder,"mouse_accel");
mouse_threshold = (GtkRange*)gtk_builder_get_object(builder,"mouse_threshold");
mouse_left_handed = (GtkToggleButton*)gtk_builder_get_object(builder,"left_handed");
mouse_dclick = (GtkRange*)gtk_builder_get_object(builder, "mouse_dclick");
kb_delay = (GtkRange*)gtk_builder_get_object(builder,"kb_delay");
kb_interval = (GtkRange*)gtk_builder_get_object(builder,"kb_interval");
kb_beep = (GtkToggleButton*)gtk_builder_get_object(builder,"beep");
kb_layout = (GtkButton*)gtk_builder_get_object(builder,"keyboard_layout");
const gchar *program = detect_keymap_program();
if (program == NULL)
{
/* Hide the button if there is no program to set keymap */
kb_layout_label = (GtkLabel*)gtk_builder_get_object(builder,"keyboard_layout_label");
gtk_widget_set_visible(GTK_WIDGET(kb_layout_label), FALSE);
gtk_widget_set_visible(GTK_WIDGET(kb_layout), FALSE);
}
else
{
gtk_button_set_label(kb_layout, _("Keyboard Layout..."));
}
g_object_unref( builder );
/* read the config flie */
load_settings();
/* init the UI */
gtk_range_set_value(mouse_accel, (gdouble)accel / 10.0);
gtk_range_set_value(mouse_threshold, threshold);
gtk_range_set_value(mouse_dclick, dclick);
gtk_toggle_button_set_active(mouse_left_handed, left_handed);
gtk_range_set_value(kb_delay, delay);
gtk_range_set_value(kb_interval, interval);
gtk_toggle_button_set_active(kb_beep, beep);
set_range_stops(mouse_accel, 10);
g_signal_connect(mouse_accel, "value-changed", G_CALLBACK(on_mouse_accel_changed), NULL);
set_range_stops(mouse_threshold, 10);
g_signal_connect(mouse_threshold, "value-changed", G_CALLBACK(on_mouse_threshold_changed), NULL);
g_signal_connect(mouse_left_handed, "toggled", G_CALLBACK(on_left_handed_toggle), NULL);
g_signal_connect(mouse_dclick, "value-changed", G_CALLBACK(on_mouse_dclick_changed), NULL);
set_range_stops(kb_delay, 10);
g_signal_connect(kb_delay, "value-changed", G_CALLBACK(on_kb_range_changed), &delay);
set_range_stops(kb_interval, 10);
g_signal_connect(kb_interval, "value-changed", G_CALLBACK(on_kb_range_changed), &interval);
g_signal_connect(kb_beep, "toggled", G_CALLBACK(on_kb_beep_toggle), NULL);
g_signal_connect(kb_layout, "clicked", G_CALLBACK(on_kb_layout_clicked), NULL);
if( gtk_dialog_run( (GtkDialog*)dlg ) == GTK_RESPONSE_OK )
{
gsize len;
if(!g_key_file_load_from_file(kf, user_config_file, G_KEY_FILE_KEEP_COMMENTS|G_KEY_FILE_KEEP_TRANSLATIONS, NULL))
{
/* the user config file doesn't exist, create its parent dir */
len = strlen(user_config_file) - strlen("/desktop.conf");
user_config_file[len] = '\0';
g_debug("user_config_file = %s", user_config_file);
g_mkdir_with_parents(user_config_file, 0700);
user_config_file[len] = '/';
g_key_file_load_from_dirs(kf, rel_path, (const char**)g_get_system_config_dirs(), NULL,
G_KEY_FILE_KEEP_COMMENTS|G_KEY_FILE_KEEP_TRANSLATIONS, NULL);
}
g_free(rel_path);
g_key_file_set_integer(kf, "Mouse", "AccFactor", accel);
g_key_file_set_integer(kf, "Mouse", "AccThreshold", threshold);
g_key_file_set_integer(kf, "Mouse", "LeftHanded", !!left_handed);
g_key_file_set_integer(kf, "Keyboard", "Delay", delay);
g_key_file_set_integer(kf, "Keyboard", "Interval", interval);
g_key_file_set_integer(kf, "Keyboard", "Beep", !!beep);
str = g_key_file_to_data(kf, &len, NULL);
g_file_set_contents(user_config_file, str, len, NULL);
g_free(str);
/* ask the settigns daemon to reload */
/* FIXME: is this needed? */
/* g_spawn_command_line_sync("lxde-settings-daemon reload", NULL, NULL, NULL, NULL); */
/* also save settings into autostart file for non-lxsession sessions */
g_free(user_config_file);
rel_path = g_build_filename(g_get_user_config_dir(), "autostart", NULL);
user_config_file = g_build_filename(rel_path, "LXinput-setup.desktop", NULL);
if (g_mkdir_with_parents(rel_path, 0755) == 0)
{
str = g_strdup_printf("[Desktop Entry]\n"
"Type=Application\n"
"Name=%s\n"
"Comment=%s\n"
"NoDisplay=true\n"
"Exec=sh -c 'xset m %d/10 %d r rate %d %d b %s'\n"
"NotShowIn=GNOME;KDE;XFCE;\n",
_("LXInput autostart"),
_("Setup keyboard and mouse using settings done in LXInput"),
/* FIXME: how to setup left-handed mouse? */
accel, threshold, delay, interval,
beep ? "on" : "off");
g_file_set_contents(user_config_file, str, -1, NULL);
g_free(str);
}
}
else
{
/* restore to original settings */
/* keyboard */
delay = old_delay;
interval = old_interval;
beep = old_beep;
XkbSetAutoRepeatRate(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), XkbUseCoreKbd, delay, interval);
/* FIXME: beep? */
/* mouse */
accel = old_accel;
threshold = old_threshold;
left_handed = old_left_handed;
XChangePointerControl(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), True, True,
accel, 10, threshold);
set_left_handed_mouse();
set_dclick_time (old_dclick);
}
gtk_widget_destroy( dlg );
g_free( file );
g_key_file_free( kf );
g_free(user_config_file);
return 0;
}
void MouseConfig::saveParams( void )
{
if (GUI)
{
accelRate = getAccel();
thresholdMove = getThreshold();
handed = getHandedness();
}
XChangePointerControl( kapp->getDisplay(),
TRUE, TRUE, accelRate, 1, thresholdMove);
unsigned char map[5];
int remap=1;
if (handedEnabled)
{
switch (num_buttons)
{
case 1:
{
map[0] = (unsigned char) 1;
}
break;
case 2:
if (handed == RIGHT_HANDED)
{
map[0] = (unsigned char) 1;
map[1] = (unsigned char) 3;
}
else
{
map[0] = (unsigned char) 3;
map[1] = (unsigned char) 1;
}
break;
case 3:
if (handed == RIGHT_HANDED)
{
map[0] = (unsigned char) 1;
map[1] = (unsigned char) middle_button;
map[2] = (unsigned char) 3;
}
else
{
map[0] = (unsigned char) 3;
map[1] = (unsigned char) middle_button;
map[2] = (unsigned char) 1;
}
break;
case 5:
// Intellimouse case, where buttons 1-3 are left, middle, and
// right, and 4-5 are up/down
if (handed == RIGHT_HANDED)
{
map[0] = (unsigned char) 1;
map[1] = (unsigned char) 2;
map[2] = (unsigned char) 3;
map[3] = (unsigned char) 4;
map[4] = (unsigned char) 5;
}
else
{
map[0] = (unsigned char) 3;
map[1] = (unsigned char) 2;
map[2] = (unsigned char) 1;
map[3] = (unsigned char) 4;
map[4] = (unsigned char) 5;
}
break;
default:
{
//catch-all for mice with four or more than five buttons
//Without this, XSetPointerMapping is called with a undefined value
//for map
remap=0; //don't remap
}
break;
}
int retval;
if (remap)
while ((retval=XSetPointerMapping(kapp->getDisplay(), map,
num_buttons)) == MappingBusy)
/* keep trying until the pointer is free */
{ };
}
config->setGroup("Mouse");
config->writeEntry("Acceleration",accelRate);
config->writeEntry("Threshold",thresholdMove);
if (handed == RIGHT_HANDED)
config->writeEntry("MouseButtonMapping","RightHanded");
else
config->writeEntry("MouseButtonMapping","LeftHanded");
}
