Merge branch 'master' of ssh+git://idr@git.freedesktop.org/git/xorg/xserver into pci-rework
Conflicts: hw/xfree86/common/xf86Configure.c hw/xfree86/common/xf86Helper.c hw/xfree86/common/xf86pciBus.c hw/xfree86/int10/helper_exec.c hw/xfree86/os-support/bus/Pci.c hw/xfree86/os-support/bus/linuxPci.c hw/xfree86/os-support/linux/lnx_pci.c hw/xfree86/scanpci/Makefile.am hw/xfree86/utils/pcitweak/Makefile.am hw/xfree86/utils/scanpci/Makefile.am
This commit is contained in:
commit
e1f73d2208
1
.gitignore
vendored
1
.gitignore
vendored
|
@ -267,3 +267,4 @@ mfb/mfbteblack.c
|
|||
mfb/mfbtewhite.c
|
||||
mfb/mfbtileC.c
|
||||
mfb/mfbtileG.c
|
||||
.*.swp
|
||||
|
|
|
@ -28,7 +28,11 @@ INCLUDES = \
|
|||
-I$(top_srcdir)/mi
|
||||
|
||||
|
||||
nodist_libglx_la_SOURCES = indirect_size.h
|
||||
nodist_libglx_la_SOURCES = indirect_size.h \
|
||||
glapi.c \
|
||||
glcontextmodes.c \
|
||||
glcontextmode.h \
|
||||
glthread.c
|
||||
|
||||
libglxdri_la_SOURCES = \
|
||||
glxdri.c \
|
||||
|
@ -37,10 +41,6 @@ libglxdri_la_SOURCES = \
|
|||
|
||||
libglx_la_SOURCES = \
|
||||
g_disptab.h \
|
||||
glapi.c \
|
||||
glcontextmodes.c \
|
||||
glcontextmodes.h \
|
||||
glthread.c \
|
||||
glxcmds.c \
|
||||
glxcmdsswap.c \
|
||||
glxcontext.h \
|
||||
|
|
|
@ -237,7 +237,7 @@ GLboolean __glXFreeContext(__GLXcontext *cx)
|
|||
* __glXDispatch() or as a callback from the resource manager. In
|
||||
* the latter case we need to lift the DRI lock manually. */
|
||||
|
||||
if (glxBlockClients) {
|
||||
if (!glxBlockClients) {
|
||||
__glXleaveServer();
|
||||
cx->destroy(cx);
|
||||
__glXenterServer();
|
||||
|
|
|
@ -85,8 +85,6 @@ extern HIDDEN void __glXDisp_EvalCoord2fv(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_EvalCoord2fv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_SwapBuffers(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -123,6 +121,8 @@ extern HIDDEN int __glXDisp_VendorPrivate(struct __GLXclientStateRec *, GLbyte *
|
|||
extern HIDDEN int __glXDispSwap_VendorPrivate(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib1fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Vertex3iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Vertex3iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc);
|
||||
|
@ -279,6 +279,8 @@ extern HIDDEN void __glXDisp_ClearStencil(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_ClearStencil(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib3dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib3dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_ConvolutionParameteriv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ConvolutionParameteriv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_RasterPos2fv(GLbyte * pc);
|
||||
|
@ -327,6 +329,8 @@ extern HIDDEN int __glXDisp_GetVertexAttribdvNV(struct __GLXclientStateRec *, GL
|
|||
extern HIDDEN int __glXDispSwap_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Normal3fv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Normal3fv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4ivARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4ivARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_End(GLbyte * pc);
|
||||
|
@ -457,8 +461,6 @@ extern HIDDEN void __glXDisp_BindFramebufferEXT(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_BindFramebufferEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PushAttrib(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_PushAttrib(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_TexParameteriv(GLbyte * pc);
|
||||
|
@ -615,6 +617,8 @@ extern HIDDEN void __glXDisp_PrioritizeTextures(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_PrioritizeTextures(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);
|
||||
|
@ -783,8 +787,6 @@ extern HIDDEN void __glXDisp_VertexAttribs2fvNV(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Rectiv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Rectiv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib1fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_SecondaryColor3dvEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_SecondaryColor3dvEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Vertex2fv(GLbyte * pc);
|
||||
|
@ -919,8 +921,6 @@ extern HIDDEN void __glXDisp_DrawBuffersARB(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_DrawBuffersARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_LoadName(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_LoadName(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CopyTexSubImage1D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CopyTexSubImage1D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CullFace(GLbyte * pc);
|
||||
|
|
|
@ -28,7 +28,7 @@
|
|||
#include <X11/Xmd.h>
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glxproto.h>
|
||||
#ifdef __linux__
|
||||
#if defined(__linux__) || defined (__GLIBC__) || defined(__GNU__)
|
||||
#include <byteswap.h>
|
||||
#elif defined(__OpenBSD__)
|
||||
#include <sys/endian.h>
|
||||
|
|
|
@ -46,7 +46,7 @@
|
|||
#include "dispatch.h"
|
||||
#include "glapioffsets.h"
|
||||
|
||||
#ifdef __linux__
|
||||
#if defined(__linux__) || defined (__GLIBC__) || defined (__GNU__)
|
||||
#include <byteswap.h>
|
||||
#elif defined(__OpenBSD__)
|
||||
#include <sys/endian.h>
|
||||
|
|
|
@ -31,7 +31,7 @@
|
|||
#include "indirect_size.h"
|
||||
#include "indirect_reqsize.h"
|
||||
|
||||
#if defined(linux)
|
||||
#if defined(__linux__) || defined (__GLIBC__) || defined(__GNU__)
|
||||
# include <byteswap.h>
|
||||
# define SWAP_32(v) do { (v) = bswap_32(v); } while(0)
|
||||
#else
|
||||
|
|
|
@ -645,7 +645,7 @@ static const void *Render_function_table[400][2] = {
|
|||
/* [ 302] = 4182 */ {__glXDisp_RequestResidentProgramsNV, __glXDispSwap_RequestResidentProgramsNV},
|
||||
/* [ 303] = 4183 */ {__glXDisp_LoadProgramNV, __glXDispSwap_LoadProgramNV},
|
||||
/* [ 304] = 4184 */ {__glXDisp_ProgramParameter4fvNV, __glXDispSwap_ProgramParameter4fvNV},
|
||||
/* [ 305] = 4185 */ {__glXDisp_ProgramParameter4dvNV, __glXDispSwap_ProgramParameter4dvNV},
|
||||
/* [ 305] = 4185 */ {__glXDisp_ProgramEnvParameter4dvARB, __glXDispSwap_ProgramEnvParameter4dvARB},
|
||||
/* [ 306] = 4186 */ {__glXDisp_ProgramParameters4fvNV, __glXDispSwap_ProgramParameters4fvNV},
|
||||
/* [ 307] = 4187 */ {__glXDisp_ProgramParameters4dvNV, __glXDispSwap_ProgramParameters4dvNV},
|
||||
/* [ 308] = 4188 */ {__glXDisp_TrackMatrixNV, __glXDispSwap_TrackMatrixNV},
|
||||
|
@ -886,10 +886,10 @@ static const int_fast16_t Render_size_table[400][2] = {
|
|||
/* [140] = 140 */ { 0, ~0},
|
||||
/* [141] = 141 */ { 4, ~0},
|
||||
/* [142] = 142 */ { 8, ~0},
|
||||
/* [143] = 143 */ { 40, 20},
|
||||
/* [144] = 144 */ { 28, 21},
|
||||
/* [145] = 145 */ { 64, 22},
|
||||
/* [146] = 146 */ { 44, 23},
|
||||
/* [143] = 143 */ { 28, 20},
|
||||
/* [144] = 144 */ { 20, 21},
|
||||
/* [145] = 145 */ { 48, 22},
|
||||
/* [146] = 146 */ { 32, 23},
|
||||
/* [147] = 147 */ { 24, ~0},
|
||||
/* [148] = 148 */ { 16, ~0},
|
||||
/* [149] = 149 */ { 44, ~0},
|
||||
|
|
|
@ -39,7 +39,7 @@
|
|||
#include "glthread.h"
|
||||
#include "dispatch.h"
|
||||
|
||||
#ifdef __linux__
|
||||
#if defined(__linux__) || defined (__GLIBC__) || defined (__GNU__)
|
||||
#include <byteswap.h>
|
||||
#elif defined(__OpenBSD__)
|
||||
#include <sys/endian.h>
|
||||
|
|
|
@ -28,7 +28,7 @@
|
|||
#include <X11/Xmd.h>
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glxproto.h>
|
||||
#ifdef __linux__
|
||||
#if defined(__linux__) || defined (__GLIBC__) || defined(__GNU__)
|
||||
#include <byteswap.h>
|
||||
#elif defined(__OpenBSD__)
|
||||
#include <sys/endian.h>
|
||||
|
|
|
@ -40,7 +40,7 @@
|
|||
#include "dispatch.h"
|
||||
#include "glapioffsets.h"
|
||||
|
||||
#ifdef __linux__
|
||||
#if defined(__linux__) || defined (__GLIBC__) || defined (__GNU__)
|
||||
#include <byteswap.h>
|
||||
#elif defined(__OpenBSD__)
|
||||
#include <sys/endian.h>
|
||||
|
|
|
@ -60,6 +60,7 @@ nodist_libmain_la_SOURCES = accum.c \
|
|||
light.c \
|
||||
lines.c \
|
||||
matrix.c \
|
||||
mipmap.c \
|
||||
mm.c \
|
||||
occlude.c \
|
||||
pixel.c \
|
||||
|
|
|
@ -289,9 +289,9 @@ action() {
|
|||
}
|
||||
|
||||
usage() {
|
||||
echo symlink.sh src-dir dst-dir
|
||||
echo src-dir: the xc directory of the monolithic source tree
|
||||
echo dst-dir: the modular source tree containing proto, app, lib, ...
|
||||
echo symlink-mesa.sh src-dir dst-dir
|
||||
echo src-dir: the Mesa source directory
|
||||
echo dst-dir: the GL subdirectory of the Xserver modular tree
|
||||
}
|
||||
|
||||
# Check commandline args
|
||||
|
|
|
@ -26,10 +26,6 @@ if GLX
|
|||
GLX_DIR=GL
|
||||
endif
|
||||
|
||||
if XINPUT
|
||||
XINPUT_DIR=Xi
|
||||
endif
|
||||
|
||||
if DBE
|
||||
DBE_DIR=dbe
|
||||
endif
|
||||
|
@ -45,7 +41,7 @@ SUBDIRS = \
|
|||
os \
|
||||
randr \
|
||||
render \
|
||||
$(XINPUT_DIR) \
|
||||
Xi \
|
||||
xkb \
|
||||
$(DBE_DIR) \
|
||||
$(MFB_DIR) \
|
||||
|
@ -59,6 +55,7 @@ SUBDIRS = \
|
|||
$(COMPOSITE_DIR) \
|
||||
$(GLX_DIR) \
|
||||
exa \
|
||||
config \
|
||||
hw
|
||||
|
||||
aclocaldir = $(datadir)/aclocal
|
||||
|
@ -94,6 +91,7 @@ DIST_SUBDIRS = \
|
|||
composite \
|
||||
GL \
|
||||
exa \
|
||||
config \
|
||||
hw
|
||||
|
||||
# gross hack
|
||||
|
|
|
@ -1122,11 +1122,11 @@ CALLBACK(SecurityClientStateCallback)
|
|||
switch (client->clientState)
|
||||
{
|
||||
case ClientStateInitial:
|
||||
TRUSTLEVEL(serverClient) = XSecurityClientTrusted;
|
||||
AUTHID(serverClient) = None;
|
||||
TRUSTLEVEL(client) = XSecurityClientTrusted;
|
||||
AUTHID(client) = None;
|
||||
break;
|
||||
|
||||
case ClientStateRunning:
|
||||
case ClientStateRunning:
|
||||
{
|
||||
XID authId = AuthorizationIDOfClient(client);
|
||||
SecurityAuthorizationPtr pAuth;
|
||||
|
@ -1146,8 +1146,8 @@ CALLBACK(SecurityClientStateCallback)
|
|||
}
|
||||
break;
|
||||
}
|
||||
case ClientStateGone:
|
||||
case ClientStateRetained: /* client disconnected */
|
||||
case ClientStateGone:
|
||||
case ClientStateRetained: /* client disconnected */
|
||||
{
|
||||
SecurityAuthorizationPtr pAuth;
|
||||
|
||||
|
@ -1167,7 +1167,7 @@ CALLBACK(SecurityClientStateCallback)
|
|||
}
|
||||
break;
|
||||
}
|
||||
default: break;
|
||||
default: break;
|
||||
}
|
||||
} /* SecurityClientStateCallback */
|
||||
|
||||
|
@ -1251,7 +1251,7 @@ typedef struct _PropertyAccessRec {
|
|||
} PropertyAccessRec, *PropertyAccessPtr;
|
||||
|
||||
static PropertyAccessPtr PropertyAccessList = NULL;
|
||||
static char SecurityDefaultAction = SecurityErrorOperation;
|
||||
static char SecurityDefaultAction = XaceErrorOperation;
|
||||
static char *SecurityPolicyFile = DEFAULTPOLICYFILE;
|
||||
static ATOM SecurityMaxPropertyName = 0;
|
||||
|
||||
|
@ -1410,9 +1410,9 @@ SecurityParsePropertyAccessRule(
|
|||
{
|
||||
switch (c)
|
||||
{
|
||||
case 'i': action = SecurityIgnoreOperation; break;
|
||||
case 'a': action = SecurityAllowOperation; break;
|
||||
case 'e': action = SecurityErrorOperation; break;
|
||||
case 'i': action = XaceIgnoreOperation; break;
|
||||
case 'a': action = XaceAllowOperation; break;
|
||||
case 'e': action = XaceErrorOperation; break;
|
||||
|
||||
case 'r': readAction = action; break;
|
||||
case 'w': writeAction = action; break;
|
||||
|
@ -1797,7 +1797,7 @@ CALLBACK(SecurityCheckPropertyAccess)
|
|||
* If pacl doesn't apply, something above should have
|
||||
* executed a continue, which will skip the follwing code.
|
||||
*/
|
||||
action = SecurityAllowOperation;
|
||||
action = XaceAllowOperation;
|
||||
if (access_mode & SecurityReadAccess)
|
||||
action = max(action, pacl->readAction);
|
||||
if (access_mode & SecurityWriteAccess)
|
||||
|
@ -1808,11 +1808,11 @@ CALLBACK(SecurityCheckPropertyAccess)
|
|||
} /* end for each pacl */
|
||||
} /* end if propertyName <= SecurityMaxPropertyName */
|
||||
|
||||
if (SecurityAllowOperation != action)
|
||||
if (XaceAllowOperation != action)
|
||||
{ /* audit the access violation */
|
||||
int cid = CLIENT_ID(pWin->drawable.id);
|
||||
int reqtype = ((xReq *)client->requestBuffer)->reqType;
|
||||
char *actionstr = (SecurityIgnoreOperation == action) ?
|
||||
char *actionstr = (XaceIgnoreOperation == action) ?
|
||||
"ignored" : "error";
|
||||
SecurityAudit("client %d attempted request %d with window 0x%x property %s (atom 0x%x) of client %d, %s\n",
|
||||
client->index, reqtype, pWin->drawable.id,
|
||||
|
|
|
@ -99,7 +99,7 @@ int XaceHook(int hook, ...)
|
|||
va_arg(ap, WindowPtr),
|
||||
va_arg(ap, Atom),
|
||||
va_arg(ap, Mask),
|
||||
SecurityAllowOperation /* default allow */
|
||||
XaceAllowOperation /* default allow */
|
||||
};
|
||||
calldata = &rec;
|
||||
prv = &rec.rval;
|
||||
|
@ -406,12 +406,14 @@ XaceCensorImage(client, pVisibleRegion, widthBytesLine, pDraw, x, y, w, h,
|
|||
unsigned int format;
|
||||
char * pBuf;
|
||||
{
|
||||
ScreenPtr pScreen = pDraw->pScreen;
|
||||
ScreenPtr pScreen;
|
||||
RegionRec imageRegion; /* region representing x,y,w,h */
|
||||
RegionRec censorRegion; /* region to obliterate */
|
||||
BoxRec imageBox;
|
||||
int nRects;
|
||||
|
||||
pScreen = pDraw->pScreen;
|
||||
|
||||
imageBox.x1 = x;
|
||||
imageBox.y1 = y;
|
||||
imageBox.x2 = x + w;
|
||||
|
|
26
Xext/xace.h
26
Xext/xace.h
|
@ -20,6 +20,13 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|||
#ifndef _XACE_H
|
||||
#define _XACE_H
|
||||
|
||||
/* Hook return codes */
|
||||
#define XaceErrorOperation 0
|
||||
#define XaceAllowOperation 1
|
||||
#define XaceIgnoreOperation 2
|
||||
|
||||
#ifdef XACE
|
||||
|
||||
#define XACE_EXTENSION_NAME "XAccessControlExtension"
|
||||
#define XACE_MAJOR_VERSION 1
|
||||
#define XACE_MINOR_VERSION 0
|
||||
|
@ -75,11 +82,6 @@ extern int XaceHook(
|
|||
/* From the original Security extension...
|
||||
*/
|
||||
|
||||
/* Hook return codes */
|
||||
#define SecurityAllowOperation 0
|
||||
#define SecurityIgnoreOperation 1
|
||||
#define SecurityErrorOperation 2
|
||||
|
||||
/* Proc vectors for untrusted clients, swapped and unswapped versions.
|
||||
* These are the same as the normal proc vectors except that extensions
|
||||
* that haven't declared themselves secure will have ProcBadRequest plugged
|
||||
|
@ -100,4 +102,18 @@ extern void XaceCensorImage(
|
|||
char * pBuf
|
||||
);
|
||||
|
||||
#else /* XACE */
|
||||
|
||||
/* Define calls away when XACE is not being built. */
|
||||
|
||||
#ifdef __GNUC__
|
||||
#define XaceHook(args...) XaceAllowOperation
|
||||
#define XaceCensorImage(args...) { ; }
|
||||
#else
|
||||
#define XaceHook(...) XaceAllowOperation
|
||||
#define XaceCensorImage(...) { ; }
|
||||
#endif
|
||||
|
||||
#endif /* XACE */
|
||||
|
||||
#endif /* _XACE_H */
|
||||
|
|
146
Xi/chgdctl.c
146
Xi/chgdctl.c
|
@ -66,6 +66,7 @@ SOFTWARE.
|
|||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
#include "exevents.h"
|
||||
|
||||
#include "chgdctl.h"
|
||||
|
||||
|
@ -98,12 +99,17 @@ int
|
|||
ProcXChangeDeviceControl(ClientPtr client)
|
||||
{
|
||||
unsigned len;
|
||||
int i, status;
|
||||
int i, status, ret = BadValue;
|
||||
DeviceIntPtr dev;
|
||||
xDeviceResolutionCtl *r;
|
||||
xChangeDeviceControlReply rep;
|
||||
AxisInfoPtr a;
|
||||
CARD32 *resolution;
|
||||
xDeviceAbsCalibCtl *calib;
|
||||
xDeviceAbsAreaCtl *area;
|
||||
xDeviceCoreCtl *c;
|
||||
xDeviceEnableCtl *e;
|
||||
devicePresenceNotify dpn;
|
||||
|
||||
REQUEST(xChangeDeviceControlReq);
|
||||
REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq);
|
||||
|
@ -111,9 +117,8 @@ ProcXChangeDeviceControl(ClientPtr client)
|
|||
len = stuff->length - (sizeof(xChangeDeviceControlReq) >> 2);
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
ret = BadDevice;
|
||||
goto out;
|
||||
}
|
||||
|
||||
rep.repType = X_Reply;
|
||||
|
@ -126,25 +131,22 @@ ProcXChangeDeviceControl(ClientPtr client)
|
|||
r = (xDeviceResolutionCtl *) & stuff[1];
|
||||
if ((len < (sizeof(xDeviceResolutionCtl) >> 2)) ||
|
||||
(len != (sizeof(xDeviceResolutionCtl) >> 2) + r->num_valuators)) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl,
|
||||
0, BadLength);
|
||||
return Success;
|
||||
ret = BadLength;
|
||||
goto out;
|
||||
}
|
||||
if (!dev->valuator) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
ret = BadMatch;
|
||||
goto out;
|
||||
}
|
||||
if ((dev->grab) && !SameClient(dev->grab, client)) {
|
||||
rep.status = AlreadyGrabbed;
|
||||
WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
|
||||
return Success;
|
||||
ret = Success;
|
||||
goto out;
|
||||
}
|
||||
resolution = (CARD32 *) (r + 1);
|
||||
if (r->first_valuator + r->num_valuators > dev->valuator->numAxes) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
ret = BadValue;
|
||||
goto out;
|
||||
}
|
||||
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) r);
|
||||
if (status == Success) {
|
||||
|
@ -158,21 +160,119 @@ ProcXChangeDeviceControl(ClientPtr client)
|
|||
}
|
||||
for (i = 0; i < r->num_valuators; i++)
|
||||
(a++)->resolution = *resolution++;
|
||||
|
||||
ret = Success;
|
||||
} else if (status == DeviceBusy) {
|
||||
rep.status = DeviceBusy;
|
||||
WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
|
||||
return Success;
|
||||
ret = Success;
|
||||
} else {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
ret = BadMatch;
|
||||
}
|
||||
break;
|
||||
case DEVICE_ABS_CALIB:
|
||||
calib = (xDeviceAbsCalibCtl *)&stuff[1];
|
||||
|
||||
if (calib->button_threshold < 0 || calib->button_threshold > 255) {
|
||||
ret = BadValue;
|
||||
goto out;
|
||||
}
|
||||
|
||||
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) calib);
|
||||
|
||||
if (status == Success) {
|
||||
dev->absolute->min_x = calib->min_x;
|
||||
dev->absolute->max_x = calib->max_x;
|
||||
dev->absolute->min_y = calib->min_y;
|
||||
dev->absolute->max_y = calib->max_y;
|
||||
dev->absolute->flip_x = calib->flip_x;
|
||||
dev->absolute->flip_y = calib->flip_y;
|
||||
dev->absolute->rotation = calib->rotation;
|
||||
dev->absolute->button_threshold = calib->button_threshold;
|
||||
ret = Success;
|
||||
} else if (status == DeviceBusy || status == BadValue) {
|
||||
rep.status = status;
|
||||
ret = Success;
|
||||
} else {
|
||||
ret = BadMatch;
|
||||
}
|
||||
|
||||
break;
|
||||
case DEVICE_ABS_AREA:
|
||||
area = (xDeviceAbsAreaCtl *)&stuff[1];
|
||||
|
||||
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) area);
|
||||
|
||||
if (status == Success) {
|
||||
dev->absolute->offset_x = area->offset_x;
|
||||
dev->absolute->offset_y = area->offset_y;
|
||||
dev->absolute->width = area->width;
|
||||
dev->absolute->height = area->height;
|
||||
dev->absolute->screen = area->screen;
|
||||
dev->absolute->following = area->following;
|
||||
ret = Success;
|
||||
} else if (status == DeviceBusy || status == BadValue) {
|
||||
rep.status = status;
|
||||
ret = Success;
|
||||
} else {
|
||||
ret = Success;
|
||||
}
|
||||
|
||||
break;
|
||||
case DEVICE_CORE:
|
||||
c = (xDeviceCoreCtl *)&stuff[1];
|
||||
|
||||
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) c);
|
||||
|
||||
if (status == Success) {
|
||||
dev->coreEvents = c->status;
|
||||
ret = Success;
|
||||
} else if (status == DeviceBusy) {
|
||||
rep.status = DeviceBusy;
|
||||
ret = Success;
|
||||
} else {
|
||||
ret = BadMatch;
|
||||
}
|
||||
|
||||
break;
|
||||
case DEVICE_ENABLE:
|
||||
e = (xDeviceEnableCtl *)&stuff[1];
|
||||
|
||||
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) e);
|
||||
|
||||
if (status == Success) {
|
||||
if (e->enable)
|
||||
EnableDevice(dev);
|
||||
else
|
||||
DisableDevice(dev);
|
||||
ret = Success;
|
||||
} else if (status == DeviceBusy) {
|
||||
rep.status = DeviceBusy;
|
||||
ret = Success;
|
||||
} else {
|
||||
ret = BadMatch;
|
||||
}
|
||||
|
||||
break;
|
||||
default:
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0, BadValue);
|
||||
return Success;
|
||||
ret = BadValue;
|
||||
}
|
||||
WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
|
||||
|
||||
out:
|
||||
if (ret == Success) {
|
||||
dpn.type = DevicePresenceNotify;
|
||||
dpn.time = currentTime.milliseconds;
|
||||
dpn.devchange = 1;
|
||||
dpn.deviceid = dev->id;
|
||||
dpn.control = stuff->control;
|
||||
SendEventToAllWindows(dev, DevicePresenceNotifyMask,
|
||||
(xEvent *) &dpn, 1);
|
||||
|
||||
WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
|
||||
}
|
||||
else {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0, ret);
|
||||
}
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
|
|
102
Xi/chgkbd.c
102
Xi/chgkbd.c
|
@ -64,7 +64,6 @@ SOFTWARE.
|
|||
#include "XIstubs.h"
|
||||
#include "globals.h"
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
|
||||
#include "exevents.h"
|
||||
#include "exglobals.h"
|
||||
|
@ -99,107 +98,10 @@ SProcXChangeKeyboardDevice(register ClientPtr client)
|
|||
int
|
||||
ProcXChangeKeyboardDevice(register ClientPtr client)
|
||||
{
|
||||
int i;
|
||||
DeviceIntPtr xkbd = inputInfo.keyboard;
|
||||
DeviceIntPtr dev;
|
||||
FocusClassPtr xf = xkbd->focus;
|
||||
FocusClassPtr df;
|
||||
KeyClassPtr k;
|
||||
xChangeKeyboardDeviceReply rep;
|
||||
changeDeviceNotify ev;
|
||||
|
||||
REQUEST(xChangeKeyboardDeviceReq);
|
||||
REQUEST_SIZE_MATCH(xChangeKeyboardDeviceReq);
|
||||
|
||||
rep.repType = X_Reply;
|
||||
rep.RepType = X_ChangeKeyboardDevice;
|
||||
rep.length = 0;
|
||||
rep.sequenceNumber = client->sequence;
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
rep.status = -1;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
|
||||
k = dev->key;
|
||||
if (k == NULL) {
|
||||
rep.status = -1;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
}
|
||||
|
||||
if (((dev->grab) && !SameClient(dev->grab, client)) ||
|
||||
((xkbd->grab) && !SameClient(xkbd->grab, client)))
|
||||
rep.status = AlreadyGrabbed;
|
||||
else if ((dev->sync.frozen &&
|
||||
dev->sync.other && !SameClient(dev->sync.other, client)) ||
|
||||
(xkbd->sync.frozen &&
|
||||
xkbd->sync.other && !SameClient(xkbd->sync.other, client)))
|
||||
rep.status = GrabFrozen;
|
||||
else {
|
||||
if (ChangeKeyboardDevice(xkbd, dev) != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (!dev->focus)
|
||||
InitFocusClassDeviceStruct(dev);
|
||||
if (!dev->kbdfeed)
|
||||
InitKbdFeedbackClassDeviceStruct(dev, (BellProcPtr) NoopDDA,
|
||||
(KbdCtrlProcPtr) NoopDDA);
|
||||
df = dev->focus;
|
||||
df->win = xf->win;
|
||||
df->revert = xf->revert;
|
||||
df->time = xf->time;
|
||||
df->traceGood = xf->traceGood;
|
||||
if (df->traceSize != xf->traceSize) {
|
||||
Must_have_memory = TRUE; /* XXX */
|
||||
df->trace = (WindowPtr *) xrealloc(df->trace,
|
||||
xf->traceSize *
|
||||
sizeof(WindowPtr));
|
||||
Must_have_memory = FALSE; /* XXX */
|
||||
}
|
||||
df->traceSize = xf->traceSize;
|
||||
for (i = 0; i < df->traceSize; i++)
|
||||
df->trace[i] = xf->trace[i];
|
||||
RegisterOtherDevice(xkbd);
|
||||
RegisterKeyboardDevice(dev);
|
||||
|
||||
ev.type = ChangeDeviceNotify;
|
||||
ev.deviceid = stuff->deviceid;
|
||||
ev.time = currentTime.milliseconds;
|
||||
ev.request = NewKeyboard;
|
||||
|
||||
SendEventToAllWindows(dev, ChangeDeviceNotifyMask, (xEvent *) & ev, 1);
|
||||
SendMappingNotify(MappingKeyboard, k->curKeySyms.minKeyCode,
|
||||
k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode +
|
||||
1, client);
|
||||
|
||||
rep.status = 0;
|
||||
}
|
||||
|
||||
WriteReplyToClient(client, sizeof(xChangeKeyboardDeviceReply), &rep);
|
||||
SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* This procedure writes the reply for the XChangeKeyboardDevice
|
||||
* function, if the client and server have a different byte ordering.
|
||||
*
|
||||
*/
|
||||
|
||||
void
|
||||
SRepXChangeKeyboardDevice(ClientPtr client, int size,
|
||||
xChangeKeyboardDeviceReply * rep)
|
||||
{
|
||||
register char n;
|
||||
|
||||
swaps(&rep->sequenceNumber, n);
|
||||
swapl(&rep->length, n);
|
||||
WriteToClient(client, size, (char *)rep);
|
||||
}
|
||||
|
|
|
@ -36,9 +36,4 @@ int SProcXChangeKeyboardDevice(ClientPtr /* client */
|
|||
int ProcXChangeKeyboardDevice(ClientPtr /* client */
|
||||
);
|
||||
|
||||
void SRepXChangeKeyboardDevice(ClientPtr /* client */ ,
|
||||
int /* size */ ,
|
||||
xChangeKeyboardDeviceReply * /* rep */
|
||||
);
|
||||
|
||||
#endif /* CHGKBD_H */
|
||||
|
|
132
Xi/chgptr.c
132
Xi/chgptr.c
|
@ -101,138 +101,10 @@ SProcXChangePointerDevice(register ClientPtr client)
|
|||
int
|
||||
ProcXChangePointerDevice(register ClientPtr client)
|
||||
{
|
||||
DeviceIntPtr xptr = inputInfo.pointer;
|
||||
DeviceIntPtr dev;
|
||||
ValuatorClassPtr v;
|
||||
xChangePointerDeviceReply rep;
|
||||
changeDeviceNotify ev;
|
||||
|
||||
REQUEST(xChangePointerDeviceReq);
|
||||
REQUEST_SIZE_MATCH(xChangePointerDeviceReq);
|
||||
|
||||
rep.repType = X_Reply;
|
||||
rep.RepType = X_ChangePointerDevice;
|
||||
rep.length = 0;
|
||||
rep.sequenceNumber = client->sequence;
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
rep.status = -1;
|
||||
SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
|
||||
v = dev->valuator;
|
||||
if (v == NULL || v->numAxes < 2 ||
|
||||
stuff->xaxis >= v->numAxes || stuff->yaxis >= v->numAxes) {
|
||||
rep.status = -1;
|
||||
SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0, BadMatch);
|
||||
return Success;
|
||||
}
|
||||
|
||||
if (((dev->grab) && !SameClient(dev->grab, client)) ||
|
||||
((xptr->grab) && !SameClient(xptr->grab, client)))
|
||||
rep.status = AlreadyGrabbed;
|
||||
else if ((dev->sync.frozen &&
|
||||
dev->sync.other && !SameClient(dev->sync.other, client)) ||
|
||||
(xptr->sync.frozen &&
|
||||
xptr->sync.other && !SameClient(xptr->sync.other, client)))
|
||||
rep.status = GrabFrozen;
|
||||
else {
|
||||
if (ChangePointerDevice(xptr, dev, stuff->xaxis, stuff->yaxis) !=
|
||||
Success) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev->focus)
|
||||
DeleteFocusClassDeviceStruct(dev);
|
||||
if (!dev->button)
|
||||
InitButtonClassDeviceStruct(dev, 0, NULL);
|
||||
if (!dev->ptrfeed)
|
||||
InitPtrFeedbackClassDeviceStruct(dev, (PtrCtrlProcPtr) NoopDDA);
|
||||
RegisterOtherDevice(xptr);
|
||||
RegisterPointerDevice(dev);
|
||||
|
||||
ev.type = ChangeDeviceNotify;
|
||||
ev.deviceid = stuff->deviceid;
|
||||
ev.time = currentTime.milliseconds;
|
||||
ev.request = NewPointer;
|
||||
|
||||
SendEventToAllWindows(dev, ChangeDeviceNotifyMask, (xEvent *) & ev, 1);
|
||||
SendMappingNotify(MappingPointer, 0, 0, client);
|
||||
|
||||
rep.status = 0;
|
||||
}
|
||||
|
||||
WriteReplyToClient(client, sizeof(xChangePointerDeviceReply), &rep);
|
||||
SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
|
||||
void
|
||||
DeleteFocusClassDeviceStruct(DeviceIntPtr dev)
|
||||
{
|
||||
xfree(dev->focus->trace);
|
||||
xfree(dev->focus);
|
||||
dev->focus = NULL;
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Send an event to interested clients in all windows on all screens.
|
||||
*
|
||||
*/
|
||||
|
||||
void
|
||||
SendEventToAllWindows(DeviceIntPtr dev, Mask mask, xEvent * ev, int count)
|
||||
{
|
||||
int i;
|
||||
WindowPtr pWin, p1;
|
||||
|
||||
for (i = 0; i < screenInfo.numScreens; i++) {
|
||||
pWin = WindowTable[i];
|
||||
(void)DeliverEventsToWindow(pWin, ev, count, mask, NullGrab, dev->id);
|
||||
p1 = pWin->firstChild;
|
||||
FindInterestedChildren(dev, p1, mask, ev, count);
|
||||
}
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Walk through the window tree, finding all clients that want to know
|
||||
* about the ChangeDeviceNotify Event.
|
||||
*
|
||||
*/
|
||||
|
||||
void
|
||||
FindInterestedChildren(DeviceIntPtr dev, WindowPtr p1, Mask mask,
|
||||
xEvent * ev, int count)
|
||||
{
|
||||
WindowPtr p2;
|
||||
|
||||
while (p1) {
|
||||
p2 = p1->firstChild;
|
||||
(void)DeliverEventsToWindow(p1, ev, count, mask, NullGrab, dev->id);
|
||||
FindInterestedChildren(dev, p2, mask, ev, count);
|
||||
p1 = p1->nextSib;
|
||||
}
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* This procedure writes the reply for the XChangePointerDevice
|
||||
* function, if the client and server have a different byte ordering.
|
||||
*
|
||||
*/
|
||||
|
||||
void
|
||||
SRepXChangePointerDevice(ClientPtr client, int size,
|
||||
xChangePointerDeviceReply * rep)
|
||||
{
|
||||
register char n;
|
||||
|
||||
swaps(&rep->sequenceNumber, n);
|
||||
swapl(&rep->length, n);
|
||||
WriteToClient(client, size, (char *)rep);
|
||||
}
|
||||
|
|
|
@ -53,9 +53,4 @@ void FindInterestedChildren( /* FIXME: could be static? */
|
|||
int /* count */
|
||||
);
|
||||
|
||||
void SRepXChangePointerDevice(ClientPtr /* client */ ,
|
||||
int /* size */ ,
|
||||
xChangePointerDeviceReply * /* rep */
|
||||
);
|
||||
|
||||
#endif /* CHGPTR_H */
|
||||
|
|
|
@ -71,8 +71,7 @@ SOFTWARE.
|
|||
#include "exglobals.h"
|
||||
#include "dixevents.h" /* DeliverFocusedEvent */
|
||||
#include "dixgrabs.h" /* CreateGrab() */
|
||||
|
||||
#include "chgptr.h"
|
||||
#include "scrnintstr.h"
|
||||
|
||||
#define WID(w) ((w) ? ((w)->drawable.id) : 0)
|
||||
#define AllModifiersMask ( \
|
||||
|
@ -302,7 +301,12 @@ _X_EXPORT void
|
|||
InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, int minval, int maxval,
|
||||
int resolution, int min_res, int max_res)
|
||||
{
|
||||
register AxisInfoPtr ax = dev->valuator->axes + axnum;
|
||||
register AxisInfoPtr ax;
|
||||
|
||||
if (!dev || !dev->valuator)
|
||||
return;
|
||||
|
||||
ax = dev->valuator->axes + axnum;
|
||||
|
||||
ax->min_value = minval;
|
||||
ax->max_value = maxval;
|
||||
|
@ -898,7 +902,7 @@ SetModifierMapping(ClientPtr client, DeviceIntPtr dev, int len, int rlen,
|
|||
return MappingBusy;
|
||||
} else {
|
||||
for (i = 0; i < inputMapLen; i++) {
|
||||
if (inputMap[i] && !LegalModifier(inputMap[i], (DevicePtr) dev)) {
|
||||
if (inputMap[i] && !LegalModifier(inputMap[i], dev)) {
|
||||
return MappingFailed;
|
||||
}
|
||||
}
|
||||
|
@ -1209,3 +1213,44 @@ ShouldFreeInputMasks(WindowPtr pWin, Bool ignoreSelectedEvents)
|
|||
else
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Walk through the window tree, finding all clients that want to know
|
||||
* about the Event.
|
||||
*
|
||||
*/
|
||||
|
||||
void
|
||||
FindInterestedChildren(DeviceIntPtr dev, WindowPtr p1, Mask mask,
|
||||
xEvent * ev, int count)
|
||||
{
|
||||
WindowPtr p2;
|
||||
|
||||
while (p1) {
|
||||
p2 = p1->firstChild;
|
||||
(void)DeliverEventsToWindow(p1, ev, count, mask, NullGrab, dev->id);
|
||||
FindInterestedChildren(dev, p2, mask, ev, count);
|
||||
p1 = p1->nextSib;
|
||||
}
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Send an event to interested clients in all windows on all screens.
|
||||
*
|
||||
*/
|
||||
|
||||
void
|
||||
SendEventToAllWindows(DeviceIntPtr dev, Mask mask, xEvent * ev, int count)
|
||||
{
|
||||
int i;
|
||||
WindowPtr pWin, p1;
|
||||
|
||||
for (i = 0; i < screenInfo.numScreens; i++) {
|
||||
pWin = WindowTable[i];
|
||||
(void)DeliverEventsToWindow(pWin, ev, count, mask, NullGrab, dev->id);
|
||||
p1 = pWin->firstChild;
|
||||
FindInterestedChildren(dev, p1, mask, ev, count);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -51,6 +51,7 @@ extern Mask DeviceMappingNotifyMask;
|
|||
extern Mask DeviceOwnerGrabButtonMask;
|
||||
extern Mask DeviceButtonGrabMask;
|
||||
extern Mask DeviceButtonMotionMask;
|
||||
extern Mask DevicePresenceNotifyMask;
|
||||
extern Mask PropagateMask[];
|
||||
|
||||
extern int DeviceValuator;
|
||||
|
@ -68,12 +69,8 @@ extern int DeviceKeyStateNotify;
|
|||
extern int DeviceButtonStateNotify;
|
||||
extern int DeviceMappingNotify;
|
||||
extern int ChangeDeviceNotify;
|
||||
extern int DevicePresenceNotify;
|
||||
|
||||
extern int RT_INPUTCLIENT;
|
||||
|
||||
#if 0
|
||||
/* FIXME: in dix */
|
||||
extern InputInfo inputInfo;
|
||||
#endif
|
||||
|
||||
#endif /* EXGLOBALS_H */
|
||||
|
|
46
Xi/extinit.c
46
Xi/extinit.c
|
@ -166,6 +166,7 @@ Mask DeviceMappingNotifyMask;
|
|||
Mask DeviceOwnerGrabButtonMask;
|
||||
Mask DeviceButtonGrabMask;
|
||||
Mask DeviceButtonMotionMask;
|
||||
Mask DevicePresenceNotifyMask;
|
||||
|
||||
int DeviceValuator;
|
||||
int DeviceKeyPress;
|
||||
|
@ -182,6 +183,7 @@ int DeviceKeyStateNotify;
|
|||
int DeviceButtonStateNotify;
|
||||
int DeviceMappingNotify;
|
||||
int ChangeDeviceNotify;
|
||||
int DevicePresenceNotify;
|
||||
|
||||
int RT_INPUTCLIENT;
|
||||
|
||||
|
@ -202,8 +204,8 @@ Mask PropagateMask[MAX_DEVICES];
|
|||
*/
|
||||
|
||||
static XExtensionVersion thisversion = { XI_Present,
|
||||
XI_Add_XChangeDeviceControl_Major,
|
||||
XI_Add_XChangeDeviceControl_Minor
|
||||
XI_Add_DevicePresenceNotify_Major,
|
||||
XI_Add_DevicePresenceNotify_Minor
|
||||
};
|
||||
|
||||
/**********************************************************************
|
||||
|
@ -463,12 +465,6 @@ SReplyIDispatch(ClientPtr client, int len, xGrabDeviceReply * rep)
|
|||
else if (rep->RepType == X_GetDeviceMotionEvents)
|
||||
SRepXGetDeviceMotionEvents(client, len,
|
||||
(xGetDeviceMotionEventsReply *) rep);
|
||||
else if (rep->RepType == X_ChangeKeyboardDevice)
|
||||
SRepXChangeKeyboardDevice(client, len,
|
||||
(xChangeKeyboardDeviceReply *) rep);
|
||||
else if (rep->RepType == X_ChangePointerDevice)
|
||||
SRepXChangePointerDevice(client, len,
|
||||
(xChangePointerDeviceReply *) rep);
|
||||
else if (rep->RepType == X_GrabDevice)
|
||||
SRepXGrabDevice(client, len, (xGrabDeviceReply *) rep);
|
||||
else if (rep->RepType == X_GetDeviceFocus)
|
||||
|
@ -648,6 +644,17 @@ SDeviceMappingNotifyEvent(deviceMappingNotify * from, deviceMappingNotify * to)
|
|||
swapl(&to->time, n);
|
||||
}
|
||||
|
||||
void
|
||||
SDevicePresenceNotifyEvent (devicePresenceNotify *from, devicePresenceNotify *to)
|
||||
{
|
||||
register char n;
|
||||
|
||||
*to = *from;
|
||||
swaps(&to->sequenceNumber,n);
|
||||
swapl(&to->time, n);
|
||||
swaps(&to->control, n);
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
*
|
||||
* This function sets up extension event types and masks.
|
||||
|
@ -674,6 +681,7 @@ FixExtensionEvents(ExtensionEntry * extEntry)
|
|||
ChangeDeviceNotify = DeviceMappingNotify + 1;
|
||||
DeviceKeyStateNotify = ChangeDeviceNotify + 1;
|
||||
DeviceButtonStateNotify = DeviceKeyStateNotify + 1;
|
||||
DevicePresenceNotify = DeviceButtonStateNotify + 1;
|
||||
|
||||
event_base[KeyClass] = DeviceKeyPress;
|
||||
event_base[ButtonClass] = DeviceButtonPress;
|
||||
|
@ -746,6 +754,9 @@ FixExtensionEvents(ExtensionEntry * extEntry)
|
|||
|
||||
DeviceOwnerGrabButtonMask = GetNextExtEventMask();
|
||||
SetEventInfo(DeviceOwnerGrabButtonMask, _deviceOwnerGrabButton);
|
||||
|
||||
DevicePresenceNotifyMask = GetNextExtEventMask();
|
||||
SetEventInfo(DevicePresenceNotifyMask, _devicePresence);
|
||||
SetEventInfo(0, _noExtensionEvent);
|
||||
}
|
||||
|
||||
|
@ -786,6 +797,7 @@ RestoreExtensionEvents(void)
|
|||
ChangeDeviceNotify = 12;
|
||||
DeviceKeyStateNotify = 13;
|
||||
DeviceButtonStateNotify = 13;
|
||||
DevicePresenceNotify = 14;
|
||||
|
||||
BadDevice = 0;
|
||||
BadEvent = 1;
|
||||
|
@ -823,6 +835,7 @@ IResetProc(ExtensionEntry * unused)
|
|||
EventSwapVector[DeviceButtonStateNotify] = NotImplemented;
|
||||
EventSwapVector[DeviceMappingNotify] = NotImplemented;
|
||||
EventSwapVector[ChangeDeviceNotify] = NotImplemented;
|
||||
EventSwapVector[DevicePresenceNotify] = NotImplemented;
|
||||
RestoreExtensionEvents();
|
||||
}
|
||||
|
||||
|
@ -857,9 +870,7 @@ MakeDeviceTypeAtoms(void)
|
|||
}
|
||||
|
||||
/**************************************************************************
|
||||
*
|
||||
* Return a DeviceIntPtr corresponding to a specified device id.
|
||||
* This will not return the pointer or keyboard, or devices that are not on.
|
||||
*
|
||||
*/
|
||||
|
||||
|
@ -869,13 +880,16 @@ LookupDeviceIntRec(CARD8 id)
|
|||
DeviceIntPtr dev;
|
||||
|
||||
for (dev = inputInfo.devices; dev; dev = dev->next) {
|
||||
if (dev->id == id) {
|
||||
if (id == inputInfo.pointer->id || id == inputInfo.keyboard->id)
|
||||
return (NULL);
|
||||
return (dev);
|
||||
}
|
||||
if (dev->id == id)
|
||||
return dev;
|
||||
}
|
||||
return (NULL);
|
||||
|
||||
for (dev = inputInfo.off_devices; dev; dev = dev->next) {
|
||||
if (dev->id == id)
|
||||
return dev;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**************************************************************************
|
||||
|
|
128
Xi/getdctl.c
128
Xi/getdctl.c
|
@ -124,6 +124,30 @@ ProcXGetDeviceControl(ClientPtr client)
|
|||
total_length = sizeof(xDeviceResolutionState) +
|
||||
(3 * sizeof(int) * dev->valuator->numAxes);
|
||||
break;
|
||||
case DEVICE_ABS_CALIB:
|
||||
if (!dev->absolute) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
}
|
||||
|
||||
total_length = sizeof(xDeviceAbsCalibCtl);
|
||||
break;
|
||||
case DEVICE_ABS_AREA:
|
||||
if (!dev->absolute) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
}
|
||||
|
||||
total_length = sizeof(xDeviceAbsAreaCtl);
|
||||
break;
|
||||
case DEVICE_CORE:
|
||||
total_length = sizeof(xDeviceCoreCtl);
|
||||
break;
|
||||
case DEVICE_ENABLE:
|
||||
total_length = sizeof(xDeviceEnableCtl);
|
||||
break;
|
||||
default:
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadValue);
|
||||
return Success;
|
||||
|
@ -140,6 +164,18 @@ ProcXGetDeviceControl(ClientPtr client)
|
|||
case DEVICE_RESOLUTION:
|
||||
CopySwapDeviceResolution(client, dev->valuator, buf, total_length);
|
||||
break;
|
||||
case DEVICE_ABS_CALIB:
|
||||
CopySwapDeviceAbsCalib(client, dev->absolute, buf);
|
||||
break;
|
||||
case DEVICE_ABS_AREA:
|
||||
CopySwapDeviceAbsArea(client, dev->absolute, buf);
|
||||
break;
|
||||
case DEVICE_CORE:
|
||||
CopySwapDeviceCore(client, dev, buf);
|
||||
break;
|
||||
case DEVICE_ENABLE:
|
||||
CopySwapDeviceEnable(client, dev, buf);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
@ -189,6 +225,98 @@ CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf,
|
|||
}
|
||||
}
|
||||
|
||||
void CopySwapDeviceAbsCalib (ClientPtr client, AbsoluteClassPtr dts,
|
||||
char *buf)
|
||||
{
|
||||
register char n;
|
||||
xDeviceAbsCalibState *calib = (xDeviceAbsCalibState *) buf;
|
||||
|
||||
calib->control = DEVICE_ABS_CALIB;
|
||||
calib->length = sizeof(calib);
|
||||
calib->min_x = dts->min_x;
|
||||
calib->max_x = dts->max_x;
|
||||
calib->min_y = dts->min_y;
|
||||
calib->max_y = dts->max_y;
|
||||
calib->flip_x = dts->flip_x;
|
||||
calib->flip_y = dts->flip_y;
|
||||
calib->rotation = dts->rotation;
|
||||
calib->button_threshold = dts->button_threshold;
|
||||
|
||||
if (client->swapped) {
|
||||
swaps(&calib->control, n);
|
||||
swaps(&calib->length, n);
|
||||
swapl(&calib->min_x, n);
|
||||
swapl(&calib->max_x, n);
|
||||
swapl(&calib->min_y, n);
|
||||
swapl(&calib->max_y, n);
|
||||
swapl(&calib->flip_x, n);
|
||||
swapl(&calib->flip_y, n);
|
||||
swapl(&calib->rotation, n);
|
||||
swapl(&calib->button_threshold, n);
|
||||
}
|
||||
}
|
||||
|
||||
void CopySwapDeviceAbsArea (ClientPtr client, AbsoluteClassPtr dts,
|
||||
char *buf)
|
||||
{
|
||||
register char n;
|
||||
xDeviceAbsAreaState *area = (xDeviceAbsAreaState *) buf;
|
||||
|
||||
area->control = DEVICE_ABS_AREA;
|
||||
area->length = sizeof(area);
|
||||
area->offset_x = dts->offset_x;
|
||||
area->offset_y = dts->offset_y;
|
||||
area->width = dts->width;
|
||||
area->height = dts->height;
|
||||
area->screen = dts->screen;
|
||||
area->following = dts->following;
|
||||
|
||||
if (client->swapped) {
|
||||
swaps(&area->control, n);
|
||||
swaps(&area->length, n);
|
||||
swapl(&area->offset_x, n);
|
||||
swapl(&area->offset_y, n);
|
||||
swapl(&area->width, n);
|
||||
swapl(&area->height, n);
|
||||
swapl(&area->screen, n);
|
||||
swapl(&area->following, n);
|
||||
}
|
||||
}
|
||||
|
||||
void CopySwapDeviceCore (ClientPtr client, DeviceIntPtr dev, char *buf)
|
||||
{
|
||||
register char n;
|
||||
xDeviceCoreState *c = (xDeviceCoreState *) buf;
|
||||
|
||||
c->control = DEVICE_CORE;
|
||||
c->length = sizeof(c);
|
||||
c->status = dev->coreEvents;
|
||||
c->iscore = (dev == inputInfo.keyboard || dev == inputInfo.pointer);
|
||||
|
||||
if (client->swapped) {
|
||||
swaps(&c->control, n);
|
||||
swaps(&c->length, n);
|
||||
swaps(&c->status, n);
|
||||
}
|
||||
}
|
||||
|
||||
void CopySwapDeviceEnable (ClientPtr client, DeviceIntPtr dev, char *buf)
|
||||
{
|
||||
register char n;
|
||||
xDeviceEnableState *e = (xDeviceEnableState *) buf;
|
||||
|
||||
e->control = DEVICE_ENABLE;
|
||||
e->length = sizeof(e);
|
||||
e->enable = dev->enabled;
|
||||
|
||||
if (client->swapped) {
|
||||
swaps(&e->control, n);
|
||||
swaps(&e->length, n);
|
||||
swaps(&e->enable, n);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* This procedure writes the reply for the xGetDeviceControl function,
|
||||
|
|
18
Xi/getdctl.h
18
Xi/getdctl.h
|
@ -42,6 +42,24 @@ void CopySwapDeviceResolution(ClientPtr /* client */ ,
|
|||
int /* length */
|
||||
);
|
||||
|
||||
void CopySwapDeviceAbsCalib (ClientPtr client,
|
||||
AbsoluteClassPtr dts,
|
||||
char *buf);
|
||||
|
||||
void CopySwapDeviceAbsArea (ClientPtr client,
|
||||
AbsoluteClassPtr dts,
|
||||
char *buf);
|
||||
|
||||
void CopySwapDeviceCore(ClientPtr /* client */ ,
|
||||
DeviceIntPtr /* dev */ ,
|
||||
char * /* buf */
|
||||
);
|
||||
|
||||
void CopySwapDeviceEnable(ClientPtr /* client */ ,
|
||||
DeviceIntPtr /* dev */ ,
|
||||
char * /* buf */
|
||||
);
|
||||
|
||||
void SRepXGetDeviceControl(ClientPtr /* client */ ,
|
||||
int /* size */ ,
|
||||
xGetDeviceControlReply * /* rep */
|
||||
|
|
15
Xi/listdev.c
15
Xi/listdev.c
|
@ -96,7 +96,7 @@ int
|
|||
ProcXListInputDevices(register ClientPtr client)
|
||||
{
|
||||
xListInputDevicesReply rep;
|
||||
int numdevs;
|
||||
int numdevs = 0;
|
||||
int namesize = 1; /* need 1 extra byte for strcpy */
|
||||
int size = 0;
|
||||
int total_length;
|
||||
|
@ -115,12 +115,15 @@ ProcXListInputDevices(register ClientPtr client)
|
|||
rep.sequenceNumber = client->sequence;
|
||||
|
||||
AddOtherInputDevices();
|
||||
numdevs = inputInfo.numDevices;
|
||||
|
||||
for (d = inputInfo.devices; d; d = d->next)
|
||||
for (d = inputInfo.devices; d; d = d->next) {
|
||||
SizeDeviceInfo(d, &namesize, &size);
|
||||
for (d = inputInfo.off_devices; d; d = d->next)
|
||||
numdevs++;
|
||||
}
|
||||
for (d = inputInfo.off_devices; d; d = d->next) {
|
||||
SizeDeviceInfo(d, &namesize, &size);
|
||||
numdevs++;
|
||||
}
|
||||
|
||||
total_length = numdevs * sizeof(xDeviceInfo) + size + namesize;
|
||||
devbuf = (char *)xalloc(total_length);
|
||||
|
@ -241,6 +244,10 @@ CopySwapDevice(register ClientPtr client, DeviceIntPtr d, int num_classes,
|
|||
dev->use = IsXKeyboard;
|
||||
else if (d == inputInfo.pointer)
|
||||
dev->use = IsXPointer;
|
||||
else if (d->key && d->kbdfeed)
|
||||
dev->use = IsXExtensionKeyboard;
|
||||
else if (d->valuator && d->button)
|
||||
dev->use = IsXExtensionPointer;
|
||||
else
|
||||
dev->use = IsXExtensionDevice;
|
||||
if (client->swapped) {
|
||||
|
|
|
@ -74,6 +74,53 @@ SOFTWARE.
|
|||
extern Mask ExtExclusiveMasks[];
|
||||
extern Mask ExtValidMasks[];
|
||||
|
||||
static int
|
||||
HandleDevicePresenceMask(ClientPtr client, WindowPtr win,
|
||||
XEventClass *cls, CARD16 *count)
|
||||
{
|
||||
int i, j;
|
||||
Mask mask;
|
||||
|
||||
/* We use the device ID 256 to select events that aren't bound to
|
||||
* any device. For now we only handle the device presence event,
|
||||
* but this could be extended to other events that aren't bound to
|
||||
* a device.
|
||||
*
|
||||
* In order not to break in CreateMaskFromList() we remove the
|
||||
* entries with device ID 256 from the XEventClass array.
|
||||
*/
|
||||
|
||||
mask = 0;
|
||||
for (i = 0, j = 0; i < *count; i++) {
|
||||
if (cls[i] >> 8 != 256) {
|
||||
cls[j] = cls[i];
|
||||
j++;
|
||||
continue;
|
||||
}
|
||||
|
||||
switch (cls[i] & 0xff) {
|
||||
case _devicePresence:
|
||||
mask |= DevicePresenceNotifyMask;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
*count = j;
|
||||
|
||||
if (mask == 0)
|
||||
return Success;
|
||||
|
||||
/* We always only use mksidx = 0 for events not bound to
|
||||
* devices */
|
||||
|
||||
if (AddExtensionClient (win, client, mask, 0) != Success)
|
||||
return BadAlloc;
|
||||
|
||||
RecalculateDeviceDeliverableEvents(win);
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Handle requests from clients with a different byte order.
|
||||
|
@ -131,6 +178,13 @@ ProcXSelectExtensionEvent(register ClientPtr client)
|
|||
return Success;
|
||||
}
|
||||
|
||||
if (HandleDevicePresenceMask(client, pWin, (XEventClass *) & stuff[1],
|
||||
&stuff->count) != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0,
|
||||
BadAlloc);
|
||||
return Success;
|
||||
}
|
||||
|
||||
if ((ret = CreateMaskFromList(client, (XEventClass *) & stuff[1],
|
||||
stuff->count, tmp, NULL,
|
||||
X_SelectExtensionEvent)) != Success)
|
||||
|
|
99
Xi/stubs.c
99
Xi/stubs.c
|
@ -66,86 +66,6 @@ SOFTWARE.
|
|||
#include <X11/extensions/XIproto.h>
|
||||
#include "XIstubs.h"
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Caller: ProcXChangeKeyboardDevice
|
||||
*
|
||||
* This procedure does the implementation-dependent portion of the work
|
||||
* needed to change the keyboard device.
|
||||
*
|
||||
* The X keyboard device has a FocusRec. If the device that has been
|
||||
* made into the new X keyboard did not have a FocusRec,
|
||||
* ProcXChangeKeyboardDevice will allocate one for it.
|
||||
*
|
||||
* If you do not want clients to be able to focus the old X keyboard
|
||||
* device, call DeleteFocusClassDeviceStruct to free the FocusRec.
|
||||
*
|
||||
* If you support input devices with keys that you do not want to be
|
||||
* used as the X keyboard, you need to check for them here and return
|
||||
* a BadDevice error.
|
||||
*
|
||||
* The default implementation is to do nothing (assume you do want
|
||||
* clients to be able to focus the old X keyboard). The commented-out
|
||||
* sample code shows what you might do if you don't want the default.
|
||||
*
|
||||
*/
|
||||
|
||||
int
|
||||
ChangeKeyboardDevice(DeviceIntPtr old_dev, DeviceIntPtr new_dev)
|
||||
{
|
||||
/***********************************************************************
|
||||
DeleteFocusClassDeviceStruct(old_dev); * defined in xchgptr.c *
|
||||
**********************************************************************/
|
||||
return BadMatch;
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Caller: ProcXChangePointerDevice
|
||||
*
|
||||
* This procedure does the implementation-dependent portion of the work
|
||||
* needed to change the pointer device.
|
||||
*
|
||||
* The X pointer device does not have a FocusRec. If the device that
|
||||
* has been made into the new X pointer had a FocusRec,
|
||||
* ProcXChangePointerDevice will free it.
|
||||
*
|
||||
* If you want clients to be able to focus the old pointer device that
|
||||
* has now become accessible through the input extension, you need to
|
||||
* add a FocusRec to it here.
|
||||
*
|
||||
* The XChangePointerDevice protocol request also allows the client
|
||||
* to choose which axes of the new pointer device are used to move
|
||||
* the X cursor in the X- and Y- directions. If the axes are different
|
||||
* than the default ones, you need to keep track of that here.
|
||||
*
|
||||
* If you support input devices with valuators that you do not want to be
|
||||
* used as the X pointer, you need to check for them here and return a
|
||||
* BadDevice error.
|
||||
*
|
||||
* The default implementation is to do nothing (assume you don't want
|
||||
* clients to be able to focus the old X pointer). The commented-out
|
||||
* sample code shows what you might do if you don't want the default.
|
||||
*
|
||||
*/
|
||||
|
||||
int
|
||||
ChangePointerDevice(DeviceIntPtr old_dev,
|
||||
DeviceIntPtr new_dev, unsigned char x, unsigned char y)
|
||||
{
|
||||
/***********************************************************************
|
||||
InitFocusClassDeviceStruct(old_dev); * allow focusing old ptr*
|
||||
|
||||
x_axis = x; * keep track of new x-axis*
|
||||
y_axis = y; * keep track of new y-axis*
|
||||
if (x_axis != 0 || y_axis != 1)
|
||||
axes_changed = TRUE; * remember axes have changed*
|
||||
else
|
||||
axes_changed = FALSE;
|
||||
*************************************************************************/
|
||||
return BadMatch;
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Caller: ProcXCloseDevice
|
||||
|
@ -287,7 +207,26 @@ ChangeDeviceControl(register ClientPtr client, DeviceIntPtr dev,
|
|||
switch (control->control) {
|
||||
case DEVICE_RESOLUTION:
|
||||
return (BadMatch);
|
||||
case DEVICE_ABS_CALIB:
|
||||
case DEVICE_ABS_AREA:
|
||||
return (BadMatch);
|
||||
case DEVICE_CORE:
|
||||
return (BadMatch);
|
||||
default:
|
||||
return (BadMatch);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
*
|
||||
* Caller: configAddDevice (and others)
|
||||
*
|
||||
* Add a new device with the specified options.
|
||||
*
|
||||
*/
|
||||
int
|
||||
NewInputDeviceRequest(InputOption *options)
|
||||
{
|
||||
return BadValue;
|
||||
}
|
||||
|
|
|
@ -269,7 +269,10 @@ ProcCompositeNameWindowPixmap (ClientPtr client)
|
|||
client->errorValue = stuff->window;
|
||||
return BadWindow;
|
||||
}
|
||||
|
||||
|
||||
if (!pWin->viewable)
|
||||
return BadMatch;
|
||||
|
||||
LEGAL_NEW_RESOURCE (stuff->pixmap, client);
|
||||
|
||||
cw = GetCompWindow (pWin);
|
||||
|
|
10
config/Makefile.am
Normal file
10
config/Makefile.am
Normal file
|
@ -0,0 +1,10 @@
|
|||
AM_CFLAGS = @DIX_CFLAGS@
|
||||
|
||||
dbusconfigdir = $(sysconfdir)/dbus-1/system.d
|
||||
dbusconfig_DATA = xorg-server.conf
|
||||
|
||||
lib_LIBRARIES = libconfig.a
|
||||
|
||||
libconfig_a_SOURCES = config.c
|
||||
|
||||
EXTRA_DIST = xorg-server.conf
|
450
config/config.c
Normal file
450
config/config.c
Normal file
|
@ -0,0 +1,450 @@
|
|||
/*
|
||||
* Copyright © 2006 Daniel Stone
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of the copyright holders and/or authors
|
||||
* not be used in advertising or publicity pertaining to distribution of the
|
||||
* software without specific, written prior permission. The copyright holders
|
||||
* and/or authors make no representations about the suitability of this
|
||||
* software for any purpose. It is provided "as is" without express or
|
||||
* implied warranty.
|
||||
*
|
||||
* THE COPYRIGHT HOLDERS AND/OR AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD
|
||||
* TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND/OR AUTHORS BE LIABLE
|
||||
* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
|
||||
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
|
||||
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_DBUS
|
||||
#define DBUS_API_SUBJECT_TO_CHANGE
|
||||
#include <dbus/dbus.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
|
||||
#include "opaque.h" /* for 'display': there has to be a better way */
|
||||
/* the above comment lies. there is no better way. */
|
||||
#include "input.h"
|
||||
#include "inputstr.h"
|
||||
#include "hotplug.h"
|
||||
#include "os.h"
|
||||
|
||||
#define CONFIG_MATCH_RULE "type='method_call',interface='org.x.config.input'"
|
||||
|
||||
#define MALFORMED_MSG "[config] malformed message, dropping"
|
||||
#define MALFORMED_MESSAGE() { DebugF(MALFORMED_MSG "\n"); \
|
||||
ret = BadValue; \
|
||||
goto unwind; }
|
||||
#define MALFORMED_MESSAGE_ERROR() { DebugF(MALFORMED_MSG ": %s, %s", \
|
||||
error->name, error->message); \
|
||||
ret = BadValue; \
|
||||
goto unwind; }
|
||||
|
||||
/* How often to attempt reconnecting when we get booted off the bus. */
|
||||
#define RECONNECT_DELAY 10000 /* in ms */
|
||||
|
||||
struct config_data {
|
||||
int fd;
|
||||
DBusConnection *connection;
|
||||
char busobject[32];
|
||||
char busname[64];
|
||||
};
|
||||
|
||||
static struct config_data *configData;
|
||||
|
||||
static CARD32 configReconnect(OsTimerPtr timer, CARD32 time, pointer arg);
|
||||
|
||||
static void
|
||||
configWakeupHandler(pointer blockData, int err, pointer pReadMask)
|
||||
{
|
||||
struct config_data *data = blockData;
|
||||
|
||||
if (data->connection && FD_ISSET(data->fd, (fd_set *) pReadMask))
|
||||
dbus_connection_read_write_dispatch(data->connection, 0);
|
||||
}
|
||||
|
||||
static void
|
||||
configBlockHandler(pointer data, struct timeval **tv, pointer pReadMask)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
configTeardown(void)
|
||||
{
|
||||
if (configData) {
|
||||
RemoveGeneralSocket(configData->fd);
|
||||
RemoveBlockAndWakeupHandlers(configBlockHandler, configWakeupHandler,
|
||||
configData);
|
||||
xfree(configData);
|
||||
configData = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
configAddDevice(DBusMessage *message, DBusMessageIter *iter, DBusError *error)
|
||||
{
|
||||
DBusMessageIter subiter;
|
||||
InputOption *tmpo = NULL, *options = NULL;
|
||||
char *tmp = NULL;
|
||||
int ret = BadMatch;
|
||||
|
||||
DebugF("[config] adding device\n");
|
||||
|
||||
/* signature should be [ss][ss]... */
|
||||
options = (InputOption *) xcalloc(sizeof(InputOption), 1);
|
||||
if (!options) {
|
||||
ErrorF("[config] couldn't allocate option\n");
|
||||
return BadAlloc;
|
||||
}
|
||||
|
||||
options->key = xstrdup("_source");
|
||||
options->value = xstrdup("client/dbus");
|
||||
|
||||
while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_ARRAY) {
|
||||
tmpo = (InputOption *) xcalloc(sizeof(InputOption), 1);
|
||||
if (!tmpo) {
|
||||
ErrorF("[config] couldn't allocate option\n");
|
||||
ret = BadAlloc;
|
||||
goto unwind;
|
||||
}
|
||||
|
||||
dbus_message_iter_recurse(iter, &subiter);
|
||||
|
||||
if (dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_STRING)
|
||||
MALFORMED_MESSAGE();
|
||||
|
||||
dbus_message_iter_get_basic(&subiter, &tmp);
|
||||
if (!tmp)
|
||||
MALFORMED_MESSAGE();
|
||||
if (tmp[0] == '_') {
|
||||
ErrorF("[config] attempted subterfuge: option name %s given\n",
|
||||
tmp);
|
||||
MALFORMED_MESSAGE();
|
||||
}
|
||||
tmpo->key = xstrdup(tmp);
|
||||
if (!tmpo->key) {
|
||||
ErrorF("[config] couldn't duplicate key!\n");
|
||||
ret = BadAlloc;
|
||||
goto unwind;
|
||||
}
|
||||
|
||||
if (!dbus_message_iter_has_next(&subiter))
|
||||
MALFORMED_MESSAGE();
|
||||
dbus_message_iter_next(&subiter);
|
||||
if (dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_STRING)
|
||||
MALFORMED_MESSAGE();
|
||||
|
||||
dbus_message_iter_get_basic(&subiter, &tmp);
|
||||
if (!tmp)
|
||||
MALFORMED_MESSAGE();
|
||||
tmpo->value = xstrdup(tmp);
|
||||
if (!tmpo->value) {
|
||||
ErrorF("[config] couldn't duplicate option!\n");
|
||||
ret = BadAlloc;
|
||||
goto unwind;
|
||||
}
|
||||
|
||||
tmpo->next = options;
|
||||
options = tmpo;
|
||||
dbus_message_iter_next(iter);
|
||||
}
|
||||
|
||||
ret = NewInputDeviceRequest(options);
|
||||
if (ret != Success)
|
||||
DebugF("[config] NewInputDeviceRequest failed\n");
|
||||
|
||||
return ret;
|
||||
|
||||
unwind:
|
||||
if (tmpo->key)
|
||||
xfree(tmpo->key);
|
||||
if (tmpo->value)
|
||||
xfree(tmpo->value);
|
||||
if (tmpo)
|
||||
xfree(tmpo);
|
||||
|
||||
while (options) {
|
||||
tmpo = options;
|
||||
options = options->next;
|
||||
if (tmpo->key)
|
||||
xfree(tmpo->key);
|
||||
if (tmpo->value)
|
||||
xfree(tmpo->value);
|
||||
xfree(tmpo);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
configRemoveDevice(DBusMessage *message, DBusMessageIter *iter,
|
||||
DBusError *error)
|
||||
{
|
||||
int deviceid = -1;
|
||||
int ret = BadMatch;
|
||||
DeviceIntPtr pDev = NULL;
|
||||
|
||||
if (!dbus_message_get_args(message, error, DBUS_TYPE_INT32,
|
||||
&deviceid, DBUS_TYPE_INVALID)) {
|
||||
MALFORMED_MESSAGE_ERROR();
|
||||
}
|
||||
|
||||
if (deviceid < 0 || !(pDev = LookupDeviceIntRec(deviceid))) {
|
||||
DebugF("[config] bogus device id %d given\n", deviceid);
|
||||
ret = BadMatch;
|
||||
goto unwind;
|
||||
}
|
||||
|
||||
DebugF("[config] removing device %s (id %d)\n", pDev->name, deviceid);
|
||||
|
||||
/* Call PIE here so we don't try to dereference a device that's
|
||||
* already been removed. */
|
||||
OsBlockSignals();
|
||||
ProcessInputEvents();
|
||||
RemoveDevice(pDev);
|
||||
OsReleaseSignals();
|
||||
|
||||
return Success;
|
||||
|
||||
unwind:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static DBusHandlerResult
|
||||
configMessage(DBusConnection *connection, DBusMessage *message, void *closure)
|
||||
{
|
||||
DBusMessageIter iter;
|
||||
DBusError error;
|
||||
DBusMessage *reply;
|
||||
DBusConnection *bus = closure;
|
||||
int ret = BadDrawable; /* nonsensical value */
|
||||
|
||||
dbus_error_init(&error);
|
||||
|
||||
if (strcmp(dbus_message_get_interface(message),
|
||||
"org.x.config.input") == 0) {
|
||||
if (!dbus_message_iter_init(message, &iter)) {
|
||||
ErrorF("[config] failed to init iterator\n");
|
||||
dbus_error_free(&error);
|
||||
return DBUS_HANDLER_RESULT_NEED_MEMORY; /* ?? */
|
||||
}
|
||||
|
||||
if (strcmp(dbus_message_get_member(message), "add") == 0)
|
||||
ret = configAddDevice(message, &iter, &error);
|
||||
else if (strcmp(dbus_message_get_member(message), "remove") == 0)
|
||||
ret = configRemoveDevice(message, &iter, &error);
|
||||
if (ret != BadDrawable && ret != BadAlloc) {
|
||||
reply = dbus_message_new_method_return(message);
|
||||
dbus_message_iter_init_append(reply, &iter);
|
||||
|
||||
if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret)) {
|
||||
ErrorF("[config] couldn't append to iterator\n");
|
||||
dbus_error_free(&error);
|
||||
return DBUS_HANDLER_RESULT_HANDLED;
|
||||
}
|
||||
|
||||
if (!dbus_connection_send(bus, reply, NULL))
|
||||
ErrorF("[config] failed to send reply\n");
|
||||
dbus_connection_flush(bus);
|
||||
|
||||
dbus_message_unref(reply);
|
||||
}
|
||||
}
|
||||
|
||||
dbus_error_free(&error);
|
||||
|
||||
if (ret == BadAlloc)
|
||||
return DBUS_HANDLER_RESULT_NEED_MEMORY;
|
||||
else if (ret == BadDrawable)
|
||||
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
||||
else
|
||||
return DBUS_HANDLER_RESULT_HANDLED;
|
||||
}
|
||||
|
||||
/**
|
||||
* This is a filter, which only handles the disconnected signal, which
|
||||
* doesn't go to the normal message handling function. This takes
|
||||
* precedence over the message handling function, so have have to be
|
||||
* careful to ignore anything we don't want to deal with here.
|
||||
*
|
||||
* Yes, this is brutally stupid.
|
||||
*/
|
||||
static DBusHandlerResult
|
||||
configFilter(DBusConnection *connection, DBusMessage *message, void *closure)
|
||||
{
|
||||
if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL,
|
||||
"Disconnected")) {
|
||||
ErrorF("[dbus] disconnected from bus\n");
|
||||
TimerSet(NULL, 0, RECONNECT_DELAY, configReconnect, NULL);
|
||||
configTeardown();
|
||||
return DBUS_HANDLER_RESULT_HANDLED;
|
||||
}
|
||||
|
||||
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
||||
}
|
||||
|
||||
static Bool
|
||||
configSetup(void)
|
||||
{
|
||||
DBusError error;
|
||||
DBusObjectPathVTable vtable = { .message_function = configMessage };
|
||||
|
||||
if (!configData)
|
||||
configData = (struct config_data *) xcalloc(sizeof(struct config_data), 1);
|
||||
if (!configData) {
|
||||
ErrorF("[dbus] failed to allocate data struct.\n");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
dbus_error_init(&error);
|
||||
configData->connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
|
||||
if (!configData->connection || dbus_error_is_set(&error)) {
|
||||
ErrorF("[dbus] some kind of error occurred: %s (%s)\n", error.name,
|
||||
error.message);
|
||||
dbus_error_free(&error);
|
||||
xfree(configData);
|
||||
configData = NULL;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
dbus_connection_set_exit_on_disconnect(configData->connection, FALSE);
|
||||
|
||||
if (!dbus_connection_get_unix_fd(configData->connection, &configData->fd)) {
|
||||
dbus_connection_unref(configData->connection);
|
||||
ErrorF("[dbus] couldn't get fd for bus\n");
|
||||
dbus_error_free(&error);
|
||||
xfree(configData);
|
||||
configData = NULL;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
snprintf(configData->busname, sizeof(configData->busname),
|
||||
"org.x.config.display%d", atoi(display));
|
||||
if (!dbus_bus_request_name(configData->connection, configData->busname,
|
||||
0, &error) || dbus_error_is_set(&error)) {
|
||||
ErrorF("[dbus] couldn't take over org.x.config: %s (%s)\n",
|
||||
error.name, error.message);
|
||||
dbus_error_free(&error);
|
||||
dbus_connection_unref(configData->connection);
|
||||
xfree(configData);
|
||||
configData = NULL;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* blocks until we get a reply. */
|
||||
dbus_bus_add_match(configData->connection, CONFIG_MATCH_RULE, &error);
|
||||
if (dbus_error_is_set(&error)) {
|
||||
ErrorF("[dbus] couldn't match X.Org rule: %s (%s)\n", error.name,
|
||||
error.message);
|
||||
dbus_error_free(&error);
|
||||
dbus_bus_release_name(configData->connection, configData->busname,
|
||||
&error);
|
||||
dbus_connection_unref(configData->connection);
|
||||
xfree(configData);
|
||||
configData = NULL;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (!dbus_connection_add_filter(configData->connection, configFilter,
|
||||
configData, NULL)) {
|
||||
|
||||
ErrorF("[dbus] couldn't add signal filter: %s (%s)\n", error.name,
|
||||
error.message);
|
||||
dbus_error_free(&error);
|
||||
dbus_bus_release_name(configData->connection, configData->busname,
|
||||
&error);
|
||||
dbus_bus_remove_match(configData->connection, CONFIG_MATCH_RULE,
|
||||
&error);
|
||||
dbus_connection_unref(configData->connection);
|
||||
xfree(configData);
|
||||
configData = NULL;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
snprintf(configData->busobject, sizeof(configData->busobject),
|
||||
"/org/x/config/%d", atoi(display));
|
||||
if (!dbus_connection_register_object_path(configData->connection,
|
||||
configData->busobject, &vtable,
|
||||
configData->connection)) {
|
||||
ErrorF("[dbus] couldn't register object path\n");
|
||||
dbus_bus_release_name(configData->connection, configData->busname,
|
||||
&error);
|
||||
dbus_bus_remove_match(configData->connection, CONFIG_MATCH_RULE,
|
||||
&error);
|
||||
dbus_connection_unref(configData->connection);
|
||||
dbus_error_free(&error);
|
||||
xfree(configData);
|
||||
configData = NULL;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
DebugF("[dbus] registered object path %s\n", configData->busobject);
|
||||
|
||||
dbus_error_free(&error);
|
||||
AddGeneralSocket(configData->fd);
|
||||
|
||||
RegisterBlockAndWakeupHandlers(configBlockHandler, configWakeupHandler,
|
||||
configData);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static CARD32
|
||||
configReconnect(OsTimerPtr timer, CARD32 time, pointer arg)
|
||||
{
|
||||
if (configSetup())
|
||||
return 0;
|
||||
else
|
||||
return RECONNECT_DELAY;
|
||||
}
|
||||
|
||||
void
|
||||
configInitialise()
|
||||
{
|
||||
TimerSet(NULL, 0, 1, configReconnect, NULL);
|
||||
}
|
||||
|
||||
void
|
||||
configFini()
|
||||
{
|
||||
DBusError error;
|
||||
|
||||
if (configData) {
|
||||
dbus_error_init(&error);
|
||||
dbus_connection_unregister_object_path(configData->connection,
|
||||
configData->busobject);
|
||||
dbus_connection_remove_filter(configData->connection, configFilter,
|
||||
configData);
|
||||
dbus_bus_remove_match(configData->connection, CONFIG_MATCH_RULE,
|
||||
&error);
|
||||
dbus_bus_release_name(configData->connection, configData->busname,
|
||||
&error);
|
||||
dbus_connection_unref(configData->connection);
|
||||
dbus_error_free(&error);
|
||||
configTeardown();
|
||||
}
|
||||
}
|
||||
|
||||
#else /* !HAVE_DBUS */
|
||||
|
||||
void
|
||||
configInitialise()
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
configFini()
|
||||
{
|
||||
}
|
||||
|
||||
#endif /* HAVE_DBUS */
|
35
config/dbus-api
Normal file
35
config/dbus-api
Normal file
|
@ -0,0 +1,35 @@
|
|||
D-BUS Configuration API v0.1
|
||||
----------------------------
|
||||
|
||||
The X server will register the bus name org.x.config.displayN, and the
|
||||
object /org/x/config/N, where N is the display number.
|
||||
|
||||
Currently only hotplugging of input devices is supported.
|
||||
|
||||
org.x.config.input:
|
||||
org.x.config.input.add:
|
||||
Takes an argument of key/value option pairs in arrays, e.g.:
|
||||
[ss][ss][ss][ss]
|
||||
is the signature for four options. These options will be passed
|
||||
to the input driver as with any others.
|
||||
Option names beginning with _ are not allowed; they are reserved
|
||||
for internal use.
|
||||
|
||||
Returns one int32, which is an X Status, as defined in X.h. If
|
||||
everything is successful, Success will be returned. BadMatch will
|
||||
be returned if the options given do not match any device. BadValue
|
||||
is returned for a malformed message.
|
||||
|
||||
Notably, BadAlloc is never returned: the server internally signals
|
||||
to D-BUS that the attempt failed for lack of memory.
|
||||
|
||||
The return does not notify the client of which devices were created
|
||||
or modified as a result of this request: clients are encouraged to
|
||||
listen for the XInput DevicePresenceNotify event to monitor changes
|
||||
in the device list.
|
||||
|
||||
org.x.config.input.remove:
|
||||
Takes one int32 argument, which is the device ID to remove, i.e.:
|
||||
i
|
||||
is the signature.
|
||||
Same return values as org.x.config.input.add.
|
13
config/xorg-server.conf
Normal file
13
config/xorg-server.conf
Normal file
|
@ -0,0 +1,13 @@
|
|||
<!DOCTYPE busconfig PUBLIC
|
||||
"-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
|
||||
"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
|
||||
<busconfig>
|
||||
<policy context="default">
|
||||
<allow own="org.x.config.display0"/>
|
||||
<allow send_destination="org.x.config.display0"/>
|
||||
<allow send_interface="org.x.config.display0"/>
|
||||
<allow own="org.x.config.display1"/>
|
||||
<allow send_destination="org.x.config.display1"/>
|
||||
<allow send_interface="org.x.config.display1"/>
|
||||
</policy>
|
||||
</busconfig>
|
395
configure.ac
395
configure.ac
|
@ -25,7 +25,7 @@ dnl Process this file with autoconf to create configure.
|
|||
AC_PREREQ(2.57)
|
||||
dnl This is the not the Xorg version number, it's the server version number.
|
||||
dnl Yes, that's weird.
|
||||
AC_INIT([xorg-server], 1.1.99.3, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
|
||||
AC_INIT([xorg-server], 1.2.99.0, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
|
||||
AC_CONFIG_SRCDIR([Makefile.am])
|
||||
AM_INIT_AUTOMAKE([dist-bzip2 foreign])
|
||||
AM_MAINTAINER_MODE
|
||||
|
@ -50,7 +50,6 @@ AC_CONFIG_HEADERS(include/xwin-config.h)
|
|||
dnl kdrive-config.h covers the kdrive DDX
|
||||
AC_CONFIG_HEADERS(include/kdrive-config.h)
|
||||
|
||||
|
||||
AC_PROG_CC
|
||||
AM_PROG_AS
|
||||
AC_PROG_INSTALL
|
||||
|
@ -62,8 +61,29 @@ AC_PROG_MAKE_SET
|
|||
PKG_PROG_PKG_CONFIG
|
||||
AC_PROG_LEX
|
||||
AC_PROG_YACC
|
||||
AC_SYS_LARGEFILE
|
||||
XORG_PROG_RAWCPP
|
||||
|
||||
dnl Check for dtrace program (needed to build Xserver dtrace probes)
|
||||
AC_ARG_WITH(dtrace, AS_HELP_STRING([--with-dtrace=PATH],
|
||||
[Enable dtrace probes (default: enabled if dtrace found)]),
|
||||
[WDTRACE=$withval], [WDTRACE=auto])
|
||||
if test "x$WDTRACE" = "xyes" -o "x$WDTRACE" = "xauto" ; then
|
||||
AC_PATH_PROG(DTRACE, [dtrace], [not_found], [$PATH:/usr/sbin])
|
||||
if test "x$DTRACE" = "xnot_found" ; then
|
||||
if test "x$WDTRACE" = "xyes" ; then
|
||||
AC_MSG_FAILURE([dtrace requested but not found])
|
||||
fi
|
||||
WDTRACE="no"
|
||||
fi
|
||||
fi
|
||||
if test "x$WDTRACE" != "xno" ; then
|
||||
AC_DEFINE(XSERVER_DTRACE, 1,
|
||||
[Define to 1 if the DTrace Xserver provider probes should be built in.])
|
||||
fi
|
||||
AM_CONDITIONAL(XSERVER_DTRACE, [test "x$WDTRACE" != "xno"])
|
||||
AC_DEFINE_DIR(XERRORDB_PATH, libdir/XErrorDB, [Path to XErrorDB file])
|
||||
|
||||
AC_HEADER_DIRENT
|
||||
AC_HEADER_STDC
|
||||
AC_CHECK_HEADERS([fcntl.h stdlib.h string.h unistd.h])
|
||||
|
@ -154,7 +174,7 @@ AC_CACHE_CHECK([for SYSV IPC],
|
|||
[AC_TRY_LINK([
|
||||
#include <sys/shm.h>
|
||||
],[
|
||||
int main () {
|
||||
{
|
||||
int id;
|
||||
id = shmget(IPC_PRIVATE, 512, SHM_W | SHM_R);
|
||||
if (id < 0) return -1;
|
||||
|
@ -262,6 +282,7 @@ case $host_os in
|
|||
*netbsd*)
|
||||
AC_DEFINE(CSRG_BASED, 1, [System is BSD-like])
|
||||
AC_DEFINE(PCCONS_SUPPORT, 1, [System has PC console])
|
||||
AC_DEFINE(PCVT_SUPPORT, 1, [System has PCVT console])
|
||||
AC_DEFINE(WSCONS_SUPPORT, 1, [System has wscons console])
|
||||
DRI=yes
|
||||
;;
|
||||
|
@ -370,7 +391,7 @@ AC_ARG_WITH(mesa-source, AS_HELP_STRING([--with-mesa-source=MESA_SOURCE], [P
|
|||
AC_ARG_WITH(fontdir, AS_HELP_STRING([--with-fontdir=FONTDIR], [Path to top level dir where fonts are installed (default: ${libdir}/X11/fonts)]),
|
||||
[ FONTDIR="$withval" ],
|
||||
[ FONTDIR="${libdir}/X11/fonts" ])
|
||||
DEFAULT_FONT_PATH="${FONTDIR}/misc/,${FONTDIR}/TTF/,${FONTDIR}/OTF,${FONTDIR}/Type1/,${FONTDIR}/CID/,${FONTDIR}/100dpi/,${FONTDIR}/75dpi/"
|
||||
DEFAULT_FONT_PATH="${FONTDIR}/misc/,${FONTDIR}/TTF/,${FONTDIR}/OTF,${FONTDIR}/Type1/,${FONTDIR}/100dpi/,${FONTDIR}/75dpi/"
|
||||
AC_ARG_WITH(default-font-path, AS_HELP_STRING([--with-default-font-path=PATH], [Comma separated list of font dirs]),
|
||||
[ FONTPATH="$withval" ],
|
||||
[ FONTPATH="${DEFAULT_FONT_PATH}" ])
|
||||
|
@ -394,6 +415,12 @@ AC_ARG_ENABLE(install-libxf86config,
|
|||
[Install libxf86config (default: disabled)]),
|
||||
[INSTALL_LIBXF86CONFIG=$enableval],
|
||||
[INSTALL_LIBXF86CONFIG=no])
|
||||
AC_ARG_ENABLE(builtin-fonts, AS_HELP_STRING([--enable-builtin-fonts], [Use only built-in fonts (default: use external)]),
|
||||
[BUILTIN_FONTS=$enableval],
|
||||
[BUILTIN_FONTS=no])
|
||||
AC_ARG_ENABLE(null-root-cursor, AS_HELP_STRING([--enable-null-root-cursor], [Use an empty root cursor (default: use core cursor)]),
|
||||
[NULL_ROOT_CURSOR=$enableval],
|
||||
[NULL_ROOT_CURSOR=no])
|
||||
|
||||
dnl Extensions.
|
||||
AC_ARG_ENABLE(composite, AS_HELP_STRING([--disable-composite], [Build Composite extension (default: enabled)]), [COMPOSITE=$enableval], [COMPOSITE=yes])
|
||||
|
@ -403,7 +430,7 @@ AC_ARG_ENABLE(xtrap, AS_HELP_STRING([--disable-xtrap], [Build XTrap ext
|
|||
AC_ARG_ENABLE(record, AS_HELP_STRING([--disable-record], [Build Record extension (default: enabled)]), [RECORD=$enableval], [RECORD=yes])
|
||||
AC_ARG_ENABLE(xv, AS_HELP_STRING([--disable-xv], [Build Xv extension (default: enabled)]), [XV=$enableval], [XV=yes])
|
||||
AC_ARG_ENABLE(xvmc, AS_HELP_STRING([--disable-xvmc], [Build XvMC extension (default: enabled)]), [XVMC=$enableval], [XVMC=yes])
|
||||
AC_ARG_ENABLE(dga, AS_HELP_STRING([--disable-dga], [Build DGA extension (default: enabled)]), [DGA=$enableval], [DGA=yes])
|
||||
AC_ARG_ENABLE(dga, AS_HELP_STRING([--disable-dga], [Build DGA extension (default: auto)]), [DGA=$enableval], [DGA=auto])
|
||||
AC_ARG_ENABLE(screensaver, AS_HELP_STRING([--disable-screensaver], [Build ScreenSaver extension (default: enabled)]), [SCREENSAVER=$enableval], [SCREENSAVER=yes])
|
||||
AC_ARG_ENABLE(xdmcp, AS_HELP_STRING([--disable-xdmcp], [Build XDMCP extension (default: auto)]), [XDMCP=$enableval], [XDMCP=auto])
|
||||
AC_ARG_ENABLE(xdm-auth-1, AS_HELP_STRING([--disable-xdm-auth-1], [Build XDM-Auth-1 extension (default: auto)]), [XDMAUTH=$enableval], [XDMAUTH=auto])
|
||||
|
@ -412,8 +439,8 @@ AC_ARG_ENABLE(aiglx, AS_HELP_STRING([--enable-aiglx], [Build accelerate
|
|||
AC_ARG_ENABLE(glx-tls, AS_HELP_STRING([--enable-glx-tls], [Build GLX with TLS support (default: disabled)]), [GLX_USE_TLS=$enableval], [GLX_USE_TLS=no])
|
||||
AC_ARG_ENABLE(dri, AS_HELP_STRING([--enable-dri], [Build DRI extension (default: auto)]), [DRI=$enableval])
|
||||
AC_ARG_ENABLE(xinerama, AS_HELP_STRING([--disable-xinerama], [Build Xinerama extension (default: enabled)]), [XINERAMA=$enableval], [XINERAMA=yes])
|
||||
AC_ARG_ENABLE(xf86vidmode, AS_HELP_STRING([--disable-xf86vidmode], [Build XF86VidMode extension (default: enabled)]), [XF86VIDMODE=$enableval], [XF86VIDMODE=yes])
|
||||
AC_ARG_ENABLE(xf86misc, AS_HELP_STRING([--disable-xf86misc], [Build XF86Misc extension (default: enabled)]), [XF86MISC=$enableval], [XF86MISC=yes])
|
||||
AC_ARG_ENABLE(xf86vidmode, AS_HELP_STRING([--disable-xf86vidmode], [Build XF86VidMode extension (default: auto)]), [XF86VIDMODE=$enableval], [XF86VIDMODE=auto])
|
||||
AC_ARG_ENABLE(xf86misc, AS_HELP_STRING([--disable-xf86misc], [Build XF86Misc extension (default: auto)]), [XF86MISC=$enableval], [XF86MISC=auto])
|
||||
AC_ARG_ENABLE(xace, AS_HELP_STRING([--disable-xace], [Build X-ACE extension (default: enabled)]), [XACE=$enableval], [XACE=yes])
|
||||
AC_ARG_ENABLE(xcsecurity, AS_HELP_STRING([--disable-xcsecurity], [Build Security extension (default: enabled)]), [XCSECURITY=$enableval], [XCSECURITY=$XACE])
|
||||
AC_ARG_ENABLE(appgroup, AS_HELP_STRING([--disable-appgroup], [Build XC-APPGROUP extension (default: enabled)]), [APPGROUP=$enableval], [APPGROUP=$XCSECURITY])
|
||||
|
@ -427,7 +454,7 @@ AC_ARG_ENABLE(fontcache, AS_HELP_STRING([--enable-fontcache], [Build FontCa
|
|||
AC_ARG_ENABLE(dbe, AS_HELP_STRING([--disable-dbe], [Build DBE extension (default: enabled)]), [DBE=$enableval], [DBE=yes])
|
||||
AC_ARG_ENABLE(xf86bigfont, AS_HELP_STRING([--disable-xf86bigfont], [Build XF86 Big Font extension (default: enabled)]), [XF86BIGFONT=$enableval], [XF86BIGFONT=yes])
|
||||
AC_ARG_ENABLE(dpms, AS_HELP_STRING([--disable-dpms], [Build DPMS extension (default: enabled)]), [DPMSExtension=$enableval], [DPMSExtension=yes])
|
||||
AC_ARG_ENABLE(xinput, AS_HELP_STRING([--disable-xinput], [Build XInput Extension (default: enabled)]), [XINPUT=$enableval], [XINPUT=yes])
|
||||
AC_ARG_ENABLE(dbus, AS_HELP_STRING([--disable-dbus], [Build D-BUS support (default: auto)]), [DBUS=$enableval], [DBUS=auto])
|
||||
AC_ARG_ENABLE(xfree86-utils, AS_HELP_STRING([--enable-xfree86-utils], [Build xfree86 DDX utilities (default: enabled)]), [XF86UTILS=$enableval], [XF86UTILS=yes])
|
||||
|
||||
dnl DDXes.
|
||||
|
@ -436,7 +463,7 @@ AC_ARG_ENABLE(dmx, AS_HELP_STRING([--enable-dmx], [Build DMX server (d
|
|||
AC_ARG_ENABLE(xvfb, AS_HELP_STRING([--enable-xvfb], [Build Xvfb server (default: yes)]), [XVFB=$enableval], [XVFB=yes])
|
||||
AC_ARG_ENABLE(xnest, AS_HELP_STRING([--enable-xnest], [Build Xnest server (default: auto)]), [XNEST=$enableval], [XNEST=auto])
|
||||
AC_ARG_ENABLE(xwin, AS_HELP_STRING([--enable-xwin], [Build XWin server (default: auto)]), [XWIN=$enableval], [XWIN=auto])
|
||||
AC_ARG_ENABLE(xprint, AS_HELP_STRING([--enable-xprint], [Build Xprint extension and server (default: auto)]), [XPRINT=$enableval], [XPRINT=auto])
|
||||
AC_ARG_ENABLE(xprint, AS_HELP_STRING([--enable-xprint], [Build Xprint extension and server (default: no)]), [XPRINT=$enableval], [XPRINT=no])
|
||||
AC_ARG_ENABLE(xgl, AS_HELP_STRING([--enable-xgl], [Build Xgl server (default: no)]), [XGL=$enableval], [XGL=no])
|
||||
AC_ARG_ENABLE(xglx, AS_HELP_STRING([--enable-xglx], [Build Xglx xgl module (default: no)]), [XGLX=$enableval], [XGLX=no])
|
||||
AC_ARG_ENABLE(xegl, AS_HELP_STRING([--enable-xegl], [Build Xegl xgl module (default: no)]), [XEGL=$enableval], [XEGL=no])
|
||||
|
@ -444,6 +471,9 @@ dnl kdrive and its subsystems
|
|||
AC_ARG_ENABLE(kdrive, AS_HELP_STRING([--enable-kdrive], [Build kdrive servers (default: no)]), [KDRIVE=$enableval], [KDRIVE=no])
|
||||
AC_ARG_ENABLE(xephyr, AS_HELP_STRING([--enable-xephyr], [Build the kdrive Xephyr server (default: auto)]), [XEPHYR=$enableval], [XEPHYR=auto])
|
||||
AC_ARG_ENABLE(xsdl, AS_HELP_STRING([--enable-xsdl], [Build the kdrive Xsdl server (default: auto)]), [XSDL=$enableval], [XSDL=auto])
|
||||
AC_ARG_ENABLE(xfake, AS_HELP_STRING([--enable-xfake], [Build the kdrive 'fake' server (default: auto)]), [XFAKE=$enableval], [XFAKE=auto])
|
||||
AC_ARG_ENABLE(xfbdev, AS_HELP_STRING([--enable-xfbdev], [Build the kdrive framebuffer device server (default: auto)]), [XFBDEV=$enableval], [XFBDEV=auto])
|
||||
AC_ARG_ENABLE(kdrive-vesa, AS_HELP_STRING([--enable-kdrive-vesa], [Build the kdrive VESA-based servers (default: auto)]), [KDRIVEVESA=$enableval], [KDRIVEVESA=auto])
|
||||
dnl xprint
|
||||
AC_ARG_ENABLE(freetype, AS_HELP_STRING([ --enable-freetype], [Build Xprint FreeType backend (default: yes)]), [XP_USE_FREETYPE=$enableval],[XP_USE_FREETYPE=no])
|
||||
AC_ARG_WITH(freetype-config, AS_HELP_STRING([ --with-freetype-config=PROG], [Use FreeType configuration program PROG (default: auto)]), freetype_config=$withval, freetype_config=auto)
|
||||
|
@ -515,9 +545,21 @@ XEXT_LIB='$(top_builddir)/Xext/libXext.la'
|
|||
XEXTXORG_LIB='$(top_builddir)/Xext/libXextbuiltin.la'
|
||||
|
||||
dnl Core modules for most extensions, et al.
|
||||
REQUIRED_MODULES="randrproto renderproto [fixesproto >= 4.0] damageproto xcmiscproto xextproto xproto xtrans xf86miscproto xf86vidmodeproto xf86bigfontproto [scrnsaverproto >= 1.1] bigreqsproto resourceproto fontsproto inputproto xf86dgaproto [kbproto >= 1.0.3]"
|
||||
REQUIRED_MODULES="[randrproto >= 1.2] renderproto [fixesproto >= 4.0] damageproto xcmiscproto xextproto xproto xtrans [scrnsaverproto >= 1.1] bigreqsproto resourceproto fontsproto [inputproto >= 1.4] [kbproto >= 1.0.3]"
|
||||
REQUIRED_LIBS="xfont xau fontenc"
|
||||
|
||||
if test "x$DBUS" = xauto; then
|
||||
PKG_CHECK_MODULES(DBUS, dbus-1, [DBUS=yes], [DBUS=no])
|
||||
fi
|
||||
if test "x$DBUS" = xyes; then
|
||||
PKG_CHECK_MODULES(DBUS, dbus-1)
|
||||
AC_DEFINE(HAVE_DBUS, 1, [Have D-BUS support])
|
||||
REQUIRED_MODULES="$REQUIRED_MODULES dbus-1"
|
||||
REQUIRED_LIBS="$REQUIRED_LIBS dbus-1"
|
||||
fi
|
||||
CONFIG_LIB='$(top_builddir)/config/libconfig.a'
|
||||
AM_CONDITIONAL(DBUS, [test "x$DBUS" = xyes])
|
||||
|
||||
AM_CONDITIONAL(XV, [test "x$XV" = xyes])
|
||||
if test "x$XV" = xyes; then
|
||||
AC_DEFINE(XV, 1, [Support Xv extension])
|
||||
|
@ -532,10 +574,6 @@ if test "x$XVMC" = xyes; then
|
|||
AC_DEFINE(XvMCExtension, 1, [Build XvMC extension])
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(DGA, [test "x$DGA" = xyes])
|
||||
if test "x$DGA" = xyes; then
|
||||
AC_DEFINE(DGA, 1, [Support DGA extension])
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(COMPOSITE, [test "x$COMPOSITE" = xyes])
|
||||
if test "x$COMPOSITE" = xyes; then
|
||||
|
@ -615,10 +653,14 @@ AM_CONDITIONAL(DRI, test "x$DRI" = xyes)
|
|||
if test "x$DRI" = xyes; then
|
||||
AC_DEFINE(XF86DRI, 1, [Build DRI extension])
|
||||
PKG_CHECK_MODULES([DRIPROTO], [xf86driproto])
|
||||
PKG_CHECK_MODULES([LIBDRM], [libdrm])
|
||||
PKG_CHECK_MODULES([LIBDRM], [libdrm >= 2.3.0])
|
||||
PKG_CHECK_MODULES([GL], [glproto >= 1.4.1])
|
||||
PKG_CHECK_EXISTS(libdrm >= 2.2.0,
|
||||
[AC_DEFINE([HAVE_LIBDRM_2_2], 1,
|
||||
[Has version 2.2 (or newer) of the drm library])])
|
||||
AC_SUBST(DRIPROTO_CFLAGS)
|
||||
AC_SUBST(LIBDRM_CFLAGS)
|
||||
AC_SUBST(LIBDRM_LIBS)
|
||||
AC_SUBST(GL_CFLAGS)
|
||||
fi
|
||||
|
||||
|
@ -696,14 +738,6 @@ if test "x$DPMSExtension" = xyes; then
|
|||
AC_DEFINE(DPMSExtension, 1, [Support DPMS extension])
|
||||
fi
|
||||
|
||||
if test "x$XF86VIDMODE" = xyes; then
|
||||
AC_DEFINE(XF86VIDMODE, 1, [Support XFree86 Video Mode extension])
|
||||
fi
|
||||
|
||||
if test "x$XF86MISC" = xyes; then
|
||||
AC_DEFINE(XF86MISC, 1, [Support XFree86 miscellaneous extensions])
|
||||
fi
|
||||
|
||||
if test "x$XPRINT" = xauto; then
|
||||
PKG_CHECK_MODULES([XPRINTPROTO], [printproto], [XPRINT=yes], [XPRINT=no])
|
||||
fi
|
||||
|
@ -713,6 +747,11 @@ if test "x$XPRINT" = xyes; then
|
|||
REQUIRED_MODULES="$REQUIRED_MODULES printproto"
|
||||
fi
|
||||
|
||||
if test "x$BUILTIN_FONTS" = xyes; then
|
||||
AC_DEFINE(BUILTIN_FONTS, 1, [Use only built-in fonts])
|
||||
AC_DEFINE(NOFONTSERVERACCESS, 1, [Avoid using a font server])
|
||||
fi
|
||||
|
||||
if test "x$XCALIBRATE" = xyes && test "$KDRIVE" = yes; then
|
||||
AC_DEFINE(XCALIBRATE, 1, [Build XCalibrate extension])
|
||||
REQUIRED_MODULES="$REQUIRED_MODULES xcalibrateproto"
|
||||
|
@ -743,12 +782,9 @@ if test "$COMPOSITE" = yes; then
|
|||
fi
|
||||
MIEXT_DAMAGE_INC='-I$(top_srcdir)/miext/damage'
|
||||
|
||||
AM_CONDITIONAL(XINPUT, [test "x$XINPUT" = xyes])
|
||||
if test "x$XINPUT" = xyes; then
|
||||
AC_DEFINE(XINPUT, 1, [Support X Input extension])
|
||||
XI_LIB='$(top_builddir)/Xi/libXi.la'
|
||||
XI_INC='-I$(top_srcdir)/Xi'
|
||||
fi
|
||||
AC_DEFINE(XINPUT, 1, [Support X Input extension])
|
||||
XI_LIB='$(top_builddir)/Xi/libXi.la'
|
||||
XI_INC='-I$(top_srcdir)/Xi'
|
||||
|
||||
AM_CONDITIONAL(XF86UTILS, test "x$XF86UTILS" = xyes)
|
||||
|
||||
|
@ -764,6 +800,10 @@ XKB_STUB_LIB='$(top_builddir)/xkb/libxkbstubs.la'
|
|||
AC_CHECK_FUNC(strcasecmp, [], AC_DEFINE([NEED_STRCASECMP], 1,
|
||||
[Do not have `strcasecmp'.]))
|
||||
|
||||
if test "x$NULL_ROOT_CURSOR" = xyes; then
|
||||
AC_DEFINE(NULL_ROOT_CURSOR, 1, [Use an empty root cursor])
|
||||
fi
|
||||
|
||||
PKG_CHECK_MODULES([XDMCP], [xdmcp], [have_libxdmcp="yes"], [have_libxdmcp="no"])
|
||||
if test "x$have_libxdmcp" = xyes; then
|
||||
AC_CHECK_LIB(Xdmcp, XdmcpWrap, [have_xdmcpwrap="yes"], [have_xdmcpwrap="no"], [$XDMCP_LIBS])
|
||||
|
@ -840,11 +880,13 @@ AC_DEFINE(DDXOSINIT, 1, [Use OsVendorInit])
|
|||
AC_DEFINE(SERVER_LOCK, 1, [Use a lock to prevent multiple servers on a display])
|
||||
AC_DEFINE(SMART_SCHEDULE, 1, [Include time-based scheduler])
|
||||
AC_DEFINE(NO_LIBCWRAPPER, 1, [Define to 1 if modules should avoid the libcwrapper])
|
||||
AM_CONDITIONAL(DEBUG, test "x$DEBUGGING" = xyes)
|
||||
|
||||
if ! test "x$DEBUGGING" = xyes; then
|
||||
AC_DEFINE(NDEBUG, 1, [Disable some debugging code])
|
||||
if test "x$DEBUGGING" = xyes; then
|
||||
AC_DEFINE(DEBUG, 1, [Enable debugging code])
|
||||
else
|
||||
AC_DEFINE(NDEBUG, 1, [Disable some debugging code])
|
||||
fi
|
||||
AM_CONDITIONAL(DEBUG, [test "x$DEBUGGING" = xyes])
|
||||
|
||||
AC_DEFINE(USE_RGB_TXT, 1, [Use rgb.txt directly])
|
||||
AC_DEFINE(MITMISC, 1, [Support MIT Misc extension])
|
||||
|
@ -854,8 +896,13 @@ AC_DEFINE(XCMISC, 1, [Support XCMisc extension])
|
|||
AC_DEFINE(BIGREQS, 1, [Support BigRequests extension])
|
||||
AC_DEFINE(PIXPRIV, 1, [Support pixmap privates])
|
||||
|
||||
DIX_LIB='$(top_builddir)/dix/libdix.la'
|
||||
OS_LIB='$(top_builddir)/os/libos.la'
|
||||
if test "x$WDTRACE" != "xno" ; then
|
||||
DIX_LIB='$(top_builddir)/dix/dix.O'
|
||||
OS_LIB='$(top_builddir)/os/os.O'
|
||||
else
|
||||
DIX_LIB='$(top_builddir)/dix/libdix.la'
|
||||
OS_LIB='$(top_builddir)/os/libos.la'
|
||||
fi
|
||||
CWRAP_LIB='$(top_builddir)/os/libcwrapper.la'
|
||||
MI_LIB='$(top_builddir)/mi/libmi.la'
|
||||
MINIMI_LIB='$(top_builddir)/mi/libminimi.la'
|
||||
|
@ -872,10 +919,71 @@ PKG_CHECK_MODULES([XSERVERCFLAGS], [$REQUIRED_MODULES $REQUIRED_LIBS])
|
|||
PKG_CHECK_MODULES([XSERVERLIBS], [$REQUIRED_LIBS])
|
||||
|
||||
XSERVER_CFLAGS="${XSERVERCFLAGS_CFLAGS}"
|
||||
XSERVER_LIBS="${XSERVERLIBS_LIBS} ${SYS_LIBS} -lm"
|
||||
AC_SUBST([XSERVER_LIBS])
|
||||
XSERVER_LIBS="${XSERVERLIBS_LIBS} ${SYS_LIBS} ${LIBS}"
|
||||
AC_SUBST([SYS_LIBS])
|
||||
|
||||
# The Xorg binary needs to export symbols so that they can be used from modules
|
||||
# Some platforms require extra flags to do this. gcc should set these flags
|
||||
# when -rdynamic is passed to it, other compilers/linkers may need to be added
|
||||
# here.
|
||||
if test "x$GCC" = "xyes"; then
|
||||
GCC_WARNINGS1="-Wall -Wpointer-arith -Wstrict-prototypes"
|
||||
GCC_WARNINGS2="-Wmissing-prototypes -Wmissing-declarations"
|
||||
GCC_WARNINGS3="-Wnested-externs -fno-strict-aliasing"
|
||||
GCC_WARNINGS="$GCC_WARNINGS1 $GCC_WARNINGS2 $GCC_WARNINGS3"
|
||||
if test "x$WERROR" = "xyes"; then
|
||||
GCC_WARNINGS="${GCC_WARNINGS} -Werror"
|
||||
fi
|
||||
XSERVER_CFLAGS="$GCC_WARNINGS $XSERVER_CFLAGS"
|
||||
|
||||
LD_EXPORT_SYMBOLS_FLAG="-rdynamic"
|
||||
fi
|
||||
case $host_os in
|
||||
openbsd*)
|
||||
LD_EXPORT_SYMBOLS_FLAG="-Wl,--export-dynamic"
|
||||
;;
|
||||
esac
|
||||
AC_SUBST([LD_EXPORT_SYMBOLS_FLAG])
|
||||
|
||||
AC_CHECK_FUNCS([clock_gettime], [have_clock_gettime=yes],
|
||||
[AC_CHECK_LIB([rt], [clock_gettime], [have_clock_gettime=-lrt],
|
||||
[have_clock_gettime=no])])
|
||||
|
||||
AC_MSG_CHECKING([for a useful monotonic clock ...])
|
||||
|
||||
if ! test "x$have_clock_gettime" = xno; then
|
||||
if ! test "x$have_clock_gettime" = xyes; then
|
||||
CLOCK_LIBS="$have_clock_gettime"
|
||||
else
|
||||
CLOCK_LIBS=""
|
||||
fi
|
||||
|
||||
AC_RUN_IFELSE([
|
||||
#define _POSIX_C_SOURCE 199309L
|
||||
#include <time.h>
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
struct timespec tp;
|
||||
|
||||
if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
|
||||
return 0;
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
], [MONOTONIC_CLOCK=yes], [MONOTONIC_CLOCK=no],
|
||||
[MONOTONIC_CLOCK="cross compiling"])
|
||||
else
|
||||
MONOTONIC_CLOCK=no
|
||||
fi
|
||||
|
||||
AC_MSG_RESULT([$MONOTONIC_CLOCK])
|
||||
|
||||
if test "x$MONOTONIC_CLOCK" = xyes; then
|
||||
AC_DEFINE(MONOTONIC_CLOCK, 1, [Have monotonic clock from clock_gettime()])
|
||||
XSERVER_LIBS="$XSERVER_LIBS $CLOCK_LIBS"
|
||||
LIBS="$LIBS $CLOCK_LIBS"
|
||||
fi
|
||||
|
||||
dnl Imake defines SVR4 on SVR4 systems, and many files check for it, so
|
||||
dnl we need to replicate that here until those can all be fixed
|
||||
AC_MSG_CHECKING([if SVR4 needs to be defined])
|
||||
|
@ -890,6 +998,8 @@ AC_MSG_RESULT([yes])], AC_MSG_RESULT([no]))
|
|||
XSERVER_CFLAGS="$XSERVER_CFLAGS $CORE_INCS $XEXT_INC $COMPOSITE_INC $DAMAGE_INC $FIXES_INC $XI_INC $MI_INC $MIEXT_SHADOW_INC $MIEXT_LAYER_INC $MIEXT_DAMAGE_INC $RENDER_INC $RANDR_INC $FB_INC"
|
||||
AC_DEFINE_UNQUOTED(X_BYTE_ORDER,[$ENDIAN],[Endian order])
|
||||
|
||||
AC_SUBST([XSERVER_LIBS])
|
||||
|
||||
dnl ---------------------------------------------------------------------------
|
||||
dnl DDX section.
|
||||
dnl ---------------------------------------------------------------------------
|
||||
|
@ -949,7 +1059,7 @@ AC_MSG_RESULT([$XVFB])
|
|||
AM_CONDITIONAL(XVFB, [test "x$XVFB" = xyes])
|
||||
|
||||
if test "x$XVFB" = xyes; then
|
||||
XVFB_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $CWRAP_LIB $OS_LIB"
|
||||
XVFB_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $CONFIG_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $CWRAP_LIB $OS_LIB $LIBS"
|
||||
AC_SUBST([XVFB_LIBS])
|
||||
fi
|
||||
|
||||
|
@ -965,7 +1075,7 @@ AC_MSG_RESULT([$XNEST])
|
|||
AM_CONDITIONAL(XNEST, [test "x$XNEST" = xyes])
|
||||
|
||||
if test "x$XNEST" = xyes; then
|
||||
XNEST_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $CWRAP_LIB $OS_LIB"
|
||||
XNEST_LIBS="$XSERVER_LIBS $FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $CONFIG_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $CWRAP_LIB $OS_LIB $LIBS"
|
||||
AC_SUBST([XNEST_LIBS])
|
||||
fi
|
||||
|
||||
|
@ -1036,7 +1146,7 @@ if test "x$XGLX" = xyes; then
|
|||
fi
|
||||
|
||||
# XORG_CORE_LIBS is needed even if you're not building the Xorg DDX
|
||||
XORG_CORE_LIBS="$DIX_LIB"
|
||||
XORG_CORE_LIBS="$DIX_LIB $CONFIG_LIB"
|
||||
AC_SUBST([XORG_CORE_LIBS])
|
||||
|
||||
xorg_bus_linuxpci=no
|
||||
|
@ -1054,6 +1164,37 @@ if test "x$XORG" = xyes -o "x$XGL" = xyes; then
|
|||
XORG_CFLAGS="$XORGSERVER_CFLAGS -DHAVE_XORG_CONFIG_H"
|
||||
XORG_LIBS="$COMPOSITE_LIB $MI_LIB $FIXES_LIB $XEXTXORG_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XPSTUBS_LIB $OS_LIB"
|
||||
|
||||
if test "x$DGA" = xauto; then
|
||||
PKG_CHECK_MODULES(DGA, xf86dgaproto, [DGA=yes], [DGA=no])
|
||||
fi
|
||||
if test "x$DGA" = xyes; then
|
||||
XORG_MODULES="$XORG_MODULES xf86dgaproto"
|
||||
AC_DEFINE(DGA, 1, [Support DGA extension])
|
||||
AC_DEFINE(XFreeXDGA, 1, [Build XDGA support])
|
||||
fi
|
||||
|
||||
if test "x$XF86MISC" = xauto; then
|
||||
PKG_CHECK_MODULES(XF86MISC, xf86miscproto, [XF86MISC=yes], [XF86MISC=no])
|
||||
fi
|
||||
if test "x$XF86MISC" = xyes; then
|
||||
XORG_MODULES="$XORG_MODULES xf86miscproto"
|
||||
AC_DEFINE(XF86MISC, 1, [Support XFree86 miscellaneous extensions])
|
||||
fi
|
||||
|
||||
if test "x$XF86VIDMODE" = xauto; then
|
||||
PKG_CHECK_MODULES(XF86VIDMODE, xf86vidmodeproto, [XF86VIDMODE=yes], [XF86VIDMODE=no])
|
||||
fi
|
||||
if test "x$XF86VIDMODE" = xyes; then
|
||||
XORG_MODULES="$XORG_MODULES xf86vidmodeproto"
|
||||
AC_DEFINE(XF86VIDMODE, 1, [Support XFree86 Video Mode extension])
|
||||
fi
|
||||
|
||||
if test -n "$XORG_MODULES"; then
|
||||
PKG_CHECK_MODULES(XORG_MODULES, [$XORG_MODULES])
|
||||
XORG_CFLAGS="$XORG_CFLAGS $XORG_MODULES_CFLAGS"
|
||||
XORG_LIBS="$XORG_LIBS $XORG_MODULES_LIBS"
|
||||
fi
|
||||
|
||||
dnl Check to see if dlopen is in default libraries (like Solaris, which
|
||||
dnl has it in libc), or if libdl is needed to get it.
|
||||
AC_CHECK_FUNC([dlopen], [],
|
||||
|
@ -1070,7 +1211,6 @@ dnl has it in libc), or if libdl is needed to get it.
|
|||
fi
|
||||
XORG_OS="linux"
|
||||
XORG_OS_SUBDIR="linux"
|
||||
XORG_OS_KBD="Lnx"
|
||||
xorg_bus_linuxpci="yes"
|
||||
linux_acpi="no"
|
||||
case $host_cpu in
|
||||
|
@ -1089,30 +1229,10 @@ dnl has it in libc), or if libdl is needed to get it.
|
|||
*)
|
||||
;;
|
||||
esac
|
||||
|
||||
# check whether struct kbd_repeat has the 'period' field.
|
||||
# on kernels < 2.5.42 it's called 'rate' instead.
|
||||
AC_TRY_COMPILE([
|
||||
#include <linux/kd.h>
|
||||
#ifdef __sparc__
|
||||
#include <asm/param.h>
|
||||
#include <asm/kbio.h>
|
||||
#endif
|
||||
],[
|
||||
int main () {
|
||||
struct kbd_repeat k;
|
||||
k.period = 0;
|
||||
return 0;
|
||||
}],
|
||||
[period_field="period"],
|
||||
[period_field="rate"])
|
||||
AC_DEFINE_UNQUOTED(LNX_KBD_PERIOD_NAME, [$period_field],
|
||||
[Name of the period field in struct kbd_repeat])
|
||||
;;
|
||||
freebsd* | kfreebsd*-gnu)
|
||||
XORG_OS="freebsd"
|
||||
XORG_OS_SUBDIR="bsd"
|
||||
XORG_OS_KBD="BSD"
|
||||
case $host_cpu in
|
||||
i*86)
|
||||
;;
|
||||
|
@ -1124,7 +1244,6 @@ int main () {
|
|||
netbsd*)
|
||||
XORG_OS="netbsd"
|
||||
XORG_OS_SUBDIR="bsd"
|
||||
XORG_OS_KBD="BSD"
|
||||
case $host_cpu in
|
||||
i*86|amd64*|x86_64*|ia64*)
|
||||
;;
|
||||
|
@ -1136,7 +1255,6 @@ int main () {
|
|||
openbsd*)
|
||||
XORG_OS="openbsd"
|
||||
XORG_OS_SUBDIR="bsd"
|
||||
XORG_OS_KBD="BSD"
|
||||
case $host_cpu in
|
||||
i*86|amd64*|x86_64*|ia64*)
|
||||
;;
|
||||
|
@ -1243,7 +1361,6 @@ int main () {
|
|||
AC_SUBST([XORG_INCS])
|
||||
AC_SUBST([XORG_OS])
|
||||
AC_SUBST([XORG_OS_SUBDIR])
|
||||
AC_SUBST([XORG_OS_KBD])
|
||||
|
||||
AC_PATH_PROG(PERL, perl, no)
|
||||
dnl unlikely as this may be ...
|
||||
|
@ -1252,28 +1369,7 @@ int main () {
|
|||
fi
|
||||
AC_SUBST(PERL)
|
||||
|
||||
# The Xorg binary needs to export symbols so that they can be used from modules
|
||||
# Some platforms require extra flags to do this. gcc should set these flags
|
||||
# when -rdynamic is passed to it, other compilers/linkers may need to be added
|
||||
# here.
|
||||
if test "x$GCC" = "xyes"; then
|
||||
GCC_WARNINGS1="-Wall -Wpointer-arith -Wstrict-prototypes"
|
||||
GCC_WARNINGS2="-Wmissing-prototypes -Wmissing-declarations"
|
||||
GCC_WARNINGS3="-Wnested-externs -fno-strict-aliasing"
|
||||
GCC_WARNINGS="$GCC_WARNINGS1 $GCC_WARNINGS2 $GCC_WARNINGS3"
|
||||
if test "x$WERROR" = "xyes"; then
|
||||
GCC_WARNINGS="${GCC_WARNINGS} -Werror"
|
||||
fi
|
||||
XSERVER_CFLAGS="$GCC_WARNINGS $XSERVER_CFLAGS"
|
||||
LD_EXPORT_SYMBOLS_FLAG="-rdynamic"
|
||||
fi
|
||||
case $host_os in
|
||||
openbsd*)
|
||||
LD_EXPORT_SYMBOLS_FLAG="-Wl,--export-dynamic"
|
||||
;;
|
||||
esac
|
||||
AC_SUBST([XORG_CFLAGS])
|
||||
AC_SUBST([LD_EXPORT_SYMBOLS_FLAG])
|
||||
|
||||
dnl these only go in xorg-config.h
|
||||
XF86CONFIGFILE="xorg.conf"
|
||||
|
@ -1293,6 +1389,7 @@ int main () {
|
|||
AC_DEFINE_DIR(__XCONFIGFILE__, XF86CONFIGFILE, [Name of configuration file])
|
||||
AC_DEFINE_DIR(XF86CONFIGFILE, XF86CONFIGFILE, [Name of configuration file])
|
||||
AC_DEFINE_DIR(DEFAULT_MODULE_PATH, moduledir, [Default module search path])
|
||||
AC_DEFINE_DIR(DEFAULT_LIBRARY_PATH, libdir, [Default library install path])
|
||||
AC_DEFINE_DIR(DEFAULT_LOGPREFIX, LOGPREFIX, [Default log location])
|
||||
AC_DEFINE_UNQUOTED(__VENDORDWEBSUPPORT__, ["$VENDOR_WEB"], [Vendor web address for support])
|
||||
|
||||
|
@ -1322,6 +1419,7 @@ AM_CONDITIONAL([SOLARIS_ASM_INLINE], [test "x$solaris_asm_inline" = xyes])
|
|||
AM_CONDITIONAL(MFB, [test "x$XORG" = xyes])
|
||||
AM_CONDITIONAL(CFB, [test "x$XORG" = xyes])
|
||||
AM_CONDITIONAL(AFB, [test "x$XORG" = xyes])
|
||||
AM_CONDITIONAL(DGA, [test "x$DGA" = xyes])
|
||||
|
||||
dnl Xprint DDX
|
||||
|
||||
|
@ -1331,7 +1429,7 @@ AC_MSG_RESULT([$XPRINT])
|
|||
if test "x$XPRINT" = xyes; then
|
||||
PKG_CHECK_MODULES([XPRINT], [printproto x11 xfont $XDMCP_MODULES xau])
|
||||
XPRINT_EXTENSIONS="$XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $RENDER_LIB $COMPOSITE_LIB $RANDR_LIB $XI_LIB $FIXES_LIB $DAMAGE_LIB $XI_LIB $GLX_LIBS"
|
||||
XPRINT_LIBS="$XPRINT_LIBS $DIX_LIB $XKB_LIB $XKB_STUB_LIB $XPRINT_EXTENSIONS $MI_LIB $MIEXT_DAMAGE_LIB $CWRAP_LIB $OS_LIB"
|
||||
XPRINT_LIBS="$XPRINT_LIBS $DIX_LIB $CONFIG_LIB $XKB_LIB $XKB_STUB_LIB $XPRINT_EXTENSIONS $MI_LIB $MIEXT_DAMAGE_LIB $CWRAP_LIB $OS_LIB $LIBS"
|
||||
AC_SUBST([XPRINT_CFLAGS])
|
||||
AC_SUBST([XPRINT_LIBS])
|
||||
|
||||
|
@ -1460,16 +1558,60 @@ if test "$KDRIVE" = yes; then
|
|||
AC_DEFINE(KDRIVEDDXACTIONS,,[Build kdrive ddx])
|
||||
|
||||
AC_CHECK_HEADERS([sys/vm86.h sys/io.h])
|
||||
if test "$ac_cv_header_sys_vm86_h" = yes; then
|
||||
if test "$ac_cv_header_sys_vm86_h" = yes && test "x$KDRIVEVESA" = xauto; then
|
||||
KDRIVEVESA=yes
|
||||
fi
|
||||
|
||||
if test "x$KDRIVEVESA" = xyes; then
|
||||
KDRIVEFBDEVLIB=yes
|
||||
AC_DEFINE(KDRIVEVESA, 1, [Build VESA-based kdrive servers])
|
||||
fi
|
||||
|
||||
AC_CHECK_HEADERS([linux/fb.h])
|
||||
if test "$ac_cv_header_linux_fb_h" = yes; then
|
||||
if test "$ac_cv_header_linux_fb_h" = yes && test "x$XFBDEV" = xauto; then
|
||||
XFBDEV=yes
|
||||
fi
|
||||
|
||||
if test "x$XFBDEV" = xyes; then
|
||||
KDRIVEFBDEVLIB=yes
|
||||
AC_DEFINE(KDRIVEFBDEV, 1, [Build fbdev-based kdrive server])
|
||||
fi
|
||||
|
||||
# tslib...
|
||||
AC_CHECK_LIB(ts, ts_open, [HAVE_TSLIB="yes"])
|
||||
if test "x$TSLIB" = xauto && test "x$HAVE_TSLIB" = xyes; then
|
||||
TSLIB=yes
|
||||
fi
|
||||
|
||||
if test "x$TSLIB" = xyes; then
|
||||
if ! test "x$HAVE_TSLIB" = xyes; then
|
||||
AC_MSG_ERROR([tslib must be installed to build the tslib input driver.])
|
||||
fi
|
||||
TSLIB_LIBS="-lts"
|
||||
AC_DEFINE(TSLIB, 1, [Have tslib support])
|
||||
fi
|
||||
|
||||
AC_CHECK_HEADERS([SDL/SDL.h])
|
||||
if test x"$ac_cv_header_SDL_SDL_h" = xyes && test "x$XSDL" = xauto; then
|
||||
XSDL=yes
|
||||
fi
|
||||
|
||||
if test x"$XSDL" = xyes; then
|
||||
# PKG_CHECK_MODULES(XSDL_EXTRA, Xfont xau $XDMCP_MODULES)
|
||||
AC_DEFINE(XSDLSERVER,1,[Build Xsdl server])
|
||||
XSDL_LIBS="`sdl-config --libs` $XSERVER_LIBS"
|
||||
XSDL_INCS="`sdl-config --cflags` $XSERVER_CFLAGS"
|
||||
fi
|
||||
|
||||
PKG_CHECK_MODULES(XEPHYR, x11 xext xfont xau xdmcp, [xephyr="yes"], [xephyr="no"])
|
||||
if test "x$XEPHYR" = xauto; then
|
||||
XEPHYR=$xephyr
|
||||
fi
|
||||
|
||||
# Xephyr needs nanosleep() which is in librt on Solaris
|
||||
AC_CHECK_FUNC([nanosleep], [],
|
||||
AC_CHECK_LIB([rt], [nanosleep], XEPHYR_LIBS="$XEPHYR_LIBS -lrt"))
|
||||
XEPHYR_LIBS="$XEPHYR_LIBS $XSERVER_LIBS"
|
||||
if test "x$TSLIB" = xyes; then
|
||||
PKG_CHECK_MODULES([TSLIB], [tslib-0.0], [HAVE_TSLIB="yes"], [HAVE_TSLIB="no"])
|
||||
if test "x$HAVE_TSLIB" = xno; then
|
||||
|
@ -1491,55 +1633,51 @@ if test "$KDRIVE" = yes; then
|
|||
# $MIEXT_SHADOW_LIB $XPSTUBS_LIB"
|
||||
KDRIVE_PURE_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $OS_LIB"
|
||||
KDRIVE_LIB='$(top_builddir)/hw/kdrive/src/libkdrive.a'
|
||||
KDRIVE_OS_LIB='$(top_builddir)/hw/kdrive/linux/liblinux.a'
|
||||
case $host_os in
|
||||
*linux*)
|
||||
KDRIVE_OS_LIB='$(top_builddir)/hw/kdrive/linux/liblinux.a'
|
||||
KDRIVELINUX=yes
|
||||
;;
|
||||
esac
|
||||
KDRIVE_STUB_LIB='$(top_builddir)/hw/kdrive/src/libkdrivestubs.a'
|
||||
KDRIVE_LIBS="$DIX_LIB $KDRIVE_LIB $KDRIVE_OS_LIB $KDRIVE_PURE_LIBS $KDRIVE_STUB_LIB $TSLIB_LIBS"
|
||||
KDRIVE_LIBS="$XSERVERLIBS_LIBS $DIX_LIB $CONFIG_LIB $KDRIVE_LIB $TSLIB_LIBS $KDRIVE_OS_LIB $KDRIVE_PURE_LIBS $KDRIVE_STUB_LIB"
|
||||
|
||||
# check if we can build Xephyr
|
||||
PKG_CHECK_MODULES(XEPHYR, x11 xext xfont xau xdmcp, [xephyr="yes"], [xephyr="no"])
|
||||
|
||||
# check for SDL SDK
|
||||
AC_CHECK_HEADERS([SDL/SDL.h])
|
||||
if test "x$XSDL" = xauto; then
|
||||
XSDL="$ac_cv_header_SDL_SDL_h"
|
||||
fi
|
||||
XEPHYR_LIBS="$XEPHYR_LIBS $XSERVER_LIBS"
|
||||
|
||||
# Xephyr needs nanosleep() which is in librt on Solaris
|
||||
AC_CHECK_FUNC([nanosleep], [],
|
||||
AC_CHECK_LIB([rt], [nanosleep], XEPHYR_LIBS="$XEPHYR_LIBS -lrt"))
|
||||
|
||||
AC_SUBST([XEPHYR_LIBS])
|
||||
AC_SUBST([XEPHYR_INCS])
|
||||
AC_SUBST([XSDL_LIBS])
|
||||
AC_SUBST([XSDL_INCS])
|
||||
fi
|
||||
AC_SUBST(KDRIVE_INCS)
|
||||
AC_SUBST(KDRIVE_PURE_INCS)
|
||||
AC_SUBST(KDRIVE_CFLAGS)
|
||||
AC_SUBST(KDRIVE_PURE_LIBS)
|
||||
AC_SUBST(KDRIVE_LIBS)
|
||||
AC_SUBST([KDRIVE_INCS])
|
||||
AC_SUBST([KDRIVE_PURE_INCS])
|
||||
AC_SUBST([KDRIVE_CFLAGS])
|
||||
AC_SUBST([KDRIVE_PURE_LIBS])
|
||||
AC_SUBST([KDRIVE_LIBS])
|
||||
AM_CONDITIONAL(KDRIVELINUX, [test "x$KDRIVELINUX" = xyes])
|
||||
AM_CONDITIONAL(TSLIB, [test "x$HAVE_TSLIB" = xyes])
|
||||
AM_CONDITIONAL(H3600_TS, false)
|
||||
AM_CONDITIONAL(KDRIVEVESA, [test "x$KDRIVEVESA" = xyes])
|
||||
AM_CONDITIONAL(KDRIVEFBDEV, [test "x$XFBDEV" = xyes])
|
||||
AM_CONDITIONAL(XSDLSERVER, [test x"$XSDL" = xyes])
|
||||
AM_CONDITIONAL(XEPHYR, [test "x$KDRIVE" = xyes && test "x$XEPHYR" = xyes])
|
||||
AM_CONDITIONAL(BUILD_KDRIVEFBDEVLIB, [test "x$KDRIVE" = xyes && test "x$KDRIVEFBDEVLIB" = xyes])
|
||||
AM_CONDITIONAL(XFAKESERVER, [test "x$KDRIVE" = xyes && test "x$XFAKE" = xyes])
|
||||
AM_CONDITIONAL(KDRIVEVESA, [test x"$ac_cv_header_sys_vm86_h" = xyes])
|
||||
AM_CONDITIONAL(KDRIVEFBDEV, [test x"$ac_cv_header_linux_fb_h" = xyes])
|
||||
|
||||
# Xephyr needs nanosleep() which is in librt on Solaris
|
||||
AC_CHECK_FUNC([nanosleep], [],
|
||||
AC_CHECK_LIB([rt], [nanosleep], XEPHYR_LIBS="$XEPHYR_LIBS -lrt"))
|
||||
|
||||
AM_CONDITIONAL(XEPHYR, [test x"$xephyr" = xyes])
|
||||
XEPHYR_LIBS="$XEPHYR_LIBS $XSERVER_LIBS"
|
||||
AC_SUBST([XEPHYR_LIBS])
|
||||
AC_SUBST([XEPHYR_INCS])
|
||||
|
||||
if test x"$XSDL" = xyes; then
|
||||
AC_DEFINE(XSDLSERVER,,[Build Xsdl server])
|
||||
XSDL_LIBS="`sdl-config --libs` $XSERVER_LIBS"
|
||||
XSDL_INCS="`sdl-config --cflags` $XSERVER_CFLAGS"
|
||||
fi
|
||||
AM_CONDITIONAL(XSDLSERVER, [test x"$XSDL" = xyes])
|
||||
AC_SUBST([XSDL_LIBS])
|
||||
AC_SUBST([XSDL_INCS])
|
||||
|
||||
|
||||
dnl these only go in xkb-config.h (which is shared by the Xorg and Xnest servers)
|
||||
AC_DEFINE(__XKBDEFRULES__, "xorg", [Default XKB rules])
|
||||
AC_DEFINE_DIR(XKB_BASE_DIRECTORY, XKBPATH, [Path to XKB data])
|
||||
AC_DEFINE_DIR(XKB_BIN_DIRECTORY, bindir, [Path to XKB bin dir])
|
||||
|
||||
# Make sure XKM_OUTPUT_DIR is an absolute path
|
||||
|
||||
XKBOUTPUT_FIRSTCHAR=`echo $XKBOUTPUT | cut -b 1`
|
||||
|
||||
if [[ x$XKBOUTPUT_FIRSTCHAR != x/ ]] ; then
|
||||
|
@ -1557,7 +1695,6 @@ AC_DEFINE_DIR(XKM_OUTPUT_DIR, XKBOUTPUT, [Path to XKB output dir])
|
|||
AC_SUBST(XKB_COMPILED_DIR)
|
||||
|
||||
dnl and the rest of these are generic, so they're in config.h
|
||||
AC_DEFINE(XFreeXDGA, 1, [Build XDGA support])
|
||||
AC_DEFINE(XResExtension, 1, [Build XRes extension])
|
||||
|
||||
dnl CYGWIN does not define fd_set if _POSIX_SOURCE is defined
|
||||
|
@ -1578,9 +1715,11 @@ esac
|
|||
AC_DEFINE_DIR(PROJECTROOT, prefix, [Overall prefix])
|
||||
|
||||
dnl xorgconfig CLI configuration utility
|
||||
PKG_CHECK_MODULES([XORGCONFIG_DEP], [xkbfile x11])
|
||||
AC_SUBST(XORGCONFIG_DEP_CFLAGS)
|
||||
AC_SUBST(XORGCONFIG_DEP_LIBS)
|
||||
if test "x$XORG" = xyes; then
|
||||
PKG_CHECK_MODULES([XORGCONFIG_DEP], [xkbfile x11])
|
||||
AC_SUBST(XORGCONFIG_DEP_CFLAGS)
|
||||
AC_SUBST(XORGCONFIG_DEP_LIBS)
|
||||
fi
|
||||
|
||||
dnl xorgcfg GUI configuration utility
|
||||
AC_ARG_ENABLE(xorgcfg, AS_HELP_STRING([--enable-xorgcfg],
|
||||
|
@ -1626,13 +1765,11 @@ AM_CONDITIONAL(BUILD_KBD_MODE, [test x$BUILD_KBD_MODE = xyes])
|
|||
AM_CONDITIONAL(BSD_KBD_MODE, [test x$KBD_MODE_TYPE = xbsd])
|
||||
AM_CONDITIONAL(SUN_KBD_MODE, [test x$KBD_MODE_TYPE = xsun])
|
||||
|
||||
CFLAGS="$XSERVER_CFLAGS $CFLAGS"
|
||||
AC_SUBST([CFLAGS])
|
||||
|
||||
BUILD_DATE="$(date +'%Y%m%d')"
|
||||
AC_SUBST([BUILD_DATE])
|
||||
|
||||
DIX_CFLAGS="-DHAVE_DIX_CONFIG_H"
|
||||
DIX_CFLAGS="-DHAVE_DIX_CONFIG_H $XSERVER_CFLAGS"
|
||||
|
||||
AC_SUBST([DIX_CFLAGS])
|
||||
|
||||
AC_SUBST([libdir exec_prefix prefix])
|
||||
|
@ -1672,6 +1809,7 @@ XTrap/Makefile
|
|||
mfb/Makefile
|
||||
cfb/Makefile
|
||||
cfb32/Makefile
|
||||
config/Makefile
|
||||
mi/Makefile
|
||||
miext/Makefile
|
||||
miext/damage/Makefile
|
||||
|
@ -1707,7 +1845,6 @@ hw/xfree86/loader/Makefile
|
|||
hw/xfree86/os-support/Makefile
|
||||
hw/xfree86/os-support/bsd/Makefile
|
||||
hw/xfree86/os-support/bus/Makefile
|
||||
hw/xfree86/os-support/drm/Makefile
|
||||
hw/xfree86/os-support/hurd/Makefile
|
||||
hw/xfree86/os-support/misc/Makefile
|
||||
hw/xfree86/os-support/linux/Makefile
|
||||
|
|
|
@ -34,6 +34,7 @@ MANDEFS = \
|
|||
-D__miscmansuffix__=$(MISC_MAN_SUFFIX) \
|
||||
-D__drivermansuffix__=$(DRIVER_MAN_SUFFIX) \
|
||||
-D__adminmansuffix__=$(ADMIN_MAN_SUFFIX) \
|
||||
-D__mandir__=$(mandir) \
|
||||
-D__projectroot__=$(prefix) \
|
||||
-D__xconfigfile__=$(__XCONFIGFILE__) -D__xconfigdir__=$(XCONFIGDIR) \
|
||||
-D__xlogfile__=$(XLOGFILE) -D__xservername__=$(XSERVERNAME)
|
||||
|
|
|
@ -17,6 +17,7 @@ libdix_la_SOURCES = \
|
|||
extension.c \
|
||||
ffs.c \
|
||||
gc.c \
|
||||
getevents.c \
|
||||
globals.c \
|
||||
glyphcurs.c \
|
||||
grabs.c \
|
||||
|
@ -37,4 +38,22 @@ libxpstubs_la_SOURCES = \
|
|||
|
||||
INCLUDES = -I$(top_srcdir)/Xprint
|
||||
|
||||
EXTRA_DIST = buildatoms BuiltInAtoms CHANGES
|
||||
EXTRA_DIST = buildatoms BuiltInAtoms CHANGES Xserver.d Xserver-dtrace.h.in
|
||||
|
||||
if XSERVER_DTRACE
|
||||
# Generate dtrace header file for C sources to include
|
||||
BUILT_SOURCES = Xserver-dtrace.h
|
||||
|
||||
Xserver-dtrace.h: $(srcdir)/Xserver.d
|
||||
$(DTRACE) -C -h -o $@ -s $(srcdir)/Xserver.d \
|
||||
|| cp Xserver-dtrace.h.in $@
|
||||
|
||||
# Generate dtrace object code for probes in libdix
|
||||
dtrace-dix.o: $(top_srcdir)/dix/Xserver.d $(am_libdix_la_OBJECTS)
|
||||
$(DTRACE) -G -C -o $@ -s $(top_srcdir)/dix/Xserver.d .libs/*.o
|
||||
|
||||
noinst_PROGRAMS = dix.O
|
||||
|
||||
dix.O: dtrace-dix.o $(am_libdix_la_OBJECTS)
|
||||
ld -r -o $@ .libs/*.o
|
||||
endif
|
||||
|
|
100
dix/Xserver-dtrace.h.in
Normal file
100
dix/Xserver-dtrace.h.in
Normal file
|
@ -0,0 +1,100 @@
|
|||
/* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, and/or sell copies of the Software, and to permit persons
|
||||
* to whom the Software is furnished to do so, provided that the above
|
||||
* copyright notice(s) and this permission notice appear in all copies of
|
||||
* the Software and that both the above copyright notice(s) and this
|
||||
* permission notice appear in supporting documentation.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
|
||||
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
|
||||
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
|
||||
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
|
||||
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
|
||||
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the name of a copyright holder
|
||||
* shall not be used in advertising or otherwise to promote the sale, use
|
||||
* or other dealings in this Software without prior written authorization
|
||||
* of the copyright holder.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Generated by dtrace(1M), and then modified for backwards compatibility
|
||||
* with older versions of dtrace. Used if dtrace -h fails.
|
||||
* (Since _ENABLED support was added after dtrace -h, this assumes if
|
||||
* dtrace -h fails, _ENABLED will too.)
|
||||
*/
|
||||
|
||||
#ifndef _XSERVER_DTRACE_H
|
||||
#define _XSERVER_DTRACE_H
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if _DTRACE_VERSION
|
||||
|
||||
#define XSERVER_CLIENT_AUTH(arg0, arg1, arg2, arg3) \
|
||||
__dtrace_Xserver___client__auth(arg0, arg1, arg2, arg3)
|
||||
#define XSERVER_CLIENT_CONNECT(arg0, arg1) \
|
||||
__dtrace_Xserver___client__connect(arg0, arg1)
|
||||
#define XSERVER_CLIENT_DISCONNECT(arg0) \
|
||||
__dtrace_Xserver___client__disconnect(arg0)
|
||||
#define XSERVER_REQUEST_DONE(arg0, arg1, arg2, arg3, arg4) \
|
||||
__dtrace_Xserver___request__done(arg0, arg1, arg2, arg3, arg4)
|
||||
#define XSERVER_REQUEST_START(arg0, arg1, arg2, arg3, arg4) \
|
||||
__dtrace_Xserver___request__start(arg0, arg1, arg2, arg3, arg4)
|
||||
#define XSERVER_RESOURCE_ALLOC(arg0, arg1, arg2, arg3) \
|
||||
__dtrace_Xserver___resource__alloc(arg0, arg1, arg2, arg3)
|
||||
#define XSERVER_RESOURCE_FREE(arg0, arg1, arg2, arg3) \
|
||||
__dtrace_Xserver___resource__free(arg0, arg1, arg2, arg3)
|
||||
#define XSERVER_SEND_EVENT(arg0, arg1, arg2) \
|
||||
__dtrace_Xserver___send__event(arg0, arg1, arg2)
|
||||
|
||||
|
||||
extern void __dtrace_Xserver___client__auth(int, string, pid_t, zoneid_t);
|
||||
extern void __dtrace_Xserver___client__connect(int, int);
|
||||
extern void __dtrace_Xserver___client__disconnect(int);
|
||||
extern void __dtrace_Xserver___request__done(string, uint8_t, uint32_t, int, int);
|
||||
extern void __dtrace_Xserver___request__start(string, uint8_t, uint16_t, int, void *);
|
||||
extern void __dtrace_Xserver___resource__alloc(uint32_t, uint32_t, void *, string);
|
||||
extern void __dtrace_Xserver___resource__free(uint32_t, uint32_t, void *, string);
|
||||
extern void __dtrace_Xserver___send__event(int, uint8_t, void *);
|
||||
|
||||
#else
|
||||
|
||||
#define XSERVER_CLIENT_AUTH(arg0, arg1, arg2, arg3)
|
||||
#define XSERVER_CLIENT_CONNECT(arg0, arg1)
|
||||
#define XSERVER_CLIENT_DISCONNECT(arg0)
|
||||
#define XSERVER_REQUEST_DONE(arg0, arg1, arg2, arg3, arg4)
|
||||
#define XSERVER_REQUEST_START(arg0, arg1, arg2, arg3, arg4)
|
||||
#define XSERVER_RESOURCE_ALLOC(arg0, arg1, arg2, arg3)
|
||||
#define XSERVER_RESOURCE_FREE(arg0, arg1, arg2, arg3)
|
||||
#define XSERVER_SEND_EVENT(arg0, arg1, arg2)
|
||||
|
||||
#endif
|
||||
|
||||
#define XSERVER_CLIENT_AUTH_ENABLED() (1)
|
||||
#define XSERVER_CLIENT_CONNECT_ENABLED() (1)
|
||||
#define XSERVER_CLIENT_DISCONNECT_ENABLED() (1)
|
||||
#define XSERVER_REQUEST_DONE_ENABLED() (1)
|
||||
#define XSERVER_REQUEST_START_ENABLED() (1)
|
||||
#define XSERVER_RESOURCE_ALLOC_ENABLED() (1)
|
||||
#define XSERVER_RESOURCE_FREE_ENABLED() (1)
|
||||
#define XSERVER_SEND_EVENT_ENABLED() (1)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _XSERVER_DTRACE_H */
|
59
dix/Xserver.d
Normal file
59
dix/Xserver.d
Normal file
|
@ -0,0 +1,59 @@
|
|||
/* Copyright 2005-2006 Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, and/or sell copies of the Software, and to permit persons
|
||||
* to whom the Software is furnished to do so, provided that the above
|
||||
* copyright notice(s) and this permission notice appear in all copies of
|
||||
* the Software and that both the above copyright notice(s) and this
|
||||
* permission notice appear in supporting documentation.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
|
||||
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
|
||||
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
|
||||
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
|
||||
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
|
||||
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the name of a copyright holder
|
||||
* shall not be used in advertising or otherwise to promote the sale, use
|
||||
* or other dealings in this Software without prior written authorization
|
||||
* of the copyright holder.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Xserver dtrace provider definition
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
provider Xserver {
|
||||
/* reqType, data, length, client id, request buffer */
|
||||
probe request__start(string, uint8_t, uint16_t, int, void *);
|
||||
/* reqType, data, sequence, client id, result */
|
||||
probe request__done(string, uint8_t, uint32_t, int, int);
|
||||
/* client id, client fd */
|
||||
probe client__connect(int, int);
|
||||
/* client id, client address, client pid, client zone id */
|
||||
probe client__auth(int, string, pid_t, zoneid_t);
|
||||
/* client id */
|
||||
probe client__disconnect(int);
|
||||
/* resource id, resource type, value, resource type name */
|
||||
probe resource__alloc(uint32_t, uint32_t, void *, string);
|
||||
/* resource id, resource type, value, resource type name */
|
||||
probe resource__free(uint32_t, uint32_t, void *, string);
|
||||
/* client id, event type, event* */
|
||||
probe send__event(int, uint8_t, void *);
|
||||
};
|
||||
|
||||
#pragma D attributes Unstable/Unstable/Common provider Xserver provider
|
||||
#pragma D attributes Private/Private/Unknown provider Xserver module
|
||||
#pragma D attributes Private/Private/Unknown provider Xserver function
|
||||
#pragma D attributes Unstable/Unstable/Common provider Xserver name
|
||||
#pragma D attributes Unstable/Unstable/Common provider Xserver args
|
||||
|
967
dix/devices.c
967
dix/devices.c
File diff suppressed because it is too large
Load Diff
163
dix/dispatch.c
163
dix/dispatch.c
|
@ -74,6 +74,36 @@ Equipment Corporation.
|
|||
|
||||
******************************************************************/
|
||||
|
||||
/* XSERVER_DTRACE additions:
|
||||
* Copyright 2005-2006 Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, and/or sell copies of the Software, and to permit persons
|
||||
* to whom the Software is furnished to do so, provided that the above
|
||||
* copyright notice(s) and this permission notice appear in all copies of
|
||||
* the Software and that both the above copyright notice(s) and this
|
||||
* permission notice appear in supporting documentation.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
|
||||
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
|
||||
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
|
||||
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
|
||||
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
|
||||
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the name of a copyright holder
|
||||
* shall not be used in advertising or otherwise to promote the sale, use
|
||||
* or other dealings in this Software without prior written authorization
|
||||
* of the copyright holder.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
|
@ -104,9 +134,7 @@ int ProcInitialConnection();
|
|||
#include "panoramiX.h"
|
||||
#include "panoramiXsrv.h"
|
||||
#endif
|
||||
#ifdef XACE
|
||||
#include "xace.h"
|
||||
#endif
|
||||
#ifdef XAPPGROUP
|
||||
#include "appgroup.h"
|
||||
#endif
|
||||
|
@ -118,6 +146,17 @@ int ProcInitialConnection();
|
|||
#include <X11/extensions/XKBsrv.h>
|
||||
#endif
|
||||
|
||||
#ifdef XSERVER_DTRACE
|
||||
#include <sys/types.h>
|
||||
typedef const char *string;
|
||||
#include "Xserver-dtrace.h"
|
||||
|
||||
char *RequestNames[256];
|
||||
static void LoadRequestNames(void);
|
||||
static void FreeRequestNames(void);
|
||||
#define GetRequestName(i) (RequestNames[i])
|
||||
#endif
|
||||
|
||||
#define mskcnt ((MAXCLIENTS + 31) / 32)
|
||||
#define BITMASK(i) (1U << ((i) & 31))
|
||||
#define MASKIDX(i) ((i) >> 5)
|
||||
|
@ -372,6 +411,10 @@ Dispatch(void)
|
|||
if (!clientReady)
|
||||
return;
|
||||
|
||||
#ifdef XSERVER_DTRACE
|
||||
LoadRequestNames();
|
||||
#endif
|
||||
|
||||
while (!dispatchException)
|
||||
{
|
||||
if (*icheck[0] != *icheck[1])
|
||||
|
@ -447,20 +490,24 @@ Dispatch(void)
|
|||
client->requestLogIndex = 0;
|
||||
client->requestLog[client->requestLogIndex] = MAJOROP;
|
||||
client->requestLogIndex++;
|
||||
#endif
|
||||
#ifdef XSERVER_DTRACE
|
||||
XSERVER_REQUEST_START(GetRequestName(MAJOROP), MAJOROP,
|
||||
((xReq *)client->requestBuffer)->length,
|
||||
client->index, client->requestBuffer);
|
||||
#endif
|
||||
if (result > (maxBigRequestSize << 2))
|
||||
result = BadLength;
|
||||
else
|
||||
#ifdef XACE
|
||||
{
|
||||
else {
|
||||
XaceHook(XACE_AUDIT_BEGIN, client);
|
||||
result = (* client->requestVector[MAJOROP])(client);
|
||||
XaceHook(XACE_AUDIT_END, client, result);
|
||||
}
|
||||
#else
|
||||
result = (* client->requestVector[MAJOROP])(client);
|
||||
#endif /* XACE */
|
||||
|
||||
#ifdef XSERVER_DTRACE
|
||||
XSERVER_REQUEST_DONE(GetRequestName(MAJOROP), MAJOROP,
|
||||
client->sequence, client->index, result);
|
||||
#endif
|
||||
|
||||
if (result != Success)
|
||||
{
|
||||
if (client->noClientException != Success)
|
||||
|
@ -491,6 +538,9 @@ Dispatch(void)
|
|||
KillAllClients();
|
||||
DEALLOCATE_LOCAL(clientReady);
|
||||
dispatchException &= ~DE_RESET;
|
||||
#ifdef XSERVER_DTRACE
|
||||
FreeRequestNames();
|
||||
#endif
|
||||
}
|
||||
|
||||
#undef MAJOROP
|
||||
|
@ -1105,14 +1155,11 @@ ProcConvertSelection(register ClientPtr client)
|
|||
i = 0;
|
||||
while ((i < NumCurrentSelections) &&
|
||||
CurrentSelections[i].selection != stuff->selection) i++;
|
||||
if ((i < NumCurrentSelections) &&
|
||||
(CurrentSelections[i].window != None)
|
||||
#ifdef XACE
|
||||
&& XaceHook(XACE_RESOURCE_ACCESS, client,
|
||||
CurrentSelections[i].window, RT_WINDOW,
|
||||
SecurityReadAccess, CurrentSelections[i].pWin)
|
||||
#endif
|
||||
)
|
||||
if ((i < NumCurrentSelections) &&
|
||||
(CurrentSelections[i].window != None) &&
|
||||
XaceHook(XACE_RESOURCE_ACCESS, client,
|
||||
CurrentSelections[i].window, RT_WINDOW,
|
||||
SecurityReadAccess, CurrentSelections[i].pWin))
|
||||
{
|
||||
event.u.u.type = SelectionRequest;
|
||||
event.u.selectionRequest.time = stuff->time;
|
||||
|
@ -2102,9 +2149,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
|
|||
Mask plane = 0;
|
||||
char *pBuf;
|
||||
xGetImageReply xgi;
|
||||
#ifdef XACE
|
||||
RegionPtr pVisibleRegion = NULL;
|
||||
#endif
|
||||
|
||||
if ((format != XYPixmap) && (format != ZPixmap))
|
||||
{
|
||||
|
@ -2208,17 +2253,16 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
|
|||
WriteReplyToClient(client, sizeof (xGetImageReply), &xgi);
|
||||
}
|
||||
|
||||
#ifdef XACE
|
||||
if (pDraw->type == DRAWABLE_WINDOW &&
|
||||
!XaceHook(XACE_DRAWABLE_ACCESS, client, pDraw))
|
||||
{
|
||||
pVisibleRegion = NotClippedByChildren((WindowPtr)pDraw);
|
||||
if (pVisibleRegion)
|
||||
{
|
||||
REGION_TRANSLATE(pDraw->pScreen, pVisibleRegion, -pDraw->x, -pDraw->y);
|
||||
REGION_TRANSLATE(pDraw->pScreen, pVisibleRegion,
|
||||
-pDraw->x, -pDraw->y);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (linesPerBuf == 0)
|
||||
{
|
||||
|
@ -2238,12 +2282,10 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
|
|||
format,
|
||||
planemask,
|
||||
(pointer) pBuf);
|
||||
#ifdef XACE
|
||||
if (pVisibleRegion)
|
||||
XaceCensorImage(client, pVisibleRegion, widthBytesLine,
|
||||
pDraw, x, y + linesDone, width,
|
||||
nlines, format, pBuf);
|
||||
#endif
|
||||
|
||||
/* Note that this is NOT a call to WriteSwappedDataToClient,
|
||||
as we do NOT byte swap */
|
||||
|
@ -2279,13 +2321,11 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
|
|||
format,
|
||||
plane,
|
||||
(pointer)pBuf);
|
||||
#ifdef XACE
|
||||
if (pVisibleRegion)
|
||||
XaceCensorImage(client, pVisibleRegion,
|
||||
widthBytesLine,
|
||||
pDraw, x, y + linesDone, width,
|
||||
nlines, format, pBuf);
|
||||
#endif
|
||||
|
||||
/* Note: NOT a call to WriteSwappedDataToClient,
|
||||
as we do NOT byte swap */
|
||||
|
@ -2307,10 +2347,8 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
|
|||
}
|
||||
}
|
||||
}
|
||||
#ifdef XACE
|
||||
if (pVisibleRegion)
|
||||
REGION_DESTROY(pDraw->pScreen, pVisibleRegion);
|
||||
#endif
|
||||
if (!im_return)
|
||||
DEALLOCATE_LOCAL(pBuf);
|
||||
return (client->noClientException);
|
||||
|
@ -2459,7 +2497,7 @@ ProcCreateColormap(register ClientPtr client)
|
|||
return(result);
|
||||
}
|
||||
client->errorValue = stuff->visual;
|
||||
return(BadValue);
|
||||
return(BadMatch);
|
||||
}
|
||||
|
||||
int
|
||||
|
@ -3281,13 +3319,11 @@ ProcListHosts(register ClientPtr client)
|
|||
/* REQUEST(xListHostsReq); */
|
||||
|
||||
REQUEST_SIZE_MATCH(xListHostsReq);
|
||||
#ifdef XACE
|
||||
|
||||
/* untrusted clients can't list hosts */
|
||||
if (!XaceHook(XACE_HOSTLIST_ACCESS, client, SecurityReadAccess))
|
||||
{
|
||||
return BadAccess;
|
||||
}
|
||||
#endif
|
||||
|
||||
result = GetHosts(&pdata, &nHosts, &len, &reply.enabled);
|
||||
if (result != Success)
|
||||
return(result);
|
||||
|
@ -3565,6 +3601,9 @@ CloseDownClient(register ClientPtr client)
|
|||
CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
|
||||
}
|
||||
FreeClientResources(client);
|
||||
#ifdef XSERVER_DTRACE
|
||||
XSERVER_CLIENT_DISCONNECT(client->index);
|
||||
#endif
|
||||
if (client->index < nextFreeClientID)
|
||||
nextFreeClientID = client->index;
|
||||
clients[client->index] = NullClient;
|
||||
|
@ -3618,7 +3657,6 @@ extern unsigned totalClientSize;
|
|||
|
||||
void InitClient(ClientPtr client, int i, pointer ospriv)
|
||||
{
|
||||
bzero(client, totalClientSize);
|
||||
client->index = i;
|
||||
client->sequence = 0;
|
||||
client->clientAsMask = ((Mask)i) << CLIENTOFFSET;
|
||||
|
@ -3991,3 +4029,60 @@ MarkClientException(ClientPtr client)
|
|||
{
|
||||
client->noClientException = -1;
|
||||
}
|
||||
|
||||
#ifdef XSERVER_DTRACE
|
||||
#include <ctype.h>
|
||||
|
||||
/* Load table of request names for dtrace probes */
|
||||
static void LoadRequestNames(void)
|
||||
{
|
||||
int i;
|
||||
FILE *xedb;
|
||||
extern void LoadExtensionNames(char **RequestNames);
|
||||
|
||||
bzero(RequestNames, 256 * sizeof(char *));
|
||||
|
||||
xedb = fopen(XERRORDB_PATH, "r");
|
||||
if (xedb != NULL) {
|
||||
char buf[256];
|
||||
while (fgets(buf, sizeof(buf), xedb)) {
|
||||
if ((strncmp("XRequest.", buf, 9) == 0) && (isdigit(buf[9]))) {
|
||||
char *name;
|
||||
i = strtol(buf + 9, &name, 10);
|
||||
if (RequestNames[i] == 0) {
|
||||
char *end = strchr(name, '\n');
|
||||
if (end) { *end = '\0'; }
|
||||
RequestNames[i] = strdup(name + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
fclose(xedb);
|
||||
}
|
||||
|
||||
LoadExtensionNames(RequestNames);
|
||||
|
||||
for (i = 0; i < 256; i++) {
|
||||
if (RequestNames[i] == 0) {
|
||||
#define RN_SIZE 12 /* "Request#' + up to 3 digits + \0 */
|
||||
RequestNames[i] = xalloc(RN_SIZE);
|
||||
if (RequestNames[i]) {
|
||||
snprintf(RequestNames[i], RN_SIZE, "Request#%d", i);
|
||||
}
|
||||
}
|
||||
/* fprintf(stderr, "%d: %s\n", i, RequestNames[i]); */
|
||||
}
|
||||
}
|
||||
|
||||
static void FreeRequestNames(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 256; i++) {
|
||||
if (RequestNames[i] != 0) {
|
||||
free(RequestNames[i]);
|
||||
RequestNames[i] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -155,11 +155,6 @@ QueueFontWakeup(FontPathElementPtr fpe)
|
|||
|
||||
for (i = 0; i < num_slept_fpes; i++) {
|
||||
if (slept_fpes[i] == fpe) {
|
||||
|
||||
#ifdef DEBUG
|
||||
fprintf(stderr, "re-queueing fpe wakeup\n");
|
||||
#endif
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
@ -1886,7 +1881,7 @@ InitFonts ()
|
|||
{
|
||||
patternCache = MakeFontPatternCache();
|
||||
|
||||
#ifndef KDRIVESERVER
|
||||
#ifndef BUILTIN_FONTS
|
||||
if (screenInfo.numScreens > screenInfo.numVideoScreens) {
|
||||
PrinterFontRegisterFpeFunctions();
|
||||
FontFileCheckRegisterFpeFunctions();
|
||||
|
@ -1894,10 +1889,11 @@ InitFonts ()
|
|||
} else
|
||||
#endif
|
||||
{
|
||||
#ifdef KDRIVESERVER
|
||||
BuiltinRegisterFpeFunctions();
|
||||
#endif
|
||||
#ifdef BUILTIN_FONTS
|
||||
BuiltinRegisterFpeFunctions();
|
||||
#else
|
||||
FontFileRegisterFpeFunctions();
|
||||
#endif
|
||||
#ifndef NOFONTSERVERACCESS
|
||||
fs_register_fpe_functions();
|
||||
#endif
|
||||
|
@ -2059,11 +2055,6 @@ init_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler)
|
|||
fs_handlers_installed = 0;
|
||||
}
|
||||
if (fs_handlers_installed == 0) {
|
||||
|
||||
#ifdef DEBUG
|
||||
fprintf(stderr, "adding FS b & w handlers\n");
|
||||
#endif
|
||||
|
||||
if (!RegisterBlockAndWakeupHandlers(block_handler,
|
||||
FontWakeup, (pointer) 0))
|
||||
return AllocError;
|
||||
|
@ -2079,55 +2070,9 @@ remove_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler, Bo
|
|||
if (all) {
|
||||
/* remove the handlers if no one else is using them */
|
||||
if (--fs_handlers_installed == 0) {
|
||||
|
||||
#ifdef DEBUG
|
||||
fprintf(stderr, "removing FS b & w handlers\n");
|
||||
#endif
|
||||
|
||||
RemoveBlockAndWakeupHandlers(block_handler, FontWakeup,
|
||||
(pointer) 0);
|
||||
}
|
||||
}
|
||||
RemoveFontWakeup(fpe);
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
#define GLWIDTHBYTESPADDED(bits,nbytes) \
|
||||
((nbytes) == 1 ? (((bits)+7)>>3) /* pad to 1 byte */ \
|
||||
:(nbytes) == 2 ? ((((bits)+15)>>3)&~1) /* pad to 2 bytes */ \
|
||||
:(nbytes) == 4 ? ((((bits)+31)>>3)&~3) /* pad to 4 bytes */ \
|
||||
:(nbytes) == 8 ? ((((bits)+63)>>3)&~7) /* pad to 8 bytes */ \
|
||||
: 0)
|
||||
|
||||
#define GLYPH_SIZE(ch, nbytes) \
|
||||
GLWIDTHBYTESPADDED((ch)->metrics.rightSideBearing - \
|
||||
(ch)->metrics.leftSideBearing, (nbytes))
|
||||
void
|
||||
dump_char_ascii(CharInfoPtr cip)
|
||||
{
|
||||
int r,
|
||||
l;
|
||||
int bpr;
|
||||
int byte;
|
||||
static unsigned maskTab[] = {
|
||||
(1 << 7), (1 << 6), (1 << 5), (1 << 4),
|
||||
(1 << 3), (1 << 2), (1 << 1), (1 << 0),
|
||||
};
|
||||
|
||||
bpr = GLYPH_SIZE(cip, 4);
|
||||
for (r = 0; r < (cip->metrics.ascent + cip->metrics.descent); r++) {
|
||||
pointer row = (pointer) cip->bits + r * bpr;
|
||||
|
||||
byte = 0;
|
||||
for (l = 0; l <= (cip->metrics.rightSideBearing -
|
||||
cip->metrics.leftSideBearing); l++) {
|
||||
if (maskTab[l & 7] & row[l >> 3])
|
||||
putchar('X');
|
||||
else
|
||||
putchar('.');
|
||||
}
|
||||
putchar('\n');
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -95,9 +95,7 @@ Author: Adobe Systems Incorporated
|
|||
#include "scrnintstr.h"
|
||||
#define XK_LATIN1
|
||||
#include <X11/keysymdef.h>
|
||||
#ifdef XACE
|
||||
#include "xace.h"
|
||||
#endif
|
||||
|
||||
/*
|
||||
* CompareTimeStamps returns -1, 0, or +1 depending on if the first
|
||||
|
|
145
dix/events.c
145
dix/events.c
|
@ -113,6 +113,7 @@ of the copyright holder.
|
|||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/keysym.h>
|
||||
#include "misc.h"
|
||||
#include "resource.h"
|
||||
#define NEED_EVENTS
|
||||
|
@ -131,12 +132,17 @@ of the copyright holder.
|
|||
#include "globals.h"
|
||||
|
||||
#ifdef XKB
|
||||
#include <X11/extensions/XKBproto.h>
|
||||
#include <X11/extensions/XKBsrv.h>
|
||||
extern Bool XkbFilterEvents(ClientPtr, int, xEvent *);
|
||||
#endif
|
||||
|
||||
#ifdef XACE
|
||||
#include "xace.h"
|
||||
|
||||
#ifdef XSERVER_DTRACE
|
||||
#include <sys/types.h>
|
||||
typedef const char *string;
|
||||
#include "Xserver-dtrace.h"
|
||||
#endif
|
||||
|
||||
#ifdef XEVIE
|
||||
|
@ -154,7 +160,9 @@ xEvent *xeviexE;
|
|||
#endif
|
||||
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "exglobals.h"
|
||||
#include "exevents.h"
|
||||
#include "exglobals.h"
|
||||
#include "extnsionst.h"
|
||||
|
||||
#include "dixevents.h"
|
||||
|
@ -206,9 +214,6 @@ _X_EXPORT CallbackListPtr DeviceEventCallback;
|
|||
Mask DontPropagateMasks[DNPMCOUNT];
|
||||
static int DontPropagateRefCnts[DNPMCOUNT];
|
||||
|
||||
#ifdef DEBUG
|
||||
static debug_events = 0;
|
||||
#endif
|
||||
_X_EXPORT InputInfo inputInfo;
|
||||
|
||||
static struct {
|
||||
|
@ -319,11 +324,16 @@ static CARD8 criticalEvents[32] =
|
|||
};
|
||||
|
||||
#ifdef PANORAMIX
|
||||
|
||||
static void ConfineToShape(RegionPtr shape, int *px, int *py);
|
||||
static void SyntheticMotion(int x, int y);
|
||||
static void PostNewCursor(void);
|
||||
|
||||
#define SyntheticMotion(x, y) \
|
||||
PostSyntheticMotion(x, y, noPanoramiXExtension ? 0 : \
|
||||
sprite.screen->myNum, \
|
||||
syncEvents.playingEvents ? \
|
||||
syncEvents.time.milliseconds : \
|
||||
currentTime.milliseconds);
|
||||
|
||||
static Bool
|
||||
XineramaSetCursorPosition(
|
||||
int x,
|
||||
|
@ -666,30 +676,6 @@ SetCriticalEvent(int event)
|
|||
criticalEvents[event >> 3] |= 1 << (event & 7);
|
||||
}
|
||||
|
||||
static void
|
||||
SyntheticMotion(int x, int y)
|
||||
{
|
||||
xEvent xE;
|
||||
|
||||
#ifdef PANORAMIX
|
||||
/* Translate back to the sprite screen since processInputProc
|
||||
will translate from sprite screen to screen 0 upon reentry
|
||||
to the DIX layer */
|
||||
if(!noPanoramiXExtension) {
|
||||
x += panoramiXdataPtr[0].x - panoramiXdataPtr[sprite.screen->myNum].x;
|
||||
y += panoramiXdataPtr[0].y - panoramiXdataPtr[sprite.screen->myNum].y;
|
||||
}
|
||||
#endif
|
||||
xE.u.keyButtonPointer.rootX = x;
|
||||
xE.u.keyButtonPointer.rootY = y;
|
||||
if (syncEvents.playingEvents)
|
||||
xE.u.keyButtonPointer.time = syncEvents.time.milliseconds;
|
||||
else
|
||||
xE.u.keyButtonPointer.time = currentTime.milliseconds;
|
||||
xE.u.u.type = MotionNotify;
|
||||
(*inputInfo.pointer->public.processInputProc)(&xE, inputInfo.pointer, 1);
|
||||
}
|
||||
|
||||
#ifdef SHAPE
|
||||
static void
|
||||
ConfineToShape(RegionPtr shape, int *px, int *py)
|
||||
|
@ -1531,9 +1517,8 @@ TryClientEvents (ClientPtr client, xEvent *pEvents, int count, Mask mask,
|
|||
int i;
|
||||
int type;
|
||||
|
||||
#ifdef DEBUG
|
||||
if (debug_events) ErrorF(
|
||||
"Event([%d, %d], mask=0x%x), client=%d",
|
||||
#ifdef DEBUG_EVENTS
|
||||
ErrorF("Event([%d, %d], mask=0x%x), client=%d",
|
||||
pEvents->u.u.type, pEvents->u.u.detail, mask, client->index);
|
||||
#endif
|
||||
if ((client) && (client != serverClient) && (!client->clientGone) &&
|
||||
|
@ -1549,9 +1534,9 @@ TryClientEvents (ClientPtr client, xEvent *pEvents, int count, Mask mask,
|
|||
if (WID(inputInfo.pointer->valuator->motionHintWindow) ==
|
||||
pEvents->u.keyButtonPointer.event)
|
||||
{
|
||||
#ifdef DEBUG
|
||||
if (debug_events) ErrorF("\n");
|
||||
fprintf(stderr,"motionHintWindow == keyButtonPointer.event\n");
|
||||
#ifdef DEBUG_EVENTS
|
||||
ErrorF("\n");
|
||||
ErrorF("motionHintWindow == keyButtonPointer.event\n");
|
||||
#endif
|
||||
return 1; /* don't send, but pretend we did */
|
||||
}
|
||||
|
@ -1589,15 +1574,15 @@ TryClientEvents (ClientPtr client, xEvent *pEvents, int count, Mask mask,
|
|||
}
|
||||
|
||||
WriteEventsToClient(client, count, pEvents);
|
||||
#ifdef DEBUG
|
||||
if (debug_events) ErrorF( " delivered\n");
|
||||
#ifdef DEBUG_EVENTS
|
||||
ErrorF( " delivered\n");
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef DEBUG
|
||||
if (debug_events) ErrorF("\n");
|
||||
#ifdef DEBUG_EVENTS
|
||||
ErrorF("\n");
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
@ -2476,10 +2461,8 @@ CheckPassiveGrabsOnWindow(
|
|||
(grab->confineTo->realized &&
|
||||
BorderSizeNotEmpty(grab->confineTo))))
|
||||
{
|
||||
#ifdef XACE
|
||||
if (!XaceHook(XACE_DEVICE_ACCESS, wClient(pWin), device, FALSE))
|
||||
return FALSE;
|
||||
#endif
|
||||
#ifdef XKB
|
||||
if (!noXkbExtension) {
|
||||
XE_KBPTR.state &= 0x1f00;
|
||||
|
@ -2776,13 +2759,6 @@ drawable.id:0;
|
|||
}
|
||||
#endif
|
||||
|
||||
#ifdef DEBUG
|
||||
if ((xkbDebugFlags&0x4)&&
|
||||
((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease))) {
|
||||
ErrorF("CoreProcessKbdEvent: Key %d %s\n",key,
|
||||
(xE->u.u.type==KeyPress?"down":"up"));
|
||||
}
|
||||
#endif
|
||||
switch (xE->u.u.type)
|
||||
{
|
||||
case KeyPress:
|
||||
|
@ -2847,9 +2823,7 @@ drawable.id:0;
|
|||
if (deactivateGrab)
|
||||
(*keybd->DeactivateGrab)(keybd);
|
||||
|
||||
#ifdef XACE
|
||||
XaceHook(XACE_KEY_AVAIL, xE, keybd, count);
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef XKB
|
||||
|
@ -2867,13 +2841,12 @@ FixKeyState (register xEvent *xE, register DeviceIntPtr keybd)
|
|||
key = xE->u.u.detail;
|
||||
kptr = &keyc->down[key >> 3];
|
||||
bit = 1 << (key & 7);
|
||||
#ifdef DEBUG
|
||||
if ((xkbDebugFlags&0x4)&&
|
||||
((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease))) {
|
||||
ErrorF("FixKeyState: Key %d %s\n",key,
|
||||
|
||||
if (((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease))) {
|
||||
DebugF("FixKeyState: Key %d %s\n",key,
|
||||
(xE->u.u.type==KeyPress?"down":"up"));
|
||||
}
|
||||
#endif
|
||||
|
||||
switch (xE->u.u.type)
|
||||
{
|
||||
case KeyPress:
|
||||
|
@ -3101,12 +3074,7 @@ EventSelectForWindow(register WindowPtr pWin, register ClientPtr client, Mask ma
|
|||
if (wClient (pWin) == client)
|
||||
{
|
||||
check = pWin->eventMask;
|
||||
#ifdef SGIMISC
|
||||
pWin->eventMask =
|
||||
(mask & ~SGIMiscSpecialDestroyMask) | (pWin->eventMask & SGIMiscSpecialDestroyMask);
|
||||
#else
|
||||
pWin->eventMask = mask;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -3115,9 +3083,6 @@ EventSelectForWindow(register WindowPtr pWin, register ClientPtr client, Mask ma
|
|||
if (SameClient(others, client))
|
||||
{
|
||||
check = others->mask;
|
||||
#ifdef SGIMISC
|
||||
mask = (mask & ~SGIMiscSpecialDestroyMask) | (others->mask & SGIMiscSpecialDestroyMask);
|
||||
#endif
|
||||
if (mask == 0)
|
||||
{
|
||||
FreeResource(others->resource, RT_NONE);
|
||||
|
@ -3282,17 +3247,13 @@ EnterLeaveEvent(
|
|||
if ((type == EnterNotify) && (mask & KeymapStateMask))
|
||||
{
|
||||
xKeymapEvent ke;
|
||||
|
||||
#ifdef XACE
|
||||
ClientPtr client = grab ? rClient(grab)
|
||||
: clients[CLIENT_ID(pWin->drawable.id)];
|
||||
if (!XaceHook(XACE_DEVICE_ACCESS, client, keybd, FALSE))
|
||||
{
|
||||
bzero((char *)&ke.map[0], 31);
|
||||
}
|
||||
if (XaceHook(XACE_DEVICE_ACCESS, client, keybd, FALSE))
|
||||
memmove((char *)&ke.map[0], (char *)&keybd->key->down[1], 31);
|
||||
else
|
||||
#endif
|
||||
memmove((char *)&ke.map[0], (char *)&keybd->key->down[1], 31);
|
||||
bzero((char *)&ke.map[0], 31);
|
||||
|
||||
ke.type = KeymapNotify;
|
||||
if (grab)
|
||||
(void)TryClientEvents(rClient(grab), (xEvent *)&ke, 1, mask,
|
||||
|
@ -3378,15 +3339,12 @@ FocusEvent(DeviceIntPtr dev, int type, int mode, int detail, register WindowPtr
|
|||
((pWin->eventMask | wOtherEventMasks(pWin)) & KeymapStateMask))
|
||||
{
|
||||
xKeymapEvent ke;
|
||||
#ifdef XACE
|
||||
ClientPtr client = clients[CLIENT_ID(pWin->drawable.id)];
|
||||
if (!XaceHook(XACE_DEVICE_ACCESS, client, dev, FALSE))
|
||||
{
|
||||
bzero((char *)&ke.map[0], 31);
|
||||
}
|
||||
if (XaceHook(XACE_DEVICE_ACCESS, client, dev, FALSE))
|
||||
memmove((char *)&ke.map[0], (char *)&dev->key->down[1], 31);
|
||||
else
|
||||
#endif
|
||||
memmove((char *)&ke.map[0], (char *)&dev->key->down[1], 31);
|
||||
bzero((char *)&ke.map[0], 31);
|
||||
|
||||
ke.type = KeymapNotify;
|
||||
(void)DeliverEventsToWindow(pWin, (xEvent *)&ke, 1,
|
||||
KeymapStateMask, NullGrab, 0);
|
||||
|
@ -3649,10 +3607,10 @@ ProcSetInputFocus(client)
|
|||
REQUEST(xSetInputFocusReq);
|
||||
|
||||
REQUEST_SIZE_MATCH(xSetInputFocusReq);
|
||||
#ifdef XACE
|
||||
|
||||
if (!XaceHook(XACE_DEVICE_ACCESS, client, inputInfo.keyboard, TRUE))
|
||||
return Success;
|
||||
#endif
|
||||
|
||||
return SetInputFocus(client, inputInfo.keyboard, stuff->focus,
|
||||
stuff->revertTo, stuff->time, FALSE);
|
||||
}
|
||||
|
@ -3914,18 +3872,17 @@ ProcGrabKeyboard(ClientPtr client)
|
|||
int result;
|
||||
|
||||
REQUEST_SIZE_MATCH(xGrabKeyboardReq);
|
||||
#ifdef XACE
|
||||
if (!XaceHook(XACE_DEVICE_ACCESS, client, inputInfo.keyboard, TRUE))
|
||||
{
|
||||
|
||||
if (XaceHook(XACE_DEVICE_ACCESS, client, inputInfo.keyboard, TRUE))
|
||||
result = GrabDevice(client, inputInfo.keyboard, stuff->keyboardMode,
|
||||
stuff->pointerMode, stuff->grabWindow,
|
||||
stuff->ownerEvents, stuff->time,
|
||||
KeyPressMask | KeyReleaseMask, &rep.status);
|
||||
else {
|
||||
result = Success;
|
||||
rep.status = AlreadyGrabbed;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
result = GrabDevice(client, inputInfo.keyboard, stuff->keyboardMode,
|
||||
stuff->pointerMode, stuff->grabWindow,
|
||||
stuff->ownerEvents, stuff->time,
|
||||
KeyPressMask | KeyReleaseMask, &rep.status);
|
||||
|
||||
if (result != Success)
|
||||
return result;
|
||||
rep.type = X_Reply;
|
||||
|
@ -4580,6 +4537,14 @@ WriteEventsToClient(ClientPtr pClient, int count, xEvent *events)
|
|||
eventinfo.count = count;
|
||||
CallCallbacks(&EventCallback, (pointer)&eventinfo);
|
||||
}
|
||||
#ifdef XSERVER_DTRACE
|
||||
if (XSERVER_SEND_EVENT_ENABLED()) {
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
XSERVER_SEND_EVENT(pClient->index, events[i].u.u.type, &events[i]);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if(pClient->swapped)
|
||||
{
|
||||
for(i = 0; i < count; i++)
|
||||
|
|
|
@ -59,9 +59,7 @@ SOFTWARE.
|
|||
#include "gcstruct.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "dispatch.h"
|
||||
#ifdef XACE
|
||||
#include "xace.h"
|
||||
#endif
|
||||
|
||||
#define EXTENSION_BASE 128
|
||||
#define EXTENSION_EVENT_BASE 64
|
||||
|
@ -256,11 +254,9 @@ GetExtensionEntry(int major)
|
|||
_X_EXPORT void
|
||||
DeclareExtensionSecurity(char *extname, Bool secure)
|
||||
{
|
||||
#ifdef XACE
|
||||
int i = FindExtension(extname, strlen(extname));
|
||||
if (i >= 0)
|
||||
XaceHook(XACE_DECLARE_EXT_SECURE, extensions[i], secure);
|
||||
#endif
|
||||
}
|
||||
|
||||
_X_EXPORT unsigned short
|
||||
|
@ -336,12 +332,7 @@ ProcQueryExtension(ClientPtr client)
|
|||
else
|
||||
{
|
||||
i = FindExtension((char *)&stuff[1], stuff->nbytes);
|
||||
if (i < 0
|
||||
#ifdef XACE
|
||||
/* call callbacks to find out whether to show extension */
|
||||
|| !XaceHook(XACE_EXT_ACCESS, client, extensions[i])
|
||||
#endif
|
||||
)
|
||||
if (i < 0 || !XaceHook(XACE_EXT_ACCESS, client, extensions[i]))
|
||||
reply.present = xFalse;
|
||||
else
|
||||
{
|
||||
|
@ -376,11 +367,10 @@ ProcListExtensions(ClientPtr client)
|
|||
|
||||
for (i=0; i<NumExtensions; i++)
|
||||
{
|
||||
#ifdef XACE
|
||||
/* call callbacks to find out whether to show extension */
|
||||
if (!XaceHook(XACE_EXT_ACCESS, client, extensions[i]))
|
||||
continue;
|
||||
#endif
|
||||
|
||||
total_length += strlen(extensions[i]->name) + 1;
|
||||
reply.nExtensions += 1 + extensions[i]->num_aliases;
|
||||
for (j = extensions[i]->num_aliases; --j >= 0;)
|
||||
|
@ -393,10 +383,9 @@ ProcListExtensions(ClientPtr client)
|
|||
for (i=0; i<NumExtensions; i++)
|
||||
{
|
||||
int len;
|
||||
#ifdef XACE
|
||||
if (!XaceHook(XACE_EXT_ACCESS, client, extensions[i]))
|
||||
continue;
|
||||
#endif
|
||||
|
||||
*bufptr++ = len = strlen(extensions[i]->name);
|
||||
memmove(bufptr, extensions[i]->name, len);
|
||||
bufptr += len;
|
||||
|
@ -482,3 +471,17 @@ RegisterScreenProc(char *name, ScreenPtr pScreen, ExtensionLookupProc proc)
|
|||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
#ifdef XSERVER_DTRACE
|
||||
void LoadExtensionNames(char **RequestNames) {
|
||||
int i;
|
||||
|
||||
for (i=0; i<NumExtensions; i++) {
|
||||
int r = extensions[i]->base;
|
||||
|
||||
if (RequestNames[r] == NULL) {
|
||||
RequestNames[r] = strdup(extensions[i]->name);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -26,10 +26,18 @@ The Open Group.
|
|||
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include "dix.h"
|
||||
|
||||
int
|
||||
ffs(int i)
|
||||
{
|
||||
int j;
|
||||
if (i == 0)
|
||||
return 0;
|
||||
for (j = 1; (i & 1) == 0; j++)
|
||||
i >>= 1;
|
||||
return j;
|
||||
|
|
785
dix/getevents.c
Normal file
785
dix/getevents.c
Normal file
|
@ -0,0 +1,785 @@
|
|||
/*
|
||||
* Copyright © 2006 Nokia Corporation
|
||||
* Copyright © 2006 Daniel Stone
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and
|
||||
* its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and that
|
||||
* both that this copyright notice and this permission notice appear in
|
||||
* supporting electronic documentation.
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
* IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR AUTHORS BE LIABLE FOR ANY
|
||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Author: Daniel Stone <daniel@fooishbar.org>
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/keysym.h>
|
||||
#define NEED_EVENTS
|
||||
#define NEED_REPLIES
|
||||
#include <X11/Xproto.h>
|
||||
|
||||
#include "misc.h"
|
||||
#include "resource.h"
|
||||
#include "inputstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "cursorstr.h"
|
||||
#include "dixstruct.h"
|
||||
#include "globals.h"
|
||||
#include "dixevents.h"
|
||||
#include "mipointer.h"
|
||||
|
||||
#ifdef XKB
|
||||
#include <X11/extensions/XKBproto.h>
|
||||
#include <X11/extensions/XKBsrv.h>
|
||||
extern Bool XkbCopyKeymap(XkbDescPtr src, XkbDescPtr dst, Bool sendNotifies);
|
||||
#endif
|
||||
|
||||
#ifdef PANORAMIX
|
||||
#include "panoramiX.h"
|
||||
#include "panoramiXsrv.h"
|
||||
#endif
|
||||
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "exglobals.h"
|
||||
#include "exevents.h"
|
||||
#include "exglobals.h"
|
||||
#include "extnsionst.h"
|
||||
|
||||
|
||||
/* Maximum number of valuators, divided by six, rounded up, to get number
|
||||
* of events. */
|
||||
#define MAX_VALUATOR_EVENTS 6
|
||||
|
||||
/* Number of motion history events to store. */
|
||||
#define MOTION_HISTORY_SIZE 256
|
||||
|
||||
|
||||
/**
|
||||
* Pick some arbitrary size for Xi motion history.
|
||||
*/
|
||||
_X_EXPORT int
|
||||
GetMotionHistorySize()
|
||||
{
|
||||
return MOTION_HISTORY_SIZE;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Allocate the motion history buffer.
|
||||
*/
|
||||
_X_EXPORT void
|
||||
AllocateMotionHistory(DeviceIntPtr pDev)
|
||||
{
|
||||
if (pDev->valuator->motion)
|
||||
xfree(pDev->valuator->motion);
|
||||
|
||||
if (pDev->valuator->numMotionEvents < 1)
|
||||
return;
|
||||
|
||||
pDev->valuator->motion = xalloc(((sizeof(INT32) * pDev->valuator->numAxes) +
|
||||
sizeof(Time)) *
|
||||
pDev->valuator->numMotionEvents);
|
||||
pDev->valuator->first_motion = 0;
|
||||
pDev->valuator->last_motion = 0;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Dump the motion history between start and stop into the supplied buffer.
|
||||
* Only records the event for a given screen in theory, but in practice, we
|
||||
* sort of ignore this.
|
||||
*/
|
||||
_X_EXPORT int
|
||||
GetMotionHistory(DeviceIntPtr pDev, xTimecoord *buff, unsigned long start,
|
||||
unsigned long stop, ScreenPtr pScreen)
|
||||
{
|
||||
char *ibuff = NULL, *obuff = (char *) buff;
|
||||
int i = 0, ret = 0;
|
||||
Time current;
|
||||
/* The size of a single motion event. */
|
||||
int size = (sizeof(INT32) * pDev->valuator->numAxes) + sizeof(Time);
|
||||
|
||||
if (!pDev->valuator || !pDev->valuator->numMotionEvents)
|
||||
return 0;
|
||||
|
||||
for (i = pDev->valuator->first_motion;
|
||||
i != pDev->valuator->last_motion;
|
||||
i = (i + 1) % pDev->valuator->numMotionEvents) {
|
||||
/* We index the input buffer by which element we're accessing, which
|
||||
* is not monotonic, and the output buffer by how many events we've
|
||||
* written so far. */
|
||||
ibuff = (char *) pDev->valuator->motion + (i * size);
|
||||
memcpy(¤t, ibuff, sizeof(Time));
|
||||
|
||||
if (current > stop) {
|
||||
return ret;
|
||||
}
|
||||
else if (current >= start) {
|
||||
memcpy(obuff, ibuff, size);
|
||||
obuff += size;
|
||||
ret++;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Update the motion history for a specific device, with the list of
|
||||
* valuators.
|
||||
*/
|
||||
static void
|
||||
updateMotionHistory(DeviceIntPtr pDev, CARD32 ms, int first_valuator,
|
||||
int num_valuators, int *valuators)
|
||||
{
|
||||
char *buff = (char *) pDev->valuator->motion;
|
||||
|
||||
if (!pDev->valuator->numMotionEvents)
|
||||
return;
|
||||
|
||||
buff += ((sizeof(INT32) * pDev->valuator->numAxes) + sizeof(CARD32)) *
|
||||
pDev->valuator->last_motion;
|
||||
memcpy(buff, &ms, sizeof(Time));
|
||||
|
||||
buff += sizeof(Time);
|
||||
bzero(buff, sizeof(INT32) * pDev->valuator->numAxes);
|
||||
|
||||
buff += sizeof(INT32) * first_valuator;
|
||||
memcpy(buff, valuators, sizeof(INT32) * num_valuators);
|
||||
|
||||
pDev->valuator->last_motion = (pDev->valuator->last_motion + 1) %
|
||||
pDev->valuator->numMotionEvents;
|
||||
|
||||
/* If we're wrapping around, just keep the circular buffer going. */
|
||||
if (pDev->valuator->first_motion == pDev->valuator->last_motion)
|
||||
pDev->valuator->first_motion = (pDev->valuator->first_motion + 1) %
|
||||
pDev->valuator->numMotionEvents;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the maximum number of events GetKeyboardEvents,
|
||||
* GetKeyboardValuatorEvents, and GetPointerEvents will ever return.
|
||||
*
|
||||
* Should be used in DIX as:
|
||||
* xEvent *events = xcalloc(sizeof(xEvent), GetMaximumEventsNum());
|
||||
*/
|
||||
_X_EXPORT int
|
||||
GetMaximumEventsNum() {
|
||||
/* Two base events -- core and device, plus valuator events. Multiply
|
||||
* by two if we're doing key repeats. */
|
||||
int ret = 2 + MAX_VALUATOR_EVENTS;
|
||||
|
||||
#ifdef XKB
|
||||
if (noXkbExtension)
|
||||
#endif
|
||||
ret *= 2;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
/* Originally a part of xf86PostMotionEvent; modifies valuators
|
||||
* in-place. */
|
||||
static void
|
||||
acceleratePointer(DeviceIntPtr pDev, int first_valuator, int num_valuators,
|
||||
int *valuators)
|
||||
{
|
||||
float mult = 0.0;
|
||||
int dx = 0, dy = 0;
|
||||
int *px = NULL, *py = NULL;
|
||||
|
||||
if (!num_valuators || !valuators)
|
||||
return;
|
||||
|
||||
if (first_valuator == 0) {
|
||||
dx = valuators[0];
|
||||
px = &valuators[0];
|
||||
}
|
||||
if (first_valuator <= 1 && num_valuators >= (2 - first_valuator)) {
|
||||
dy = valuators[1 - first_valuator];
|
||||
py = &valuators[1 - first_valuator];
|
||||
}
|
||||
|
||||
if (!dx && !dy)
|
||||
return;
|
||||
|
||||
if (pDev->ptrfeed && pDev->ptrfeed->ctrl.num) {
|
||||
/* modeled from xf86Events.c */
|
||||
if (pDev->ptrfeed->ctrl.threshold) {
|
||||
if ((abs(dx) + abs(dy)) >= pDev->ptrfeed->ctrl.threshold) {
|
||||
pDev->valuator->dxremaind = ((float)dx *
|
||||
(float)(pDev->ptrfeed->ctrl.num)) /
|
||||
(float)(pDev->ptrfeed->ctrl.den) +
|
||||
pDev->valuator->dxremaind;
|
||||
if (px) {
|
||||
*px = (int)pDev->valuator->dxremaind;
|
||||
pDev->valuator->dxremaind = pDev->valuator->dxremaind -
|
||||
(float)(*px);
|
||||
}
|
||||
|
||||
pDev->valuator->dyremaind = ((float)dy *
|
||||
(float)(pDev->ptrfeed->ctrl.num)) /
|
||||
(float)(pDev->ptrfeed->ctrl.den) +
|
||||
pDev->valuator->dyremaind;
|
||||
if (py) {
|
||||
*py = (int)pDev->valuator->dyremaind;
|
||||
pDev->valuator->dyremaind = pDev->valuator->dyremaind -
|
||||
(float)(*py);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
mult = pow((float)(dx * dx + dy * dy),
|
||||
((float)(pDev->ptrfeed->ctrl.num) /
|
||||
(float)(pDev->ptrfeed->ctrl.den) - 1.0) /
|
||||
2.0) / 2.0;
|
||||
if (dx) {
|
||||
pDev->valuator->dxremaind = mult * (float)dx +
|
||||
pDev->valuator->dxremaind;
|
||||
*px = (int)pDev->valuator->dxremaind;
|
||||
pDev->valuator->dxremaind = pDev->valuator->dxremaind -
|
||||
(float)(*px);
|
||||
}
|
||||
if (dy) {
|
||||
pDev->valuator->dyremaind = mult * (float)dy +
|
||||
pDev->valuator->dyremaind;
|
||||
*py = (int)pDev->valuator->dyremaind;
|
||||
pDev->valuator->dyremaind = pDev->valuator->dyremaind -
|
||||
(float)(*py);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Clip an axis to its bounds, which are declared in the call to
|
||||
* InitValuatorAxisClassStruct.
|
||||
*/
|
||||
static void
|
||||
clipAxis(DeviceIntPtr pDev, int axisNum, int *val)
|
||||
{
|
||||
AxisInfoPtr axes = pDev->valuator->axes + axisNum;
|
||||
|
||||
if (*val < axes->min_value)
|
||||
*val = axes->min_value;
|
||||
if (axes->max_value >= 0 && *val > axes->max_value)
|
||||
*val = axes->max_value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clip every axis in the list of valuators to its bounds.
|
||||
*/
|
||||
static void
|
||||
clipValuators(DeviceIntPtr pDev, int first_valuator, int num_valuators,
|
||||
int *valuators)
|
||||
{
|
||||
AxisInfoPtr axes = pDev->valuator->axes + first_valuator;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < num_valuators; i++, axes++)
|
||||
clipAxis(pDev, i + first_valuator, &(valuators[i]));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Fills events with valuator events for pDev, as given by the other
|
||||
* parameters.
|
||||
*
|
||||
* FIXME: Need to fix ValuatorClassRec to store all the valuators as
|
||||
* last posted, not just x and y; otherwise relative non-x/y
|
||||
* valuators, though a very narrow use case, will be broken.
|
||||
*/
|
||||
static xEvent *
|
||||
getValuatorEvents(xEvent *events, DeviceIntPtr pDev, int first_valuator,
|
||||
int num_valuators, int *valuators) {
|
||||
deviceValuator *xv = (deviceValuator *) events;
|
||||
int i = 0, final_valuator = first_valuator + num_valuators;
|
||||
|
||||
for (i = first_valuator; i < final_valuator; i += 6, xv++, events++) {
|
||||
xv->type = DeviceValuator;
|
||||
xv->first_valuator = i;
|
||||
xv->num_valuators = num_valuators;
|
||||
xv->deviceid = pDev->id;
|
||||
switch (final_valuator - i) {
|
||||
case 6:
|
||||
xv->valuator5 = valuators[i + 5];
|
||||
case 5:
|
||||
xv->valuator4 = valuators[i + 4];
|
||||
case 4:
|
||||
xv->valuator3 = valuators[i + 3];
|
||||
case 3:
|
||||
xv->valuator2 = valuators[i + 2];
|
||||
case 2:
|
||||
xv->valuator1 = valuators[i + 1];
|
||||
case 1:
|
||||
xv->valuator0 = valuators[i];
|
||||
}
|
||||
|
||||
if (i + 6 < final_valuator)
|
||||
xv->deviceid |= MORE_EVENTS;
|
||||
}
|
||||
|
||||
return events;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Convenience wrapper around GetKeyboardValuatorEvents, that takes no
|
||||
* valuators.
|
||||
*/
|
||||
_X_EXPORT int
|
||||
GetKeyboardEvents(xEvent *events, DeviceIntPtr pDev, int type, int key_code) {
|
||||
return GetKeyboardValuatorEvents(events, pDev, type, key_code, 0, 0, NULL);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns a set of keyboard events for KeyPress/KeyRelease, optionally
|
||||
* also with valuator events. Handles Xi and XKB.
|
||||
*
|
||||
* events is not NULL-terminated; the return value is the number of events.
|
||||
* The DDX is responsible for allocating the event structure in the first
|
||||
* place via GetMaximumEventsNum(), and for freeing it.
|
||||
*
|
||||
* This function does not change the core keymap to that of the device;
|
||||
* that is done by SwitchCoreKeyboard, which is called from
|
||||
* mieqProcessInputEvents. If replacing that function, take care to call
|
||||
* SetCoreKeyboard before processInputProc, so keymaps are altered to suit.
|
||||
*
|
||||
* Note that this function recurses! If called for non-XKB, a repeating
|
||||
* key press will trigger a matching KeyRelease, as well as the
|
||||
* KeyPresses.
|
||||
*/
|
||||
_X_EXPORT int
|
||||
GetKeyboardValuatorEvents(xEvent *events, DeviceIntPtr pDev, int type,
|
||||
int key_code, int first_valuator,
|
||||
int num_valuators, int *valuators) {
|
||||
int numEvents = 0;
|
||||
CARD32 ms = 0;
|
||||
KeySym *map = pDev->key->curKeySyms.map;
|
||||
KeySym sym = map[key_code * pDev->key->curKeySyms.mapWidth];
|
||||
deviceKeyButtonPointer *kbp = NULL;
|
||||
|
||||
if (!events)
|
||||
return 0;
|
||||
|
||||
if (type != KeyPress && type != KeyRelease)
|
||||
return 0;
|
||||
|
||||
if (!pDev->key || !pDev->focus || !pDev->kbdfeed ||
|
||||
(pDev->coreEvents && !inputInfo.keyboard->key))
|
||||
return 0;
|
||||
|
||||
if (pDev->coreEvents)
|
||||
numEvents = 2;
|
||||
else
|
||||
numEvents = 1;
|
||||
|
||||
if (num_valuators) {
|
||||
if ((num_valuators / 6) + 1 > MAX_VALUATOR_EVENTS)
|
||||
num_valuators = MAX_VALUATOR_EVENTS;
|
||||
numEvents += (num_valuators / 6) + 1;
|
||||
}
|
||||
|
||||
#ifdef XKB
|
||||
if (noXkbExtension)
|
||||
#endif
|
||||
{
|
||||
switch (sym) {
|
||||
case XK_Num_Lock:
|
||||
case XK_Caps_Lock:
|
||||
case XK_Scroll_Lock:
|
||||
case XK_Shift_Lock:
|
||||
if (type == KeyRelease)
|
||||
return 0;
|
||||
else if (type == KeyPress &&
|
||||
(pDev->key->down[key_code >> 3] & (key_code & 7)) & 1)
|
||||
type = KeyRelease;
|
||||
}
|
||||
}
|
||||
|
||||
/* Handle core repeating, via press/release/press/release.
|
||||
* FIXME: In theory, if you're repeating with two keyboards in non-XKB,
|
||||
* you could get unbalanced events here. */
|
||||
if (type == KeyPress &&
|
||||
(((pDev->key->down[key_code >> 3] & (key_code & 7))) & 1)) {
|
||||
if (!pDev->kbdfeed->ctrl.autoRepeat ||
|
||||
pDev->key->modifierMap[key_code] ||
|
||||
!(pDev->kbdfeed->ctrl.autoRepeats[key_code >> 3]
|
||||
& (1 << (key_code & 7))))
|
||||
return 0;
|
||||
|
||||
#ifdef XKB
|
||||
if (noXkbExtension)
|
||||
#endif
|
||||
{
|
||||
numEvents += GetKeyboardValuatorEvents(events, pDev,
|
||||
KeyRelease, key_code,
|
||||
first_valuator, num_valuators,
|
||||
valuators);
|
||||
events += numEvents;
|
||||
}
|
||||
}
|
||||
|
||||
ms = GetTimeInMillis();
|
||||
|
||||
kbp = (deviceKeyButtonPointer *) events;
|
||||
kbp->time = ms;
|
||||
kbp->deviceid = pDev->id;
|
||||
if (type == KeyPress)
|
||||
kbp->type = DeviceKeyPress;
|
||||
else if (type == KeyRelease)
|
||||
kbp->type = DeviceKeyRelease;
|
||||
|
||||
events++;
|
||||
if (num_valuators) {
|
||||
kbp->deviceid |= MORE_EVENTS;
|
||||
clipValuators(pDev, first_valuator, num_valuators, valuators);
|
||||
events = getValuatorEvents(events, pDev, first_valuator,
|
||||
num_valuators, valuators);
|
||||
}
|
||||
|
||||
if (pDev->coreEvents) {
|
||||
events->u.keyButtonPointer.time = ms;
|
||||
events->u.u.type = type;
|
||||
events->u.u.detail = key_code;
|
||||
}
|
||||
|
||||
return numEvents;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Generate a series of xEvents (returned in xE) representing pointer
|
||||
* motion, or button presses. Xi and XKB-aware.
|
||||
*
|
||||
* events is not NULL-terminated; the return value is the number of events.
|
||||
* The DDX is responsible for allocating the event structure in the first
|
||||
* place via GetMaximumEventsNum(), and for freeing it.
|
||||
*/
|
||||
_X_EXPORT int
|
||||
GetPointerEvents(xEvent *events, DeviceIntPtr pDev, int type, int buttons,
|
||||
int flags, int first_valuator, int num_valuators,
|
||||
int *valuators) {
|
||||
int num_events = 0, final_valuator = 0;
|
||||
CARD32 ms = 0;
|
||||
deviceKeyButtonPointer *kbp = NULL;
|
||||
/* Thanks to a broken lib, we _always_ have to chase DeviceMotionNotifies
|
||||
* with DeviceValuators. */
|
||||
Bool sendValuators = (type == MotionNotify || flags & POINTER_ABSOLUTE);
|
||||
DeviceIntPtr cp = inputInfo.pointer;
|
||||
int x = 0, y = 0;
|
||||
|
||||
/* Sanity checks. */
|
||||
if (type != MotionNotify && type != ButtonPress && type != ButtonRelease)
|
||||
return 0;
|
||||
|
||||
if ((type == ButtonPress || type == ButtonRelease) && !pDev->button)
|
||||
return 0;
|
||||
|
||||
if (pDev->coreEvents)
|
||||
num_events = 2;
|
||||
else
|
||||
num_events = 1;
|
||||
|
||||
if (type == MotionNotify && num_valuators <= 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Do we need to send a DeviceValuator event? */
|
||||
if (sendValuators) {
|
||||
if ((((num_valuators - 1) / 6) + 1) > MAX_VALUATOR_EVENTS)
|
||||
num_valuators = MAX_VALUATOR_EVENTS * 6;
|
||||
num_events += ((num_valuators - 1) / 6) + 1;
|
||||
}
|
||||
|
||||
final_valuator = num_valuators + first_valuator;
|
||||
|
||||
/* You fail. */
|
||||
if (first_valuator < 0 || final_valuator > pDev->valuator->numAxes)
|
||||
return 0;
|
||||
|
||||
ms = GetTimeInMillis();
|
||||
|
||||
kbp = (deviceKeyButtonPointer *) events;
|
||||
kbp->time = ms;
|
||||
kbp->deviceid = pDev->id;
|
||||
|
||||
/* Set x and y based on whether this is absolute or relative, and
|
||||
* accelerate if we need to. */
|
||||
if (flags & POINTER_ABSOLUTE) {
|
||||
if (num_valuators >= 1 && first_valuator == 0) {
|
||||
x = valuators[0];
|
||||
}
|
||||
else {
|
||||
if (pDev->coreEvents)
|
||||
x = cp->valuator->lastx;
|
||||
else
|
||||
x = pDev->valuator->lastx;
|
||||
}
|
||||
|
||||
if (first_valuator <= 1 && num_valuators >= (2 - first_valuator)) {
|
||||
y = valuators[1 - first_valuator];
|
||||
}
|
||||
else {
|
||||
if (pDev->coreEvents)
|
||||
y = cp->valuator->lasty;
|
||||
else
|
||||
y = pDev->valuator->lasty;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (flags & POINTER_ACCELERATE)
|
||||
acceleratePointer(pDev, first_valuator, num_valuators,
|
||||
valuators);
|
||||
|
||||
if (pDev->coreEvents) {
|
||||
if (first_valuator == 0 && num_valuators >= 1)
|
||||
x = cp->valuator->lastx + valuators[0];
|
||||
else
|
||||
x = cp->valuator->lastx;
|
||||
|
||||
if (first_valuator <= 1 && num_valuators >= (2 - first_valuator))
|
||||
y = cp->valuator->lasty + valuators[1 - first_valuator];
|
||||
else
|
||||
y = cp->valuator->lasty;
|
||||
}
|
||||
else {
|
||||
if (first_valuator == 0 && num_valuators >= 1)
|
||||
x = pDev->valuator->lastx + valuators[0];
|
||||
else
|
||||
x = pDev->valuator->lastx;
|
||||
|
||||
if (first_valuator <= 1 && num_valuators >= (2 - first_valuator))
|
||||
y = pDev->valuator->lasty + valuators[1 - first_valuator];
|
||||
else
|
||||
y = pDev->valuator->lasty;
|
||||
}
|
||||
}
|
||||
|
||||
/* Clip both x and y to the defined limits (usually co-ord space limit). */
|
||||
clipAxis(pDev, 0, &x);
|
||||
clipAxis(pDev, 1, &y);
|
||||
|
||||
/* This takes care of crossing screens for us, as well as clipping
|
||||
* to the current screen. Right now, we only have one history buffer,
|
||||
* so we don't set this for both the device and core.*/
|
||||
miPointerSetPosition(pDev, &x, &y, ms);
|
||||
|
||||
/* Drop x and y back into the valuators list, if they were originally
|
||||
* present. */
|
||||
if (first_valuator == 0 && num_valuators >= 1)
|
||||
valuators[0] = x;
|
||||
if (first_valuator <= 1 && num_valuators >= (2 - first_valuator))
|
||||
valuators[1 - first_valuator] = y;
|
||||
|
||||
updateMotionHistory(pDev, ms, first_valuator, num_valuators, valuators);
|
||||
|
||||
if (pDev->coreEvents) {
|
||||
cp->valuator->lastx = x;
|
||||
cp->valuator->lasty = y;
|
||||
}
|
||||
pDev->valuator->lastx = x;
|
||||
pDev->valuator->lasty = y;
|
||||
|
||||
if (type == MotionNotify) {
|
||||
kbp->type = DeviceMotionNotify;
|
||||
}
|
||||
else {
|
||||
if (type == ButtonPress)
|
||||
kbp->type = DeviceButtonPress;
|
||||
else if (type == ButtonRelease)
|
||||
kbp->type = DeviceButtonRelease;
|
||||
kbp->detail = pDev->button->map[buttons];
|
||||
}
|
||||
|
||||
kbp->root_x = x;
|
||||
kbp->root_y = y;
|
||||
|
||||
events++;
|
||||
if (sendValuators) {
|
||||
kbp->deviceid |= MORE_EVENTS;
|
||||
clipValuators(pDev, first_valuator, num_valuators, valuators);
|
||||
events = getValuatorEvents(events, pDev, first_valuator,
|
||||
num_valuators, valuators);
|
||||
}
|
||||
|
||||
if (pDev->coreEvents) {
|
||||
events->u.u.type = type;
|
||||
events->u.keyButtonPointer.time = ms;
|
||||
events->u.keyButtonPointer.rootX = x;
|
||||
events->u.keyButtonPointer.rootY = y;
|
||||
|
||||
if (type == ButtonPress || type == ButtonRelease) {
|
||||
/* We hijack SetPointerMapping to work on all core-sending
|
||||
* devices, so we use the device-specific map here instead of
|
||||
* the core one. */
|
||||
events->u.u.detail = pDev->button->map[buttons];
|
||||
}
|
||||
else {
|
||||
events->u.u.detail = 0;
|
||||
}
|
||||
}
|
||||
|
||||
return num_events;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Post ProximityIn/ProximityOut events, accompanied by valuators.
|
||||
*
|
||||
* events is not NULL-terminated; the return value is the number of events.
|
||||
* The DDX is responsible for allocating the event structure in the first
|
||||
* place via GetMaximumEventsNum(), and for freeing it.
|
||||
*/
|
||||
_X_EXPORT int
|
||||
GetProximityEvents(xEvent *events, DeviceIntPtr pDev, int type,
|
||||
int first_valuator, int num_valuators, int *valuators)
|
||||
{
|
||||
int num_events = 0;
|
||||
deviceKeyButtonPointer *kbp = (deviceKeyButtonPointer *) events;
|
||||
|
||||
/* Sanity checks. */
|
||||
if (type != ProximityIn && type != ProximityOut)
|
||||
return 0;
|
||||
|
||||
if (!pDev->valuator)
|
||||
return 0;
|
||||
|
||||
/* Do we need to send a DeviceValuator event? */
|
||||
if ((pDev->valuator->mode & 1) == Relative)
|
||||
num_valuators = 0;
|
||||
|
||||
if (num_valuators) {
|
||||
if ((((num_valuators - 1) / 6) + 1) > MAX_VALUATOR_EVENTS)
|
||||
num_valuators = MAX_VALUATOR_EVENTS * 6;
|
||||
num_events += ((num_valuators - 1) / 6) + 1;
|
||||
}
|
||||
|
||||
/* You fail. */
|
||||
if (first_valuator < 0 ||
|
||||
(num_valuators + first_valuator) > pDev->valuator->numAxes)
|
||||
return 0;
|
||||
|
||||
kbp->type = type;
|
||||
kbp->deviceid = pDev->id;
|
||||
kbp->detail = 0;
|
||||
kbp->time = GetTimeInMillis();
|
||||
|
||||
if (num_valuators) {
|
||||
kbp->deviceid |= MORE_EVENTS;
|
||||
events++;
|
||||
clipValuators(pDev, first_valuator, num_valuators, valuators);
|
||||
events = getValuatorEvents(events, pDev, first_valuator,
|
||||
num_valuators, valuators);
|
||||
}
|
||||
|
||||
return num_events;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Note that pDev was the last device to send a core event. This function
|
||||
* copies the complete keymap from the originating device to the core
|
||||
* device, and makes sure the appropriate notifications are generated.
|
||||
*
|
||||
* Call this just before processInputProc.
|
||||
*/
|
||||
_X_EXPORT void
|
||||
SwitchCoreKeyboard(DeviceIntPtr pDev)
|
||||
{
|
||||
KeyClassPtr ckeyc = inputInfo.keyboard->key;
|
||||
|
||||
if (inputInfo.keyboard->devPrivates[CoreDevicePrivatesIndex].ptr != pDev) {
|
||||
memcpy(ckeyc->modifierMap, pDev->key->modifierMap, MAP_LENGTH);
|
||||
if (ckeyc->modifierKeyMap)
|
||||
xfree(ckeyc->modifierKeyMap);
|
||||
ckeyc->modifierKeyMap = xalloc(8 * pDev->key->maxKeysPerModifier);
|
||||
memcpy(ckeyc->modifierKeyMap, pDev->key->modifierKeyMap,
|
||||
(8 * pDev->key->maxKeysPerModifier));
|
||||
|
||||
ckeyc->maxKeysPerModifier = pDev->key->maxKeysPerModifier;
|
||||
ckeyc->curKeySyms.minKeyCode = pDev->key->curKeySyms.minKeyCode;
|
||||
ckeyc->curKeySyms.maxKeyCode = pDev->key->curKeySyms.maxKeyCode;
|
||||
SetKeySymsMap(&ckeyc->curKeySyms, &pDev->key->curKeySyms);
|
||||
|
||||
#ifdef XKB
|
||||
if (!noXkbExtension && pDev->key->xkbInfo && pDev->key->xkbInfo->desc) {
|
||||
if (!XkbCopyKeymap(pDev->key->xkbInfo->desc, ckeyc->xkbInfo->desc,
|
||||
True))
|
||||
FatalError("Couldn't pivot keymap from device to core!\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
SendMappingNotify(MappingKeyboard, ckeyc->curKeySyms.minKeyCode,
|
||||
(ckeyc->curKeySyms.maxKeyCode -
|
||||
ckeyc->curKeySyms.minKeyCode),
|
||||
serverClient);
|
||||
inputInfo.keyboard->devPrivates[CoreDevicePrivatesIndex].ptr = pDev;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Note that pDev was the last function to send a core pointer event.
|
||||
* Currently a no-op.
|
||||
*
|
||||
* Call this just before processInputProc.
|
||||
*/
|
||||
_X_EXPORT void
|
||||
SwitchCorePointer(DeviceIntPtr pDev)
|
||||
{
|
||||
if (inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr != pDev)
|
||||
inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr = pDev;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Synthesize a single motion event for the core pointer.
|
||||
*
|
||||
* Used in cursor functions, e.g. when cursor confinement changes, and we need
|
||||
* to shift the pointer to get it inside the new bounds.
|
||||
*/
|
||||
void
|
||||
PostSyntheticMotion(int x, int y, ScreenPtr pScreen, unsigned long time)
|
||||
{
|
||||
xEvent xE;
|
||||
|
||||
#ifdef PANORAMIX
|
||||
/* Translate back to the sprite screen since processInputProc
|
||||
will translate from sprite screen to screen 0 upon reentry
|
||||
to the DIX layer. */
|
||||
if (!noPanoramiXExtension) {
|
||||
x += panoramiXdataPtr[0].x - panoramiXdataPtr[pScreen->myNum].x;
|
||||
y += panoramiXdataPtr[0].y - panoramiXdataPtr[pScreen->myNum].y;
|
||||
}
|
||||
#endif
|
||||
|
||||
memset(&xE, 0, sizeof(xEvent));
|
||||
xE.u.u.type = MotionNotify;
|
||||
xE.u.keyButtonPointer.rootX = x;
|
||||
xE.u.keyButtonPointer.rootY = y;
|
||||
xE.u.keyButtonPointer.time = time;
|
||||
|
||||
(*inputInfo.pointer->public.processInputProc)(&xE, inputInfo.pointer, 1);
|
||||
}
|
|
@ -105,7 +105,7 @@ int ScreenSaverAllowExposures;
|
|||
# define DEFAULT_OFF_TIME DEFAULT_SCREEN_SAVER_TIME * 4
|
||||
# endif
|
||||
# ifndef DEFAULT_DPMS_ENABLED
|
||||
# define DEFAULT_DPMS_ENABLED FALSE
|
||||
# define DEFAULT_DPMS_ENABLED TRUE
|
||||
# endif
|
||||
CARD32 defaultDPMSStandbyTime = DEFAULT_STANDBY_TIME;
|
||||
CARD32 defaultDPMSSuspendTime = DEFAULT_SUSPEND_TIME;
|
||||
|
|
47
dix/main.c
47
dix/main.c
|
@ -98,6 +98,7 @@ Equipment Corporation.
|
|||
#include <X11/fonts/font.h>
|
||||
#include "opaque.h"
|
||||
#include "servermd.h"
|
||||
#include "hotplug.h"
|
||||
#include "site.h"
|
||||
#include "dixfont.h"
|
||||
#include "extnsionst.h"
|
||||
|
@ -309,7 +310,8 @@ main(int argc, char *argv[], char *envp[])
|
|||
#endif
|
||||
InitBlockAndWakeupHandlers();
|
||||
/* Perform any operating system dependent initializations you'd like */
|
||||
OsInit();
|
||||
OsInit();
|
||||
configInitialise();
|
||||
if(serverGeneration == 1)
|
||||
{
|
||||
CreateWellKnownSockets();
|
||||
|
@ -394,23 +396,43 @@ main(int argc, char *argv[], char *envp[])
|
|||
if (!CreateRootWindow(pScreen))
|
||||
FatalError("failed to create root window");
|
||||
}
|
||||
InitCoreDevices();
|
||||
InitInput(argc, argv);
|
||||
if (InitAndStartDevices() != Success)
|
||||
FatalError("failed to initialize core devices");
|
||||
|
||||
InitFonts();
|
||||
#ifdef BUILTIN_FONTS
|
||||
defaultFontPath = "built-ins";
|
||||
#else
|
||||
if (loadableFonts) {
|
||||
SetFontPath(0, 0, (unsigned char *)defaultFontPath, &error);
|
||||
} else {
|
||||
} else
|
||||
#endif
|
||||
{
|
||||
if (SetDefaultFontPath(defaultFontPath) != Success)
|
||||
ErrorF("failed to set default font path '%s'",
|
||||
defaultFontPath);
|
||||
}
|
||||
if (!SetDefaultFont(defaultTextFont))
|
||||
if (!SetDefaultFont(defaultTextFont)) {
|
||||
FatalError("could not open default font '%s'", defaultTextFont);
|
||||
if (!(rootCursor = CreateRootCursor(defaultCursorFont, 0)))
|
||||
}
|
||||
#ifdef NULL_ROOT_CURSOR
|
||||
cm.width = 0;
|
||||
cm.height = 0;
|
||||
cm.xhot = 0;
|
||||
cm.yhot = 0;
|
||||
|
||||
if (!(rootCursor = AllocCursor(NULL, NULL, &cm, 0, 0, 0, 0, 0, 0))) {
|
||||
FatalError("could not create empty root cursor");
|
||||
}
|
||||
AddResource(FakeClientID(0), RT_CURSOR, (pointer)rootCursor);
|
||||
#else
|
||||
if (!(rootCursor = CreateRootCursor(defaultCursorFont, 0))) {
|
||||
FatalError("could not open default cursor font '%s'",
|
||||
defaultCursorFont);
|
||||
}
|
||||
#endif
|
||||
#ifdef DPMSExtension
|
||||
/* check all screens, looking for DPMS Capabilities */
|
||||
DPMSCapableFlag = DPMSSupported();
|
||||
|
@ -433,13 +455,15 @@ main(int argc, char *argv[], char *envp[])
|
|||
|
||||
#ifdef PANORAMIX
|
||||
if (!noPanoramiXExtension) {
|
||||
if (!PanoramiXCreateConnectionBlock())
|
||||
if (!PanoramiXCreateConnectionBlock()) {
|
||||
FatalError("could not create connection block info");
|
||||
}
|
||||
} else
|
||||
#endif
|
||||
{
|
||||
if (!CreateConnectionBlock())
|
||||
if (!CreateConnectionBlock()) {
|
||||
FatalError("could not create connection block info");
|
||||
}
|
||||
}
|
||||
|
||||
Dispatch();
|
||||
|
@ -461,6 +485,7 @@ main(int argc, char *argv[], char *envp[])
|
|||
FreeAllResources();
|
||||
#endif
|
||||
|
||||
configFini();
|
||||
CloseDownDevices();
|
||||
for (i = screenInfo.numScreens - 1; i >= 0; i--)
|
||||
{
|
||||
|
@ -681,9 +706,6 @@ AddScreen(
|
|||
int i;
|
||||
int scanlinepad, format, depth, bitsPerPixel, j, k;
|
||||
ScreenPtr pScreen;
|
||||
#ifdef DEBUG
|
||||
void (**jNI) ();
|
||||
#endif /* DEBUG */
|
||||
|
||||
i = screenInfo.numScreens;
|
||||
if (i == MAXSCREENS)
|
||||
|
@ -717,13 +739,6 @@ AddScreen(
|
|||
pScreen->ClipNotify = 0; /* for R4 ddx compatibility */
|
||||
pScreen->CreateScreenResources = 0;
|
||||
|
||||
#ifdef DEBUG
|
||||
for (jNI = &pScreen->QueryBestSize;
|
||||
jNI < (void (**) ()) &pScreen->SendGraphicsExpose;
|
||||
jNI++)
|
||||
*jNI = NotImplemented;
|
||||
#endif /* DEBUG */
|
||||
|
||||
/*
|
||||
* This loop gets run once for every Screen that gets added,
|
||||
* but thats ok. If the ddx layer initializes the formats
|
||||
|
|
|
@ -58,9 +58,7 @@ SOFTWARE.
|
|||
#include "dixstruct.h"
|
||||
#include "dispatch.h"
|
||||
#include "swaprep.h"
|
||||
#ifdef XACE
|
||||
#include "xace.h"
|
||||
#endif
|
||||
|
||||
/*****************************************************************
|
||||
* Property Stuff
|
||||
|
@ -118,27 +116,19 @@ ProcRotateProperties(ClientPtr client)
|
|||
return(BadAlloc);
|
||||
for (i = 0; i < stuff->nAtoms; i++)
|
||||
{
|
||||
#ifdef XACE
|
||||
char action = XaceHook(XACE_PROPERTY_ACCESS, client, pWin, atoms[i],
|
||||
SecurityReadAccess|SecurityWriteAccess);
|
||||
#endif
|
||||
if (!ValidAtom(atoms[i])
|
||||
#ifdef XACE
|
||||
|| (SecurityErrorOperation == action)
|
||||
#endif
|
||||
)
|
||||
{
|
||||
|
||||
if (!ValidAtom(atoms[i]) || (XaceErrorOperation == action)) {
|
||||
DEALLOCATE_LOCAL(props);
|
||||
client->errorValue = atoms[i];
|
||||
return BadAtom;
|
||||
}
|
||||
#ifdef XACE
|
||||
if (SecurityIgnoreOperation == action)
|
||||
{
|
||||
if (XaceIgnoreOperation == action) {
|
||||
DEALLOCATE_LOCAL(props);
|
||||
return Success;
|
||||
}
|
||||
#endif
|
||||
|
||||
for (j = i + 1; j < stuff->nAtoms; j++)
|
||||
if (atoms[j] == atoms[i])
|
||||
{
|
||||
|
@ -233,17 +223,15 @@ ProcChangeProperty(ClientPtr client)
|
|||
return(BadAtom);
|
||||
}
|
||||
|
||||
#ifdef XACE
|
||||
switch (XaceHook(XACE_PROPERTY_ACCESS, client, pWin, stuff->property,
|
||||
SecurityWriteAccess))
|
||||
SecurityWriteAccess))
|
||||
{
|
||||
case SecurityErrorOperation:
|
||||
client->errorValue = stuff->property;
|
||||
return BadAtom;
|
||||
case SecurityIgnoreOperation:
|
||||
return Success;
|
||||
case XaceErrorOperation:
|
||||
client->errorValue = stuff->property;
|
||||
return BadAtom;
|
||||
case XaceIgnoreOperation:
|
||||
return Success;
|
||||
}
|
||||
#endif
|
||||
|
||||
err = ChangeWindowProperty(pWin, stuff->property, stuff->type, (int)format,
|
||||
(int)mode, len, (pointer)&stuff[1], TRUE);
|
||||
|
@ -460,6 +448,7 @@ ProcGetProperty(ClientPtr client)
|
|||
unsigned long n, len, ind;
|
||||
WindowPtr pWin;
|
||||
xGetPropertyReply reply;
|
||||
Mask access_mode = SecurityReadAccess;
|
||||
REQUEST(xGetPropertyReq);
|
||||
|
||||
REQUEST_SIZE_MATCH(xGetPropertyReq);
|
||||
|
@ -501,24 +490,18 @@ ProcGetProperty(ClientPtr client)
|
|||
if (!pProp)
|
||||
return NullPropertyReply(client, None, 0, &reply);
|
||||
|
||||
#ifdef XACE
|
||||
if (stuff->delete)
|
||||
access_mode |= SecurityDestroyAccess;
|
||||
switch (XaceHook(XACE_PROPERTY_ACCESS, client, pWin, stuff->property,
|
||||
access_mode))
|
||||
{
|
||||
Mask access_mode = SecurityReadAccess;
|
||||
|
||||
if (stuff->delete)
|
||||
access_mode |= SecurityDestroyAccess;
|
||||
switch(XaceHook(XACE_PROPERTY_ACCESS, client, pWin, stuff->property,
|
||||
access_mode))
|
||||
{
|
||||
case SecurityErrorOperation:
|
||||
client->errorValue = stuff->property;
|
||||
return BadAtom;;
|
||||
case SecurityIgnoreOperation:
|
||||
return NullPropertyReply(client, pProp->type, pProp->format,
|
||||
&reply);
|
||||
}
|
||||
case XaceErrorOperation:
|
||||
client->errorValue = stuff->property;
|
||||
return BadAtom;;
|
||||
case XaceIgnoreOperation:
|
||||
return NullPropertyReply(client, pProp->type, pProp->format, &reply);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* If the request type and actual type don't match. Return the
|
||||
property information, but not the data. */
|
||||
|
||||
|
@ -663,17 +646,15 @@ ProcDeleteProperty(register ClientPtr client)
|
|||
return (BadAtom);
|
||||
}
|
||||
|
||||
#ifdef XACE
|
||||
switch(XaceHook(XACE_PROPERTY_ACCESS, client, pWin, stuff->property,
|
||||
SecurityDestroyAccess))
|
||||
switch (XaceHook(XACE_PROPERTY_ACCESS, client, pWin, stuff->property,
|
||||
SecurityDestroyAccess))
|
||||
{
|
||||
case SecurityErrorOperation:
|
||||
client->errorValue = stuff->property;
|
||||
return BadAtom;;
|
||||
case SecurityIgnoreOperation:
|
||||
return Success;
|
||||
case XaceErrorOperation:
|
||||
client->errorValue = stuff->property;
|
||||
return BadAtom;;
|
||||
case XaceIgnoreOperation:
|
||||
return Success;
|
||||
}
|
||||
#endif
|
||||
|
||||
result = DeleteProperty(pWin, stuff->property);
|
||||
if (client->noClientException != Success)
|
||||
|
|
|
@ -72,6 +72,34 @@ dealings in this Software without prior written authorization from Digital
|
|||
Equipment Corporation.
|
||||
|
||||
******************************************************************/
|
||||
/* XSERVER_DTRACE additions:
|
||||
* Copyright 2005-2006 Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, and/or sell copies of the Software, and to permit persons
|
||||
* to whom the Software is furnished to do so, provided that the above
|
||||
* copyright notice(s) and this permission notice appear in all copies of
|
||||
* the Software and that both the above copyright notice(s) and this
|
||||
* permission notice appear in supporting documentation.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
|
||||
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
|
||||
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
|
||||
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
|
||||
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
|
||||
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the name of a copyright holder
|
||||
* shall not be used in advertising or otherwise to promote the sale, use
|
||||
* or other dealings in this Software without prior written authorization
|
||||
* of the copyright holder.
|
||||
*/
|
||||
|
||||
/* $TOG: resource.c /main/41 1998/02/09 14:20:31 kaleb $ */
|
||||
|
||||
|
@ -120,11 +148,17 @@ Equipment Corporation.
|
|||
#include "panoramiX.h"
|
||||
#include "panoramiXsrv.h"
|
||||
#endif
|
||||
#ifdef XACE
|
||||
#include "xace.h"
|
||||
#endif
|
||||
#include <assert.h>
|
||||
|
||||
#ifdef XSERVER_DTRACE
|
||||
#include <sys/types.h>
|
||||
typedef const char *string;
|
||||
#include "Xserver-dtrace.h"
|
||||
|
||||
#define TypeNameString(t) NameForAtom(ResourceNames[t & TypeMask])
|
||||
#endif
|
||||
|
||||
static void RebuildTable(
|
||||
int /*client*/
|
||||
);
|
||||
|
@ -429,6 +463,9 @@ AddResource(XID id, RESTYPE type, pointer value)
|
|||
register ClientResourceRec *rrec;
|
||||
register ResourcePtr res, *head;
|
||||
|
||||
#ifdef XSERVER_DTRACE
|
||||
XSERVER_RESOURCE_ALLOC(id, type, value, TypeNameString(type));
|
||||
#endif
|
||||
client = CLIENT_ID(id);
|
||||
rrec = &clientTable[client];
|
||||
if (!rrec->buckets)
|
||||
|
@ -528,6 +565,11 @@ FreeResource(XID id, RESTYPE skipDeleteFuncType)
|
|||
if (res->id == id)
|
||||
{
|
||||
RESTYPE rtype = res->type;
|
||||
|
||||
#ifdef XSERVER_DTRACE
|
||||
XSERVER_RESOURCE_FREE(res->id, res->type,
|
||||
res->value, TypeNameString(res->type));
|
||||
#endif
|
||||
*prev = res->next;
|
||||
elements = --*eltptr;
|
||||
if (rtype & RC_CACHED)
|
||||
|
@ -569,6 +611,10 @@ FreeResourceByType(XID id, RESTYPE type, Bool skipFree)
|
|||
{
|
||||
if (res->id == id && res->type == type)
|
||||
{
|
||||
#ifdef XSERVER_DTRACE
|
||||
XSERVER_RESOURCE_FREE(res->id, res->type,
|
||||
res->value, TypeNameString(res->type));
|
||||
#endif
|
||||
*prev = res->next;
|
||||
if (type & RC_CACHED)
|
||||
FlushClientCaches(res->id);
|
||||
|
@ -731,6 +777,10 @@ FreeClientNeverRetainResources(ClientPtr client)
|
|||
RESTYPE rtype = this->type;
|
||||
if (rtype & RC_NEVERRETAIN)
|
||||
{
|
||||
#ifdef XSERVER_DTRACE
|
||||
XSERVER_RESOURCE_FREE(this->id, this->type,
|
||||
this->value, TypeNameString(this->type));
|
||||
#endif
|
||||
*prev = this->next;
|
||||
if (rtype & RC_CACHED)
|
||||
FlushClientCaches(this->id);
|
||||
|
@ -777,6 +827,10 @@ FreeClientResources(ClientPtr client)
|
|||
for (this = *head; this; this = *head)
|
||||
{
|
||||
RESTYPE rtype = this->type;
|
||||
#ifdef XSERVER_DTRACE
|
||||
XSERVER_RESOURCE_FREE(this->id, this->type,
|
||||
this->value, TypeNameString(this->type));
|
||||
#endif
|
||||
*head = this->next;
|
||||
if (rtype & RC_CACHED)
|
||||
FlushClientCaches(this->id);
|
||||
|
@ -848,11 +902,10 @@ SecurityLookupIDByType(ClientPtr client, XID id, RESTYPE rtype, Mask mode)
|
|||
break;
|
||||
}
|
||||
}
|
||||
#ifdef XACE
|
||||
if (retval && client &&
|
||||
!XaceHook(XACE_RESOURCE_ACCESS, client, id, rtype, mode, retval))
|
||||
retval = NULL;
|
||||
#endif
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
@ -876,11 +929,10 @@ SecurityLookupIDByClass(ClientPtr client, XID id, RESTYPE classes, Mask mode)
|
|||
break;
|
||||
}
|
||||
}
|
||||
#ifdef XACE
|
||||
if (retval && client &&
|
||||
!XaceHook(XACE_RESOURCE_ACCESS, client, id, res->type, mode, retval))
|
||||
retval = NULL;
|
||||
#endif
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
|
65
dix/window.c
65
dix/window.c
|
@ -126,9 +126,7 @@ Equipment Corporation.
|
|||
#ifdef XAPPGROUP
|
||||
#include "appgroup.h"
|
||||
#endif
|
||||
#ifdef XACE
|
||||
#include "xace.h"
|
||||
#endif
|
||||
|
||||
/******
|
||||
* Window stuff for server
|
||||
|
@ -187,7 +185,7 @@ _X_EXPORT int deltaSaveUndersViewable = 0;
|
|||
* For debugging only
|
||||
******/
|
||||
|
||||
int
|
||||
static void
|
||||
PrintChildren(WindowPtr p1, int indent)
|
||||
{
|
||||
WindowPtr p2;
|
||||
|
@ -197,14 +195,15 @@ PrintChildren(WindowPtr p1, int indent)
|
|||
{
|
||||
p2 = p1->firstChild;
|
||||
for (i=0; i<indent; i++) ErrorF( " ");
|
||||
ErrorF( "%x\n", p1->drawable.id);
|
||||
ErrorF( "%lx\n", p1->drawable.id);
|
||||
miPrintRegion(&p1->clipList);
|
||||
PrintChildren(p2, indent+4);
|
||||
p1 = p1->nextSib;
|
||||
}
|
||||
}
|
||||
|
||||
PrintWindowTree()
|
||||
static void
|
||||
PrintWindowTree(void)
|
||||
{
|
||||
int i;
|
||||
WindowPtr pWin, p1;
|
||||
|
@ -530,9 +529,7 @@ InitRootWindow(WindowPtr pWin)
|
|||
/* We SHOULD check for an error value here XXX */
|
||||
(*pScreen->ChangeWindowAttributes)(pWin, backFlag);
|
||||
|
||||
#ifdef XACE
|
||||
XaceHook(XACE_WINDOW_INIT, serverClient, pWin);
|
||||
#endif
|
||||
|
||||
MapWindow(pWin, serverClient);
|
||||
}
|
||||
|
@ -547,9 +544,11 @@ ClippedRegionFromBox(register WindowPtr pWin, RegionPtr Rgn,
|
|||
register int x, register int y,
|
||||
register int w, register int h)
|
||||
{
|
||||
ScreenPtr pScreen = pWin->drawable.pScreen;
|
||||
ScreenPtr pScreen;
|
||||
BoxRec box;
|
||||
|
||||
pScreen = pWin->drawable.pScreen;
|
||||
|
||||
box = *(REGION_EXTENTS(pScreen, &pWin->winSize));
|
||||
/* we do these calculations to avoid overflows */
|
||||
if (x > box.x1)
|
||||
|
@ -735,18 +734,16 @@ CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
|
|||
}
|
||||
|
||||
pWin->borderWidth = bw;
|
||||
#ifdef XACE
|
||||
|
||||
/* can't let untrusted clients have background None windows;
|
||||
* they make it too easy to steal window contents
|
||||
*/
|
||||
if (!XaceHook(XACE_BACKGRND_ACCESS, client, pWin))
|
||||
{
|
||||
if (XaceHook(XACE_BACKGRND_ACCESS, client, pWin))
|
||||
pWin->backgroundState = None;
|
||||
else {
|
||||
pWin->backgroundState = BackgroundPixel;
|
||||
pWin->background.pixel = 0;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
pWin->backgroundState = None;
|
||||
|
||||
pWin->borderIsPixel = pParent->borderIsPixel;
|
||||
pWin->border = pParent->border;
|
||||
|
@ -766,9 +763,7 @@ CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
|
|||
REGION_NULL(pScreen, &pWin->winSize);
|
||||
REGION_NULL(pScreen, &pWin->borderSize);
|
||||
|
||||
#ifdef XACE
|
||||
XaceHook(XACE_WINDOW_INIT, client, pWin);
|
||||
#endif
|
||||
|
||||
pHead = RealChildHead(pParent);
|
||||
if (pHead)
|
||||
|
@ -1033,24 +1028,18 @@ ChangeWindowAttributes(register WindowPtr pWin, Mask vmask, XID *vlist, ClientPt
|
|||
borderRelative = TRUE;
|
||||
if (pixID == None)
|
||||
{
|
||||
#ifdef XACE
|
||||
/* can't let untrusted clients have background None windows */
|
||||
if (XaceHook(XACE_BACKGRND_ACCESS, client, pWin))
|
||||
{
|
||||
#endif
|
||||
if (pWin->backgroundState == BackgroundPixmap)
|
||||
(*pScreen->DestroyPixmap)(pWin->background.pixmap);
|
||||
if (!pWin->parent)
|
||||
MakeRootTile(pWin);
|
||||
else
|
||||
pWin->backgroundState = None;
|
||||
#ifdef XACE
|
||||
}
|
||||
else
|
||||
{ /* didn't change the background to None, so don't tell ddx */
|
||||
if (XaceHook(XACE_BACKGRND_ACCESS, client, pWin)) {
|
||||
if (pWin->backgroundState == BackgroundPixmap)
|
||||
(*pScreen->DestroyPixmap)(pWin->background.pixmap);
|
||||
if (!pWin->parent)
|
||||
MakeRootTile(pWin);
|
||||
else
|
||||
pWin->backgroundState = None;
|
||||
} else {
|
||||
/* didn't change the backgrnd to None, so don't tell ddx */
|
||||
index2 = 0;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else if (pixID == ParentRelative)
|
||||
{
|
||||
|
@ -1663,7 +1652,8 @@ CreateUnclippedWinSize (register WindowPtr pWin)
|
|||
pRgn = REGION_CREATE(pWin->drawable.pScreen, &box, 1);
|
||||
#ifdef SHAPE
|
||||
if (wBoundingShape (pWin) || wClipShape (pWin)) {
|
||||
ScreenPtr pScreen = pWin->drawable.pScreen;
|
||||
ScreenPtr pScreen;
|
||||
pScreen = pWin->drawable.pScreen;
|
||||
|
||||
REGION_TRANSLATE(pScreen, pRgn, - pWin->drawable.x,
|
||||
- pWin->drawable.y);
|
||||
|
@ -1699,7 +1689,8 @@ SetWinSize (register WindowPtr pWin)
|
|||
(int)pWin->drawable.height);
|
||||
#ifdef SHAPE
|
||||
if (wBoundingShape (pWin) || wClipShape (pWin)) {
|
||||
ScreenPtr pScreen = pWin->drawable.pScreen;
|
||||
ScreenPtr pScreen;
|
||||
pScreen = pWin->drawable.pScreen;
|
||||
|
||||
REGION_TRANSLATE(pScreen, &pWin->winSize, - pWin->drawable.x,
|
||||
- pWin->drawable.y);
|
||||
|
@ -1741,7 +1732,8 @@ SetBorderSize (register WindowPtr pWin)
|
|||
(int)(pWin->drawable.height + (bw<<1)));
|
||||
#ifdef SHAPE
|
||||
if (wBoundingShape (pWin)) {
|
||||
ScreenPtr pScreen = pWin->drawable.pScreen;
|
||||
ScreenPtr pScreen;
|
||||
pScreen = pWin->drawable.pScreen;
|
||||
|
||||
REGION_TRANSLATE(pScreen, &pWin->borderSize, - pWin->drawable.x,
|
||||
- pWin->drawable.y);
|
||||
|
@ -1952,7 +1944,8 @@ MakeBoundingRegion (
|
|||
BoxPtr pBox)
|
||||
{
|
||||
RegionPtr pRgn;
|
||||
ScreenPtr pScreen = pWin->drawable.pScreen;
|
||||
ScreenPtr pScreen;
|
||||
pScreen = pWin->drawable.pScreen;
|
||||
|
||||
pRgn = REGION_CREATE(pScreen, pBox, 1);
|
||||
if (wBoundingShape (pWin)) {
|
||||
|
@ -2732,11 +2725,9 @@ MapWindow(register WindowPtr pWin, ClientPtr client)
|
|||
if (pWin->mapped)
|
||||
return(Success);
|
||||
|
||||
#ifdef XACE
|
||||
/* general check for permission to map window */
|
||||
if (!XaceHook(XACE_MAP_ACCESS, client, pWin))
|
||||
return Success;
|
||||
#endif
|
||||
|
||||
pScreen = pWin->drawable.pScreen;
|
||||
if ( (pParent = pWin->parent) )
|
||||
|
|
32
doc/c-extensions
Normal file
32
doc/c-extensions
Normal file
|
@ -0,0 +1,32 @@
|
|||
Use of extensions throughout the X server tree
|
||||
----------------------------------------------
|
||||
|
||||
Optional extensions:
|
||||
The server will still build if your toolchain does not support these
|
||||
extensions, although the results may not be optimal.
|
||||
|
||||
* _X_SENTINEL(x): member x of the passed structure must be NULL, e.g.:
|
||||
void parseOptions(Option *options _X_SENTINEL(0));
|
||||
parseOptions("foo", "bar", NULL); /* this is OK */
|
||||
parseOptions("foo", "bar", "baz"); /* this is not */
|
||||
This definition comes from Xfuncproto.h in the core
|
||||
protocol headers.
|
||||
* _X_ATTRIBUTE_PRINTF(x, y): This function has printf-like semantics;
|
||||
check the format string when built with
|
||||
-Wformat (gcc) or similar.
|
||||
* _X_EXPORT: this function should appear in symbol tables.
|
||||
* _X_HIDDEN: this function should not appear in the _dynamic_ symbol
|
||||
table.
|
||||
* _X_INTERNAL: like _X_HIDDEN, but attempt to ensure that this function
|
||||
is never called from another module.
|
||||
* _X_INLINE: inline this functon if possible (generally obeyed unless
|
||||
disabling optimisations).
|
||||
* _X_DEPRECATED: warn on use of this function.
|
||||
|
||||
Mandatory extensions:
|
||||
The server will not build if your toolchain does not support these extensions.
|
||||
|
||||
* named initialisers: explicitly initialising structure members, e.g.:
|
||||
struct foo bar = { .baz = quux, .brian = "dog" };
|
||||
* variadic macros: macros with a variable number of arguments, e.g.:
|
||||
#define DebugF(x, ...) /**/
|
3
fb/fb.h
3
fb/fb.h
|
@ -1341,6 +1341,9 @@ fbCreateDefColormap(ScreenPtr pScreen);
|
|||
void
|
||||
fbClearVisualTypes(void);
|
||||
|
||||
Bool
|
||||
fbHasVisualTypes (int depth);
|
||||
|
||||
Bool
|
||||
fbSetVisualTypes (int depth, int visuals, int bitsPerRGB);
|
||||
|
||||
|
|
15
fb/fbpict.c
15
fb/fbpict.c
|
@ -930,9 +930,8 @@ fbComposite (CARD8 op,
|
|||
case PictOpOver:
|
||||
if (pMask)
|
||||
{
|
||||
if (srcRepeat &&
|
||||
pSrc->pDrawable->width == 1 &&
|
||||
pSrc->pDrawable->height == 1)
|
||||
if (fbCanGetSolid(pSrc) &&
|
||||
!maskRepeat)
|
||||
{
|
||||
srcRepeat = FALSE;
|
||||
if (PICT_FORMAT_COLOR(pSrc->format)) {
|
||||
|
@ -1044,7 +1043,7 @@ fbComposite (CARD8 op,
|
|||
{
|
||||
if (pSrc->pDrawable == pMask->pDrawable &&
|
||||
xSrc == xMask && ySrc == yMask &&
|
||||
!pMask->componentAlpha)
|
||||
!pMask->componentAlpha && !maskRepeat)
|
||||
{
|
||||
/* source == mask: non-premultiplied data */
|
||||
switch (pSrc->format) {
|
||||
|
@ -1108,9 +1107,7 @@ fbComposite (CARD8 op,
|
|||
else
|
||||
{
|
||||
/* non-repeating source, repeating mask => translucent window */
|
||||
if (maskRepeat &&
|
||||
pMask->pDrawable->width == 1 &&
|
||||
pMask->pDrawable->height == 1)
|
||||
if (fbCanGetSolid(pMask))
|
||||
{
|
||||
if (pSrc->format == PICT_x8r8g8b8 &&
|
||||
pDst->format == PICT_x8r8g8b8 &&
|
||||
|
@ -1127,9 +1124,7 @@ fbComposite (CARD8 op,
|
|||
}
|
||||
else /* no mask */
|
||||
{
|
||||
if (srcRepeat &&
|
||||
pSrc->pDrawable->width == 1 &&
|
||||
pSrc->pDrawable->height == 1)
|
||||
if (fbCanGetSolid(pSrc))
|
||||
{
|
||||
/* no mask and repeating source */
|
||||
switch (pSrc->format) {
|
||||
|
|
47
fb/fbpict.h
47
fb/fbpict.h
|
@ -30,6 +30,13 @@
|
|||
|
||||
#include "renderedge.h"
|
||||
|
||||
|
||||
#if defined(__GNUC__)
|
||||
#define INLINE __inline__
|
||||
#else
|
||||
#define INLINE
|
||||
#endif
|
||||
|
||||
#define FbIntMult(a,b,t) ( (t) = (a) * (b) + 0x80, ( ( ( (t)>>8 ) + (t) )>>8 ) )
|
||||
#define FbIntDiv(a,b) (((CARD16) (a) * 255) / (b))
|
||||
|
||||
|
@ -67,6 +74,40 @@
|
|||
#define Green(x) (((x) >> 8) & 0xff)
|
||||
#define Blue(x) ((x) & 0xff)
|
||||
|
||||
/**
|
||||
* Returns TRUE if the fbComposeGetSolid can be used to get a single solid
|
||||
* color representing every source sampling location of the picture.
|
||||
*/
|
||||
static INLINE Bool
|
||||
fbCanGetSolid(PicturePtr pict)
|
||||
{
|
||||
if (pict->pDrawable == NULL ||
|
||||
pict->pDrawable->width != 1 ||
|
||||
pict->pDrawable->height != 1)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (pict->repeat != RepeatNormal)
|
||||
return FALSE;
|
||||
|
||||
switch (pict->format) {
|
||||
case PICT_a8r8g8b8:
|
||||
case PICT_x8r8g8b8:
|
||||
case PICT_a8b8g8r8:
|
||||
case PICT_x8b8g8r8:
|
||||
case PICT_r8g8b8:
|
||||
case PICT_b8g8r8:
|
||||
case PICT_r5g6b5:
|
||||
case PICT_b5g6r5:
|
||||
return TRUE;
|
||||
default:
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
#define fbCanGetSolid(pict) \
|
||||
(pict->pDrawable != NULL && pict->pDrawable->width == 1 && pict->pDrawable->height == 1)
|
||||
|
||||
#define fbComposeGetSolid(pict, bits, fmt) { \
|
||||
FbBits *__bits__; \
|
||||
FbStride __stride__; \
|
||||
|
@ -322,12 +363,6 @@
|
|||
#define FASTCALL
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__)
|
||||
#define INLINE __inline__
|
||||
#else
|
||||
#define INLINE
|
||||
#endif
|
||||
|
||||
typedef struct _FbComposeData {
|
||||
CARD8 op;
|
||||
PicturePtr src;
|
||||
|
|
|
@ -1020,7 +1020,7 @@ int DarwinModifierStringToNXKey(const char *str)
|
|||
* This allows the ddx layer to prevent some keys from being remapped
|
||||
* as modifier keys.
|
||||
*/
|
||||
Bool LegalModifier(unsigned int key, DevicePtr pDev)
|
||||
Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
|
|
@ -27,7 +27,7 @@ endif
|
|||
|
||||
AM_YFLAGS = -d
|
||||
AM_CFLAGS = \
|
||||
\
|
||||
$(DIX_CFLAGS) \
|
||||
-I$(top_srcdir)/hw/dmx \
|
||||
$(GLX_INCS) \
|
||||
-DHAVE_DMX_CONFIG_H \
|
||||
|
|
|
@ -53,7 +53,7 @@
|
|||
/** Returns TRUE if the key is a valid modifier. For PC-class
|
||||
* keyboards, all keys can be used as modifiers, so return TRUE
|
||||
* always. */
|
||||
Bool LegalModifier(unsigned int key, DevicePtr pDev)
|
||||
Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
|
|
|
@ -32,7 +32,7 @@ libglxproxy_a_SOURCES = compsize.c \
|
|||
unpack.h
|
||||
|
||||
AM_CFLAGS = \
|
||||
\
|
||||
$(DIX_CFLAGS) \
|
||||
-I$(top_srcdir)/hw/dmx \
|
||||
-I$(top_srcdir)/include \
|
||||
-I$(top_srcdir)/GL/include \
|
||||
|
|
|
@ -60,7 +60,7 @@ GLX_DEFS = @GL_CFLAGS@
|
|||
GLX_INCS = -I@MESA_SOURCE@/include
|
||||
endif
|
||||
|
||||
AM_CFLAGS = \
|
||||
AM_CFLAGS = $(DIX_CFLAGS) \
|
||||
-I$(top_srcdir)/hw/dmx \
|
||||
-I$(top_srcdir)/hw/xfree86/common \
|
||||
$(GLX_INCS) \
|
||||
|
|
|
@ -3,10 +3,14 @@ VESA_SUBDIRS = vesa ati chips epson i810 mach64 mga neomagic nvidia pm2 r128 \
|
|||
smi via
|
||||
endif
|
||||
|
||||
if KDRIVEFBDEV
|
||||
if BUILD_KDRIVEFBDEVLIB
|
||||
FBDEV_SUBDIRS = fbdev
|
||||
endif
|
||||
|
||||
if XFAKESERVER
|
||||
XFAKE_SUBDIRS = fake
|
||||
endif
|
||||
|
||||
if XSDLSERVER
|
||||
XSDL_SUBDIRS = sdl
|
||||
endif
|
||||
|
@ -15,14 +19,18 @@ if XEPHYR
|
|||
XEPHYR_SUBDIRS = ephyr
|
||||
endif
|
||||
|
||||
if KDRIVELINUX
|
||||
LINUX_SUBDIRS = linux
|
||||
endif
|
||||
|
||||
SUBDIRS = \
|
||||
src \
|
||||
linux \
|
||||
$(LINUX_SUBDIRS) \
|
||||
$(XSDL_SUBDIRS) \
|
||||
$(FBDEV_SUBDIRS) \
|
||||
$(VESA_SUBDIRS) \
|
||||
$(XEPHYR_SUBDIRS) \
|
||||
fake
|
||||
$(XFAKE_SUBDIRS)
|
||||
|
||||
DIST_SUBDIRS = vesa ati chips epson i810 mach64 mga neomagic nvidia pm2 r128 \
|
||||
smi via fbdev sdl ephyr src linux fake sis300
|
||||
|
|
|
@ -61,12 +61,4 @@ ATI_LIBS = \
|
|||
Xati_LDADD = \
|
||||
$(ATI_LIBS) \
|
||||
@KDRIVE_LIBS@ \
|
||||
@XSERVER_LIBS@
|
||||
|
||||
|
||||
Xati_DEPENDENCIES = \
|
||||
libati.a \
|
||||
$(FBDEV_LIBS) \
|
||||
$(VESA_LIBS) \
|
||||
$(DRI_LIBS)
|
||||
|
||||
@XSERVER_LIBS@
|
||||
|
|
|
@ -53,7 +53,15 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
|
|||
void
|
||||
InitInput(int argc, char **argv)
|
||||
{
|
||||
KdInitInput(&LinuxMouseFuncs, &LinuxKeyboardFuncs);
|
||||
KdKeyboardInfo *ki = NULL;
|
||||
|
||||
KdAddPointerDriver(&LinuxMouseDriver);
|
||||
ki = KdNewKeyboard();
|
||||
if (ki) {
|
||||
ki->driver = &LinuxKeyboardDriver;
|
||||
KdAddKeyboard(ki);
|
||||
}
|
||||
KdInitInput();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
@ -24,7 +24,3 @@ Xchips_LDADD = \
|
|||
$(CHIPS_LIBS) \
|
||||
@KDRIVE_LIBS@ \
|
||||
@XSERVER_LIBS@
|
||||
|
||||
Xchips_DEPENDENCIES = \
|
||||
libchips.a \
|
||||
$(top_builddir)/hw/kdrive/vesa/libvesa.a
|
||||
|
|
|
@ -48,7 +48,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
|
|||
void
|
||||
InitInput (int argc, char **argv)
|
||||
{
|
||||
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
|
||||
KdOsAddInputDrivers ();
|
||||
KdInitInput ();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
@ -28,9 +28,4 @@ Xephyr_LDADD = \
|
|||
libxephyr-hostx.a \
|
||||
../../../exa/libexa.la \
|
||||
@KDRIVE_LIBS@ \
|
||||
@KDRIVE_LIBS@ \
|
||||
@XEPHYR_LIBS@
|
||||
|
||||
Xephyr_DEPENDENCIES = \
|
||||
libxephyr.a \
|
||||
libxephyr-hostx.a
|
||||
|
|
|
@ -36,10 +36,16 @@
|
|||
#include "inputstr.h"
|
||||
|
||||
extern int KdTsPhyScreen;
|
||||
extern DeviceIntPtr pKdKeyboard;
|
||||
KdKeyboardInfo *ephyrKbd;
|
||||
KdPointerInfo *ephyrMouse;
|
||||
EphyrKeySyms ephyrKeySyms;
|
||||
|
||||
static int mouseState = 0;
|
||||
|
||||
typedef struct _EphyrInputPrivate {
|
||||
Bool enabled;
|
||||
} EphyrKbdPrivate, EphyrPointerPrivate;
|
||||
|
||||
Bool EphyrWantGrayScale = 0;
|
||||
|
||||
Bool
|
||||
|
@ -206,15 +212,14 @@ ephyrMapFramebuffer (KdScreenInfo *screen)
|
|||
{
|
||||
EphyrScrPriv *scrpriv = screen->driver;
|
||||
EphyrPriv *priv = screen->card->driver;
|
||||
KdMouseMatrix m;
|
||||
KdPointerMatrix m;
|
||||
int buffer_height;
|
||||
|
||||
EPHYR_DBG(" screen->width: %d, screen->height: %d",
|
||||
screen->width, screen->height);
|
||||
|
||||
KdComputeMouseMatrix (&m, scrpriv->randr, screen->width, screen->height);
|
||||
|
||||
KdSetMouseMatrix (&m);
|
||||
KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
|
||||
KdSetPointerMatrix (&m);
|
||||
|
||||
priv->bytes_per_line = ((screen->width * screen->fb[0].bitsPerPixel + 31) >> 5) << 2;
|
||||
|
||||
|
@ -719,8 +724,9 @@ ephyrUpdateModifierState(unsigned int state)
|
|||
kptr = &keyc->down[key >> 3];
|
||||
bit = 1 << (key & 7);
|
||||
|
||||
if (*kptr & bit)
|
||||
KdEnqueueKeyboardEvent(key, TRUE); /* release */
|
||||
if (*kptr & bit && ephyrKbd &&
|
||||
((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
|
||||
KdEnqueueKeyboardEvent(ephyrKbd, key, TRUE); /* release */
|
||||
|
||||
if (--count == 0)
|
||||
break;
|
||||
|
@ -732,7 +738,9 @@ ephyrUpdateModifierState(unsigned int state)
|
|||
for (key = 0; key < MAP_LENGTH; key++)
|
||||
if (keyc->modifierMap[key] & mask)
|
||||
{
|
||||
KdEnqueueKeyboardEvent(key, FALSE); /* press */
|
||||
if (keyc->modifierMap[key] & mask && ephyrKbd &&
|
||||
((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
|
||||
KdEnqueueKeyboardEvent(ephyrKbd, key, FALSE); /* press */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -748,31 +756,47 @@ ephyrPoll(void)
|
|||
switch (ev.type)
|
||||
{
|
||||
case EPHYR_EV_MOUSE_MOTION:
|
||||
KdEnqueueMouseEvent(kdMouseInfo, mouseState,
|
||||
ev.data.mouse_motion.x,
|
||||
ev.data.mouse_motion.y);
|
||||
if (!ephyrMouse ||
|
||||
!((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled)
|
||||
continue;
|
||||
KdEnqueuePointerEvent(ephyrMouse, mouseState,
|
||||
ev.data.mouse_motion.x,
|
||||
ev.data.mouse_motion.y,
|
||||
0);
|
||||
break;
|
||||
|
||||
case EPHYR_EV_MOUSE_PRESS:
|
||||
if (!ephyrMouse ||
|
||||
!((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled)
|
||||
continue;
|
||||
ephyrUpdateModifierState(ev.key_state);
|
||||
mouseState |= ev.data.mouse_down.button_num;
|
||||
KdEnqueueMouseEvent(kdMouseInfo, mouseState|KD_MOUSE_DELTA, 0, 0);
|
||||
KdEnqueuePointerEvent(ephyrMouse, mouseState|KD_MOUSE_DELTA, 0, 0, 0);
|
||||
break;
|
||||
|
||||
case EPHYR_EV_MOUSE_RELEASE:
|
||||
if (!ephyrMouse ||
|
||||
!((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled)
|
||||
continue;
|
||||
ephyrUpdateModifierState(ev.key_state);
|
||||
mouseState &= ~ev.data.mouse_up.button_num;
|
||||
KdEnqueueMouseEvent(kdMouseInfo, mouseState|KD_MOUSE_DELTA, 0, 0);
|
||||
KdEnqueuePointerEvent(ephyrMouse, mouseState|KD_MOUSE_DELTA, 0, 0, 0);
|
||||
break;
|
||||
|
||||
case EPHYR_EV_KEY_PRESS:
|
||||
if (!ephyrKbd ||
|
||||
!((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
|
||||
continue;
|
||||
ephyrUpdateModifierState(ev.key_state);
|
||||
KdEnqueueKeyboardEvent (ev.data.key_down.scancode, FALSE);
|
||||
KdEnqueueKeyboardEvent (ephyrKbd, ev.data.key_down.scancode, FALSE);
|
||||
break;
|
||||
|
||||
case EPHYR_EV_KEY_RELEASE:
|
||||
if (!ephyrKbd ||
|
||||
!((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
|
||||
continue;
|
||||
ephyrUpdateModifierState(ev.key_state);
|
||||
KdEnqueueKeyboardEvent (ev.data.key_up.scancode, TRUE);
|
||||
KdEnqueueKeyboardEvent (ephyrKbd, ev.data.key_up.scancode, TRUE);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
@ -833,59 +857,112 @@ ephyrPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
|
|||
|
||||
/* Mouse calls */
|
||||
|
||||
static Bool
|
||||
MouseInit (void)
|
||||
static Status
|
||||
MouseInit (KdPointerInfo *pi)
|
||||
{
|
||||
return TRUE;
|
||||
pi->driverPrivate = (EphyrPointerPrivate *)
|
||||
xcalloc(sizeof(EphyrPointerPrivate), 1);
|
||||
((EphyrPointerPrivate *)pi->driverPrivate)->enabled = FALSE;
|
||||
pi->nAxes = 3;
|
||||
pi->nButtons = 32;
|
||||
pi->name = KdSaveString("Xephyr virtual mouse");
|
||||
ephyrMouse = pi;
|
||||
return Success;
|
||||
}
|
||||
|
||||
static Status
|
||||
MouseEnable (KdPointerInfo *pi)
|
||||
{
|
||||
((EphyrPointerPrivate *)pi->driverPrivate)->enabled = TRUE;
|
||||
return Success;
|
||||
}
|
||||
|
||||
static void
|
||||
MouseFini (void)
|
||||
MouseDisable (KdPointerInfo *pi)
|
||||
{
|
||||
;
|
||||
((EphyrPointerPrivate *)pi->driverPrivate)->enabled = FALSE;
|
||||
return;
|
||||
}
|
||||
|
||||
KdMouseFuncs EphyrMouseFuncs = {
|
||||
static void
|
||||
MouseFini (KdPointerInfo *pi)
|
||||
{
|
||||
ephyrMouse = NULL;
|
||||
return;
|
||||
}
|
||||
|
||||
KdPointerDriver EphyrMouseDriver = {
|
||||
"ephyr",
|
||||
MouseInit,
|
||||
MouseEnable,
|
||||
MouseDisable,
|
||||
MouseFini,
|
||||
NULL,
|
||||
};
|
||||
|
||||
/* Keyboard */
|
||||
|
||||
static void
|
||||
EphyrKeyboardLoad (void)
|
||||
static Status
|
||||
EphyrKeyboardInit (KdKeyboardInfo *ki)
|
||||
{
|
||||
EPHYR_DBG("mark");
|
||||
|
||||
ki->driverPrivate = (EphyrKbdPrivate *)
|
||||
xcalloc(sizeof(EphyrKbdPrivate), 1);
|
||||
hostx_load_keymap();
|
||||
if (!ephyrKeySyms.map) {
|
||||
ErrorF("Couldn't load keymap from host\n");
|
||||
return BadAlloc;
|
||||
}
|
||||
ki->keySyms.minKeyCode = ephyrKeySyms.minKeyCode;
|
||||
ki->keySyms.maxKeyCode = ephyrKeySyms.maxKeyCode;
|
||||
ki->minScanCode = ki->keySyms.minKeyCode;
|
||||
ki->maxScanCode = ki->keySyms.maxKeyCode;
|
||||
ki->keySyms.mapWidth = ephyrKeySyms.mapWidth;
|
||||
ki->keySyms.map = ephyrKeySyms.map;
|
||||
ki->name = KdSaveString("Xephyr virtual keyboard");
|
||||
ephyrKbd = ki;
|
||||
return Success;
|
||||
}
|
||||
|
||||
static int
|
||||
EphyrKeyboardInit (void)
|
||||
static Status
|
||||
EphyrKeyboardEnable (KdKeyboardInfo *ki)
|
||||
{
|
||||
return 0;
|
||||
((EphyrKbdPrivate *)ki->driverPrivate)->enabled = TRUE;
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
static void
|
||||
EphyrKeyboardFini (void)
|
||||
EphyrKeyboardDisable (KdKeyboardInfo *ki)
|
||||
{
|
||||
((EphyrKbdPrivate *)ki->driverPrivate)->enabled = FALSE;
|
||||
}
|
||||
|
||||
static void
|
||||
EphyrKeyboardFini (KdKeyboardInfo *ki)
|
||||
{
|
||||
/* not xfree: we call malloc from hostx.c. */
|
||||
free(ki->keySyms.map);
|
||||
ephyrKbd = NULL;
|
||||
return;
|
||||
}
|
||||
|
||||
static void
|
||||
EphyrKeyboardLeds (KdKeyboardInfo *ki, int leds)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
EphyrKeyboardLeds (int leds)
|
||||
EphyrKeyboardBell (KdKeyboardInfo *ki, int volume, int frequency, int duration)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
EphyrKeyboardBell (int volume, int frequency, int duration)
|
||||
{
|
||||
}
|
||||
|
||||
KdKeyboardFuncs EphyrKeyboardFuncs = {
|
||||
EphyrKeyboardLoad,
|
||||
KdKeyboardDriver EphyrKeyboardDriver = {
|
||||
"ephyr",
|
||||
EphyrKeyboardInit,
|
||||
EphyrKeyboardEnable,
|
||||
EphyrKeyboardLeds,
|
||||
EphyrKeyboardBell,
|
||||
EphyrKeyboardDisable,
|
||||
EphyrKeyboardFini,
|
||||
0,
|
||||
NULL,
|
||||
};
|
||||
|
|
|
@ -31,7 +31,6 @@
|
|||
|
||||
#include "os.h" /* for OsSignal() */
|
||||
#include "kdrive.h"
|
||||
#include "kkeymap.h"
|
||||
#include "hostx.h"
|
||||
#include "exa.h"
|
||||
|
||||
|
@ -68,7 +67,9 @@ typedef struct _ephyrScrPriv {
|
|||
EphyrFakexaPriv *fakexa;
|
||||
} EphyrScrPriv;
|
||||
|
||||
extern KdCardFuncs ephyrFuncs;
|
||||
extern KdCardFuncs ephyrFuncs;
|
||||
extern KdKeyboardInfo *ephyrKbd;
|
||||
extern KdPointerInfo *ephyrMouse;
|
||||
|
||||
Bool
|
||||
ephyrInitialize (KdCardInfo *card, EphyrPriv *priv);
|
||||
|
@ -167,9 +168,9 @@ ephyrShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf);
|
|||
void
|
||||
ephyrUpdateModifierState(unsigned int state);
|
||||
|
||||
extern KdMouseFuncs EphyrMouseFuncs;
|
||||
extern KdPointerDriver EphyrMouseDriver;
|
||||
|
||||
extern KdKeyboardFuncs EphyrKeyboardFuncs;
|
||||
extern KdKeyboardDriver EphyrKeyboardDriver;
|
||||
|
||||
extern KdOsFuncs EphyrOsFuncs;
|
||||
|
||||
|
|
|
@ -51,7 +51,24 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
|
|||
void
|
||||
InitInput (int argc, char **argv)
|
||||
{
|
||||
KdInitInput (&EphyrMouseFuncs, &EphyrKeyboardFuncs);
|
||||
KdKeyboardInfo *ki;
|
||||
KdPointerInfo *pi;
|
||||
|
||||
ki = KdNewKeyboard();
|
||||
if (!ki)
|
||||
FatalError("Couldn't create Xephyr keyboard\n");
|
||||
ki->driver = &EphyrKeyboardDriver;
|
||||
KdAddKeyboardDriver(&EphyrKeyboardDriver);
|
||||
KdAddKeyboard(ki);
|
||||
|
||||
pi = KdNewPointer();
|
||||
if (!pi)
|
||||
FatalError("Couldn't create Xephyr pointer\n");
|
||||
pi->driver = &EphyrMouseDriver;
|
||||
KdAddPointerDriver(&EphyrMouseDriver);
|
||||
KdAddPointer(pi);
|
||||
|
||||
KdInitInput();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
@ -77,14 +77,8 @@ static EphyrHostXVars HostX = { "?", 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|||
|
||||
static int HostXWantDamageDebug = 0;
|
||||
|
||||
extern KeySym EphyrKeymap[];
|
||||
extern EphyrKeySyms ephyrKeySyms;
|
||||
|
||||
extern KeySym kdKeymap[];
|
||||
extern int kdMinScanCode;
|
||||
extern int kdMaxScanCode;
|
||||
extern int kdMinKeyCode;
|
||||
extern int kdMaxKeyCode;
|
||||
extern int kdKeymapWidth;
|
||||
extern int monitorResolution;
|
||||
|
||||
static void
|
||||
|
@ -403,9 +397,9 @@ hostx_get_bpp(void)
|
|||
}
|
||||
|
||||
void
|
||||
hostx_get_visual_masks (unsigned long *rmsk,
|
||||
unsigned long *gmsk,
|
||||
unsigned long *bmsk)
|
||||
hostx_get_visual_masks (CARD32 *rmsk,
|
||||
CARD32 *gmsk,
|
||||
CARD32 *bmsk)
|
||||
{
|
||||
if (host_depth_matches_server())
|
||||
{
|
||||
|
@ -683,19 +677,21 @@ hostx_load_keymap(void)
|
|||
*/
|
||||
width = (host_width > 4) ? 4 : host_width;
|
||||
|
||||
ephyrKeySyms.map = (KeySym *)calloc(sizeof(KeySym),
|
||||
(max_keycode - min_keycode + 1) *
|
||||
width);
|
||||
if (!ephyrKeySyms.map)
|
||||
return;
|
||||
|
||||
for (i=0; i<(max_keycode - min_keycode+1); i++)
|
||||
for (j=0; j<width; j++)
|
||||
kdKeymap[ (i*width)+j ] = keymap[ (i*host_width) + j ];
|
||||
ephyrKeySyms.map[(i*width)+j] = keymap[(i*host_width) + j];
|
||||
|
||||
EPHYR_DBG("keymap width, host:%d kdrive:%d", host_width, width);
|
||||
|
||||
/* all kdrive vars - see kkeymap.c */
|
||||
|
||||
kdMinScanCode = min_keycode;
|
||||
kdMaxScanCode = max_keycode;
|
||||
kdMinKeyCode = min_keycode;
|
||||
kdMaxKeyCode = max_keycode;
|
||||
kdKeymapWidth = width;
|
||||
ephyrKeySyms.minKeyCode = min_keycode;
|
||||
ephyrKeySyms.maxKeyCode = max_keycode;
|
||||
ephyrKeySyms.mapWidth = width;
|
||||
|
||||
XFree(keymap);
|
||||
}
|
||||
|
|
|
@ -26,6 +26,9 @@
|
|||
#ifndef _XLIBS_STUFF_H_
|
||||
#define _XLIBS_STUFF_H_
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
|
||||
#define EPHYR_WANT_DEBUG 0
|
||||
|
||||
#if (EPHYR_WANT_DEBUG)
|
||||
|
@ -48,6 +51,14 @@ typedef enum EphyrHostXEventType
|
|||
}
|
||||
EphyrHostXEventType;
|
||||
|
||||
/* I can't believe it's not a KeySymsRec. */
|
||||
typedef struct {
|
||||
int minKeyCode;
|
||||
int maxKeyCode;
|
||||
int mapWidth;
|
||||
KeySym *map;
|
||||
} EphyrKeySyms;
|
||||
|
||||
struct EphyrHostXEvent
|
||||
{
|
||||
EphyrHostXEventType type;
|
||||
|
@ -126,9 +137,9 @@ int
|
|||
hostx_get_bpp(void);
|
||||
|
||||
void
|
||||
hostx_get_visual_masks (unsigned long *rmsk,
|
||||
unsigned long *gmsk,
|
||||
unsigned long *bmsk);
|
||||
hostx_get_visual_masks (CARD32 *rmsk,
|
||||
CARD32 *gmsk,
|
||||
CARD32 *bmsk);
|
||||
void
|
||||
hostx_set_cmap_entry(unsigned char idx,
|
||||
unsigned char r,
|
||||
|
|
|
@ -34,34 +34,8 @@ EphyrInit (void)
|
|||
return hostx_init();
|
||||
}
|
||||
|
||||
static void
|
||||
EphyrEnable (void)
|
||||
{
|
||||
EPHYR_DBG("mark");
|
||||
}
|
||||
|
||||
static Bool
|
||||
EphyrSpecialKey (KeySym sym)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static void
|
||||
EphyrDisable (void)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
EphyrFini (void)
|
||||
{
|
||||
}
|
||||
|
||||
KdOsFuncs EphyrOsFuncs = {
|
||||
EphyrInit,
|
||||
EphyrEnable,
|
||||
EphyrSpecialKey,
|
||||
EphyrDisable,
|
||||
EphyrFini,
|
||||
ephyrPoll
|
||||
.Init = EphyrInit,
|
||||
.pollEvents = ephyrPoll,
|
||||
};
|
||||
|
||||
|
|
|
@ -24,5 +24,3 @@ Xepson_LDADD = \
|
|||
$(EPSON_LIBS) \
|
||||
@KDRIVE_LIBS@ \
|
||||
@XSERVER_LIBS@
|
||||
|
||||
Xepson_DEPENDENCIES = libepson.a
|
||||
|
|
|
@ -53,10 +53,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
|
|||
void
|
||||
InitInput (int argc, char **argv)
|
||||
{
|
||||
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
|
||||
#ifdef TOUCHSCREEN
|
||||
KdAddMouseDriver (&TsFuncs);
|
||||
#endif
|
||||
KdOsAddInputDrivers ();
|
||||
KdInitInput ();
|
||||
}
|
||||
|
||||
int
|
||||
|
|
|
@ -6,10 +6,6 @@ noinst_LIBRARIES = libfake.a
|
|||
|
||||
bin_PROGRAMS = Xfake
|
||||
|
||||
if TSLIB
|
||||
TSLIB_FLAG = -lts
|
||||
endif
|
||||
|
||||
libfake_a_SOURCES = \
|
||||
fake.c \
|
||||
kbd.c \
|
||||
|
@ -23,9 +19,4 @@ Xfake_SOURCES = \
|
|||
Xfake_LDADD = \
|
||||
libfake.a \
|
||||
@KDRIVE_LIBS@ \
|
||||
@KDRIVE_LIBS@ \
|
||||
$(TSLIB_FLAG) \
|
||||
@XSERVER_LIBS@
|
||||
|
||||
Xfake_DEPENDENCIES = \
|
||||
libfake.a
|
||||
|
|
|
@ -158,7 +158,7 @@ Bool
|
|||
fakeMapFramebuffer (KdScreenInfo *screen)
|
||||
{
|
||||
FakeScrPriv *scrpriv = screen->driver;
|
||||
KdMouseMatrix m;
|
||||
KdPointerMatrix m;
|
||||
FakePriv *priv = screen->card->driver;
|
||||
|
||||
if (scrpriv->randr != RR_Rotate_0)
|
||||
|
@ -166,9 +166,9 @@ fakeMapFramebuffer (KdScreenInfo *screen)
|
|||
else
|
||||
scrpriv->shadow = FALSE;
|
||||
|
||||
KdComputeMouseMatrix (&m, scrpriv->randr, screen->width, screen->height);
|
||||
KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
|
||||
|
||||
KdSetMouseMatrix (&m);
|
||||
KdSetPointerMatrix (&m);
|
||||
|
||||
priv->bytes_per_line = ((screen->width * screen->fb[0].bitsPerPixel + 31) >> 5) << 2;
|
||||
if (priv->base)
|
||||
|
|
|
@ -130,9 +130,9 @@ fakeRandRInit (ScreenPtr pScreen);
|
|||
|
||||
#endif
|
||||
|
||||
extern KdMouseFuncs FakeMouseFuncs;
|
||||
extern KdPointerDriver FakePointerDriver;
|
||||
|
||||
extern KdKeyboardFuncs FakeKeyboardFuncs;
|
||||
extern KdKeyboardDriver FakeKeyboardDriver;
|
||||
|
||||
extern KdOsFuncs FakeOsFuncs;
|
||||
|
||||
|
|
|
@ -44,7 +44,22 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
|
|||
void
|
||||
InitInput (int argc, char **argv)
|
||||
{
|
||||
KdInitInput (&FakeMouseFuncs, &FakeKeyboardFuncs);
|
||||
KdPointerInfo *pi;
|
||||
KdKeyboardInfo *ki;
|
||||
|
||||
pi = KdNewPointer ();
|
||||
if (!pi)
|
||||
return;
|
||||
pi->driver = &FakePointerDriver;
|
||||
KdAddPointer(pi);
|
||||
|
||||
ki = KdNewKeyboard ();
|
||||
if (!ki)
|
||||
return;
|
||||
ki->driver = &FakeKeyboardDriver;
|
||||
KdAddKeyboard(ki);
|
||||
|
||||
KdInitInput ();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
@ -27,7 +27,6 @@
|
|||
#include <kdrive-config.h>
|
||||
#endif
|
||||
#include "fake.h"
|
||||
#include "kkeymap.h"
|
||||
#include <X11/keysym.h>
|
||||
|
||||
#define FAKE_WIDTH 2
|
||||
|
@ -155,41 +154,58 @@ KeySym FakeKeymap[] = {
|
|||
/* 116 123 */ NoSymbol, NoSymbol, /* tiny button */
|
||||
};
|
||||
|
||||
static void
|
||||
FakeKeyboardLoad (void)
|
||||
static Status
|
||||
FakeKeyboardInit (KdKeyboardInfo *ki)
|
||||
{
|
||||
kdMinScanCode = 1;
|
||||
kdKeymapWidth = FAKE_WIDTH;
|
||||
kdMaxScanCode = (sizeof (FakeKeymap) / sizeof (FakeKeymap[0])) / FAKE_WIDTH;
|
||||
memcpy (kdKeymap, FakeKeymap, sizeof (FakeKeymap));
|
||||
ki->keySyms.minKeyCode = 1;
|
||||
ki->keySyms.maxKeyCode = (sizeof (FakeKeymap) / sizeof (FakeKeymap[0])) / FAKE_WIDTH;
|
||||
ki->keySyms.mapWidth = FAKE_WIDTH;
|
||||
if (ki->keySyms.map)
|
||||
xfree(ki->keySyms.map);
|
||||
ki->keySyms.map = (KeySym *)xalloc(sizeof(FakeKeymap));
|
||||
if (!ki->keySyms.map)
|
||||
return BadAlloc;
|
||||
memcpy (ki->keySyms.map, FakeKeymap, sizeof (FakeKeymap));
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
static int
|
||||
FakeKeyboardInit (void)
|
||||
static Status
|
||||
FakeKeyboardEnable (KdKeyboardInfo *ki)
|
||||
{
|
||||
return 0;
|
||||
return Success;
|
||||
}
|
||||
|
||||
static void
|
||||
FakeKeyboardFini (void)
|
||||
FakeKeyboardDisable (KdKeyboardInfo *ki)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
static void
|
||||
FakeKeyboardFini (KdKeyboardInfo *ki)
|
||||
{
|
||||
xfree(ki->keySyms.map);
|
||||
ki->keySyms.map = NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
FakeKeyboardLeds (KdKeyboardInfo *ki, int leds)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
FakeKeyboardLeds (int leds)
|
||||
FakeKeyboardBell (KdKeyboardInfo *ki, int volume, int frequency, int duration)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
FakeKeyboardBell (int volume, int frequency, int duration)
|
||||
{
|
||||
}
|
||||
|
||||
KdKeyboardFuncs FakeKeyboardFuncs = {
|
||||
FakeKeyboardLoad,
|
||||
KdKeyboardDriver FakeKeyboardDriver = {
|
||||
"fake",
|
||||
FakeKeyboardInit,
|
||||
FakeKeyboardEnable,
|
||||
FakeKeyboardLeds,
|
||||
FakeKeyboardBell,
|
||||
FakeKeyboardDisable,
|
||||
FakeKeyboardFini,
|
||||
0,
|
||||
NULL,
|
||||
};
|
||||
|
|
|
@ -35,19 +35,35 @@
|
|||
#include "scrnintstr.h"
|
||||
#include "kdrive.h"
|
||||
|
||||
static Bool
|
||||
MouseInit (void)
|
||||
static Status
|
||||
MouseInit (KdPointerInfo *pi)
|
||||
{
|
||||
return TRUE;
|
||||
return Success;
|
||||
}
|
||||
|
||||
static Status
|
||||
MouseEnable (KdPointerInfo *pi)
|
||||
{
|
||||
return Success;
|
||||
}
|
||||
|
||||
static void
|
||||
MouseFini (void)
|
||||
MouseDisable (KdPointerInfo *pi)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
static void
|
||||
MouseFini (KdPointerInfo *pi)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
KdMouseFuncs FakeMouseFuncs = {
|
||||
KdPointerDriver FakePointerDriver = {
|
||||
"fake",
|
||||
MouseInit,
|
||||
MouseEnable,
|
||||
MouseDisable,
|
||||
MouseFini,
|
||||
};
|
||||
|
|
|
@ -4,19 +4,18 @@ INCLUDES = \
|
|||
|
||||
noinst_LIBRARIES = libfbdev.a
|
||||
|
||||
bin_PROGRAMS = Xfbdev
|
||||
|
||||
libfbdev_a_SOURCES = \
|
||||
fbdev.c \
|
||||
fbdev.h
|
||||
|
||||
if KDRIVEFBDEV
|
||||
bin_PROGRAMS = Xfbdev
|
||||
|
||||
Xfbdev_SOURCES = \
|
||||
fbinit.c
|
||||
|
||||
Xfbdev_LDADD = \
|
||||
libfbdev.a \
|
||||
@KDRIVE_LIBS@ \
|
||||
@XSERVER_LIBS@
|
||||
|
||||
Xfbdev_DEPENDENCIES = \
|
||||
libfbdev.a
|
||||
@XSERVER_LIBS@
|
||||
endif
|
||||
|
|
|
@ -331,7 +331,7 @@ Bool
|
|||
fbdevMapFramebuffer (KdScreenInfo *screen)
|
||||
{
|
||||
FbdevScrPriv *scrpriv = screen->driver;
|
||||
KdMouseMatrix m;
|
||||
KdPointerMatrix m;
|
||||
FbdevPriv *priv = screen->card->driver;
|
||||
|
||||
if (scrpriv->randr != RR_Rotate_0)
|
||||
|
@ -339,9 +339,9 @@ fbdevMapFramebuffer (KdScreenInfo *screen)
|
|||
else
|
||||
scrpriv->shadow = FALSE;
|
||||
|
||||
KdComputeMouseMatrix (&m, scrpriv->randr, screen->width, screen->height);
|
||||
KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
|
||||
|
||||
KdSetMouseMatrix (&m);
|
||||
KdSetPointerMatrix (&m);
|
||||
|
||||
screen->width = priv->var.xres;
|
||||
screen->height = priv->var.yres;
|
||||
|
|
|
@ -45,10 +45,18 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
|
|||
void
|
||||
InitInput (int argc, char **argv)
|
||||
{
|
||||
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
|
||||
#ifdef TOUCHSCREEN
|
||||
KdAddMouseDriver (&TsFuncs);
|
||||
KdKeyboardInfo *ki;
|
||||
|
||||
KdAddKeyboardDriver (&LinuxKeyboardDriver);
|
||||
KdAddPointerDriver (&LinuxMouseDriver);
|
||||
#ifdef TSLIB
|
||||
KdAddPointerDriver (&TsDriver);
|
||||
#endif
|
||||
|
||||
ki = KdParseKeyboard ("keybd");
|
||||
KdAddKeyboard(ki);
|
||||
|
||||
KdInitInput ();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
@ -27,5 +27,3 @@ Xi810_LDADD = \
|
|||
$(I810_LIBS) \
|
||||
@KDRIVE_LIBS@ \
|
||||
@XSERVER_LIBS@
|
||||
|
||||
Xi810_DEPENDENCIES = libi810.a
|
||||
|
|
|
@ -73,7 +73,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
|
|||
void
|
||||
InitInput (int argc, char **argv)
|
||||
{
|
||||
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
|
||||
KdOsAddInputDrivers ();
|
||||
KdInitInput ();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
@ -56,7 +56,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
|
|||
void
|
||||
InitInput (int argc, char **argv)
|
||||
{
|
||||
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
|
||||
KdOsAddInputDrivers ();
|
||||
KdInitInput ();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
@ -27,7 +27,6 @@
|
|||
#include <kdrive-config.h>
|
||||
#endif
|
||||
#include "itsy.h"
|
||||
#include "kkeymap.h"
|
||||
#include <X11/keysym.h>
|
||||
#include <linux/itsy_buttons.h>
|
||||
|
||||
|
@ -167,28 +166,44 @@ ItsyKeyboardLoad (void)
|
|||
{
|
||||
KeySym *k;
|
||||
|
||||
itsyButtonState = 0;
|
||||
kdMinScanCode = 1;
|
||||
kdKeymapWidth = ITSY_WIDTH;
|
||||
kdMaxScanCode = (sizeof (ItsyKeymap) / sizeof (ItsyKeymap[0])) / ITSY_WIDTH;
|
||||
memcpy (kdKeymap, ItsyKeymap, sizeof (ItsyKeymap));
|
||||
}
|
||||
|
||||
int
|
||||
ItsyKeyboardInit (void)
|
||||
static Status
|
||||
ItsyKeyboardInit (KdKeyboardInfo *ki)
|
||||
{
|
||||
int butPort;
|
||||
if (!ki)
|
||||
return BadImplementation;
|
||||
|
||||
butPort = open ("/dev/buttons", 0);
|
||||
fprintf (stderr, "butPort %d\n", butPort);
|
||||
return butPort;
|
||||
ki->driverPrivate = open ("/dev/buttons", 0);
|
||||
|
||||
itsyButtonState = 0;
|
||||
ki->keySyms.minKeyCode = 1;
|
||||
ki->keySyms.maxKeyCode = (sizeof (ItsyKeymap) / sizeof (ItsyKeymap[0])) / ITSY_WIDTH;
|
||||
ki->minScanCode = ki->keySyms.minKeyCode;
|
||||
ki->maxScanCode = ki->keySyms.maxKeyCode;
|
||||
ki->keySyms.mapWidth = ITSY_WIDTH;
|
||||
|
||||
if (ki->keySyms.map)
|
||||
xfree(ki->keySyms.map);
|
||||
ki->keySyms.map = xalloc(sizeof(ItsyKeymap));
|
||||
if (!ki->keySyms.map)
|
||||
return BadAlloc;
|
||||
memcpy (kdKeymap, ItsyKeymap, sizeof (ItsyKeymap));
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
void
|
||||
ItsyKeyboardFini (int fd)
|
||||
static void
|
||||
ItsyKeyboardDisable (KdKeybdInfo *ki)
|
||||
{
|
||||
if (fd >= 0)
|
||||
close (fd);
|
||||
close ((int)ki->driverPrivate);
|
||||
}
|
||||
|
||||
static void
|
||||
ItsyKeyboardFini (KdKeybdInfo *ki)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void
|
||||
|
@ -227,11 +242,13 @@ ItsyKeyboardBell (int volume, int frequency, int duration)
|
|||
}
|
||||
|
||||
KdKeyboardFuncs itsyKeyboardFuncs = {
|
||||
ItsyKeyboardLoad,
|
||||
"itsy",
|
||||
ItsyKeyboardInit,
|
||||
ItsyKeyboardEnable,
|
||||
ItsyKeyboardRead,
|
||||
ItsyKeyboardLeds,
|
||||
ItsyKeyboardBell,
|
||||
ItsyKeyboardDisable
|
||||
ItsyKeyboardFini,
|
||||
0,
|
||||
NULL,
|
||||
};
|
||||
|
|
|
@ -63,7 +63,7 @@ itsyTsReadBytes (int fd, char *buf, int len, int min)
|
|||
}
|
||||
|
||||
void
|
||||
itsyTsRead (int tsPort)
|
||||
itsyTsRead (KdPointerInfo *pi, int tsPort)
|
||||
{
|
||||
ts_event event;
|
||||
long buf[3];
|
||||
|
@ -89,7 +89,7 @@ itsyTsRead (int tsPort)
|
|||
x = 0;
|
||||
y = 0;
|
||||
}
|
||||
KdEnqueueMouseEvent (flags, x, y);
|
||||
KdEnqueuePointerEvent (pi, flags, x, y, 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -204,7 +204,8 @@ itsyTsFini (int tsPort)
|
|||
close (tsPort);
|
||||
}
|
||||
|
||||
KdMouseFuncs itsyTsMouseFuncs = {
|
||||
KdPointerDriver itsyTsMouseDriver = {
|
||||
"itsyts",
|
||||
itsyTsInit,
|
||||
itsyTsRead,
|
||||
itsyTsFini
|
||||
|
|
|
@ -32,16 +32,3 @@ liblinux_a_SOURCES = \
|
|||
$(KDRIVE_HW_SOURCES) \
|
||||
$(TSLIB_C) \
|
||||
$(TS_C)
|
||||
|
||||
liblinux_a_DEPENDENCIES = \
|
||||
agp.c \
|
||||
bus.c \
|
||||
keyboard.c \
|
||||
linux.c \
|
||||
mouse.c \
|
||||
evdev.c \
|
||||
ms.c \
|
||||
ps2.c \
|
||||
$(TSLIB_C) \
|
||||
$(TS_C)
|
||||
|
||||
|
|
|
@ -55,7 +55,7 @@ BusRead (int adbPort, void *closure)
|
|||
flags |= KD_BUTTON_2;
|
||||
if ((buf[0] & 1) == 0)
|
||||
flags |= KD_BUTTON_3;
|
||||
KdEnqueueMouseEvent (kdMouseInfo, flags, dx, dy);
|
||||
KdEnqueuePointerEvent (closure, flags, dx, dy, 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -66,36 +66,71 @@ char *BusNames[] = {
|
|||
|
||||
#define NUM_BUS_NAMES (sizeof (BusNames) / sizeof (BusNames[0]))
|
||||
|
||||
int BusInputType;
|
||||
static int
|
||||
BusInit (KdPointerInfo *pi)
|
||||
{
|
||||
int i, fd = 0;
|
||||
|
||||
if (!pi->path || (strcmp(pi->path, "auto") == 0))
|
||||
{
|
||||
for (i = 0; i < NUM_BUS_NAMES; i++)
|
||||
{
|
||||
if ((fd = open (BusNames[i], 0)) > 0)
|
||||
{
|
||||
close(fd);
|
||||
if (pi->path)
|
||||
xfree(pi->path);
|
||||
pi->path = KdSaveString(BusNames[i]);
|
||||
return Success;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((fd = open(pi->path, 0)) > 0)
|
||||
{
|
||||
close(fd);
|
||||
return Success;
|
||||
}
|
||||
}
|
||||
|
||||
return !Success;
|
||||
}
|
||||
|
||||
static int
|
||||
BusInit (void)
|
||||
BusEnable (KdPointerInfo *pi)
|
||||
{
|
||||
int i;
|
||||
int busPort;
|
||||
int n = 0;
|
||||
int fd = open(pi->path, 0);
|
||||
|
||||
if (!BusInputType)
|
||||
BusInputType = KdAllocInputType ();
|
||||
|
||||
for (i = 0; i < NUM_BUS_NAMES; i++)
|
||||
if (fd > 0)
|
||||
{
|
||||
busPort = open (BusNames[i], 0);
|
||||
{
|
||||
KdRegisterFd (BusInputType, busPort, BusRead, 0);
|
||||
n++;
|
||||
}
|
||||
KdRegisterFd(fd, BusRead, pi);
|
||||
pi->driverPrivate = (void *)fd;
|
||||
return Success;
|
||||
}
|
||||
else
|
||||
{
|
||||
return !Success;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
static void
|
||||
BusFini (void)
|
||||
BusDisable (KdPointerInfo *pi)
|
||||
{
|
||||
KdUnregisterFds (BusInputType, TRUE);
|
||||
KdUnregisterFd(pi, (int)pi->driverPrivate, TRUE);
|
||||
}
|
||||
|
||||
KdMouseFuncs BusMouseFuncs = {
|
||||
static void
|
||||
BusFini (KdPointerInfo *pi)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
KdPointerDriver BusMouseDriver = {
|
||||
"bus",
|
||||
BusInit,
|
||||
BusFini
|
||||
BusEnable,
|
||||
BusDisable,
|
||||
BusFini,
|
||||
NULL
|
||||
};
|
||||
|
|
|
@ -43,98 +43,100 @@
|
|||
#define ISBITSET(x,y) ((x)[LONG(y)] & BIT(y))
|
||||
#define OFF(x) ((x)%BITS_PER_LONG)
|
||||
#define LONG(x) ((x)/BITS_PER_LONG)
|
||||
#define BIT(x) (1 << OFF(x))
|
||||
#define BIT(x) (1 << OFF(x))
|
||||
#define SETBIT(x,y) ((x)[LONG(y)] |= BIT(y))
|
||||
#define CLRBIT(x,y) ((x)[LONG(y)] &= ~BIT(y))
|
||||
#define ASSIGNBIT(x,y,z) ((x)[LONG(y)] = ((x)[LONG(y)] & ~BIT(y)) | (z << OFF(y)))
|
||||
|
||||
typedef struct _kevdevMouse {
|
||||
/* current device state */
|
||||
int rel[REL_MAX + 1];
|
||||
int abs[ABS_MAX + 1];
|
||||
int prevabs[ABS_MAX + 1];
|
||||
long key[NBITS(KEY_MAX + 1)];
|
||||
int rel[REL_MAX + 1];
|
||||
int abs[ABS_MAX + 1];
|
||||
int prevabs[ABS_MAX + 1];
|
||||
long key[NBITS(KEY_MAX + 1)];
|
||||
|
||||
/* supported device info */
|
||||
long relbits[NBITS(REL_MAX + 1)];
|
||||
long absbits[NBITS(ABS_MAX + 1)];
|
||||
long keybits[NBITS(KEY_MAX + 1)];
|
||||
long relbits[NBITS(REL_MAX + 1)];
|
||||
long absbits[NBITS(ABS_MAX + 1)];
|
||||
long keybits[NBITS(KEY_MAX + 1)];
|
||||
struct input_absinfo absinfo[ABS_MAX + 1];
|
||||
int max_rel;
|
||||
int max_abs;
|
||||
int max_rel;
|
||||
int max_abs;
|
||||
|
||||
int fd;
|
||||
} Kevdev;
|
||||
|
||||
static void
|
||||
EvdevMotion (KdMouseInfo *mi)
|
||||
EvdevMotion (KdPointerInfo *pi)
|
||||
{
|
||||
Kevdev *ke = mi->driver;
|
||||
int i;
|
||||
Kevdev *ke = pi->driverPrivate;
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= ke->max_rel; i++)
|
||||
if (ke->rel[i])
|
||||
{
|
||||
int a;
|
||||
ErrorF ("rel");
|
||||
for (a = 0; a <= ke->max_rel; a++)
|
||||
{
|
||||
if (ISBITSET (ke->relbits, a))
|
||||
ErrorF (" %d=%d", a, ke->rel[a]);
|
||||
ke->rel[a] = 0;
|
||||
}
|
||||
ErrorF ("\n");
|
||||
break;
|
||||
}
|
||||
if (ke->rel[i])
|
||||
{
|
||||
int a;
|
||||
ErrorF ("rel");
|
||||
for (a = 0; a <= ke->max_rel; a++)
|
||||
{
|
||||
if (ISBITSET (ke->relbits, a))
|
||||
ErrorF (" %d=%d", a, ke->rel[a]);
|
||||
ke->rel[a] = 0;
|
||||
}
|
||||
ErrorF ("\n");
|
||||
break;
|
||||
}
|
||||
for (i = 0; i < ke->max_abs; i++)
|
||||
if (ke->abs[i] != ke->prevabs[i])
|
||||
{
|
||||
int a;
|
||||
ErrorF ("abs");
|
||||
for (a = 0; a <= ke->max_abs; a++)
|
||||
{
|
||||
if (ISBITSET (ke->absbits, a))
|
||||
ErrorF (" %d=%d", a, ke->abs[a]);
|
||||
ke->prevabs[a] = ke->abs[a];
|
||||
}
|
||||
ErrorF ("\n");
|
||||
break;
|
||||
}
|
||||
if (ke->abs[i] != ke->prevabs[i])
|
||||
{
|
||||
int a;
|
||||
ErrorF ("abs");
|
||||
for (a = 0; a <= ke->max_abs; a++)
|
||||
{
|
||||
if (ISBITSET (ke->absbits, a))
|
||||
ErrorF (" %d=%d", a, ke->abs[a]);
|
||||
ke->prevabs[a] = ke->abs[a];
|
||||
}
|
||||
ErrorF ("\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
EvdevRead (int evdevPort, void *closure)
|
||||
{
|
||||
KdMouseInfo *mi = closure;
|
||||
Kevdev *ke = mi->driver;
|
||||
int i;
|
||||
struct input_event events[NUM_EVENTS];
|
||||
int n;
|
||||
KdPointerInfo *pi = closure;
|
||||
Kevdev *ke = pi->driverPrivate;
|
||||
int i;
|
||||
struct input_event events[NUM_EVENTS];
|
||||
int n;
|
||||
|
||||
n = read (evdevPort, &events, NUM_EVENTS * sizeof (struct input_event));
|
||||
if (n <= 0)
|
||||
return;
|
||||
return;
|
||||
n /= sizeof (struct input_event);
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
switch (events[i].type) {
|
||||
case EV_SYN:
|
||||
break;
|
||||
case EV_KEY:
|
||||
EvdevMotion (mi);
|
||||
ASSIGNBIT(ke->key,events[i].code, events[i].value);
|
||||
if (events[i].code < 0x100)
|
||||
ErrorF ("key %d %d\n", events[i].code, events[i].value);
|
||||
else
|
||||
ErrorF ("key 0x%x %d\n", events[i].code, events[i].value);
|
||||
break;
|
||||
case EV_REL:
|
||||
ke->rel[events[i].code] += events[i].value;
|
||||
break;
|
||||
case EV_ABS:
|
||||
ke->abs[events[i].code] = events[i].value;
|
||||
break;
|
||||
}
|
||||
switch (events[i].type) {
|
||||
case EV_SYN:
|
||||
break;
|
||||
case EV_KEY:
|
||||
EvdevMotion (pi);
|
||||
ASSIGNBIT(ke->key,events[i].code, events[i].value);
|
||||
if (events[i].code < 0x100)
|
||||
ErrorF ("key %d %d\n", events[i].code, events[i].value);
|
||||
else
|
||||
ErrorF ("key 0x%x %d\n", events[i].code, events[i].value);
|
||||
break;
|
||||
case EV_REL:
|
||||
ke->rel[events[i].code] += events[i].value;
|
||||
break;
|
||||
case EV_ABS:
|
||||
ke->abs[events[i].code] = events[i].value;
|
||||
break;
|
||||
}
|
||||
}
|
||||
EvdevMotion (mi);
|
||||
EvdevMotion (pi);
|
||||
}
|
||||
|
||||
int EvdevInputType;
|
||||
|
@ -148,143 +150,153 @@ char *kdefaultEvdev[] = {
|
|||
|
||||
#define NUM_DEFAULT_EVDEV (sizeof (kdefaultEvdev) / sizeof (kdefaultEvdev[0]))
|
||||
|
||||
static Bool
|
||||
EvdevInit (void)
|
||||
static Status
|
||||
EvdevInit (KdPointerInfo *pi)
|
||||
{
|
||||
int i;
|
||||
int fd;
|
||||
KdMouseInfo *mi, *next;
|
||||
int n = 0;
|
||||
char *prot;
|
||||
int i;
|
||||
int fd;
|
||||
int n = 0;
|
||||
char *prot;
|
||||
|
||||
if (!EvdevInputType)
|
||||
EvdevInputType = KdAllocInputType ();
|
||||
|
||||
for (mi = kdMouseInfo; mi; mi = next)
|
||||
{
|
||||
next = mi->next;
|
||||
prot = mi->prot;
|
||||
if (mi->inputType)
|
||||
continue;
|
||||
if (!mi->name)
|
||||
{
|
||||
for (i = 0; i < NUM_DEFAULT_EVDEV; i++)
|
||||
{
|
||||
fd = open (kdefaultEvdev[i], 2);
|
||||
if (fd >= 0)
|
||||
{
|
||||
mi->name = KdSaveString (kdefaultEvdev[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
fd = open (mi->name, 2);
|
||||
|
||||
if (fd >= 0)
|
||||
{
|
||||
unsigned long ev[NBITS(EV_MAX)];
|
||||
Kevdev *ke;
|
||||
|
||||
if (ioctl (fd, EVIOCGBIT(0 /*EV*/, sizeof (ev)), ev) < 0)
|
||||
{
|
||||
perror ("EVIOCGBIT 0");
|
||||
close (fd);
|
||||
continue;
|
||||
}
|
||||
ke = xalloc (sizeof (Kevdev));
|
||||
if (!ke)
|
||||
{
|
||||
close (fd);
|
||||
continue;
|
||||
}
|
||||
memset (ke, '\0', sizeof (Kevdev));
|
||||
if (ISBITSET (ev, EV_KEY))
|
||||
{
|
||||
if (ioctl (fd, EVIOCGBIT (EV_KEY, sizeof (ke->keybits)),
|
||||
ke->keybits) < 0)
|
||||
{
|
||||
perror ("EVIOCGBIT EV_KEY");
|
||||
xfree (ke);
|
||||
close (fd);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (ISBITSET (ev, EV_REL))
|
||||
{
|
||||
if (ioctl (fd, EVIOCGBIT (EV_REL, sizeof (ke->relbits)),
|
||||
ke->relbits) < 0)
|
||||
{
|
||||
perror ("EVIOCGBIT EV_REL");
|
||||
xfree (ke);
|
||||
close (fd);
|
||||
continue;
|
||||
}
|
||||
for (ke->max_rel = REL_MAX; ke->max_rel >= 0; ke->max_rel--)
|
||||
if (ISBITSET(ke->relbits, ke->max_rel))
|
||||
break;
|
||||
}
|
||||
if (ISBITSET (ev, EV_ABS))
|
||||
{
|
||||
int i;
|
||||
|
||||
if (ioctl (fd, EVIOCGBIT (EV_ABS, sizeof (ke->absbits)),
|
||||
ke->absbits) < 0)
|
||||
{
|
||||
perror ("EVIOCGBIT EV_ABS");
|
||||
xfree (ke);
|
||||
close (fd);
|
||||
continue;
|
||||
}
|
||||
for (ke->max_abs = ABS_MAX; ke->max_abs >= 0; ke->max_abs--)
|
||||
if (ISBITSET(ke->absbits, ke->max_abs))
|
||||
break;
|
||||
for (i = 0; i <= ke->max_abs; i++)
|
||||
{
|
||||
if (ISBITSET (ke->absbits, i))
|
||||
if (ioctl (fd, EVIOCGABS(i), &ke->absinfo[i]) < 0)
|
||||
{
|
||||
perror ("EVIOCGABS");
|
||||
break;
|
||||
}
|
||||
ke->prevabs[i] = ABS_UNSET;
|
||||
}
|
||||
if (i <= ke->max_abs)
|
||||
{
|
||||
xfree (ke);
|
||||
close (fd);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
mi->driver = ke;
|
||||
mi->inputType = EvdevInputType;
|
||||
if (KdRegisterFd (EvdevInputType, fd, EvdevRead, (void *) mi))
|
||||
n++;
|
||||
}
|
||||
if (!pi->path) {
|
||||
for (i = 0; i < NUM_DEFAULT_EVDEV; i++) {
|
||||
fd = open (kdefaultEvdev[i], 2);
|
||||
if (fd >= 0) {
|
||||
pi->path = KdSaveString (kdefaultEvdev[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
else {
|
||||
fd = open (pi->path, 2);
|
||||
if (fd < 0) {
|
||||
ErrorF("Failed to open evdev device %s\n", pi->path);
|
||||
return BadMatch;
|
||||
}
|
||||
}
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
static Status
|
||||
EvdevEnable (KdPointerInfo *pi)
|
||||
{
|
||||
int fd;
|
||||
|
||||
if (!pi || !pi->path)
|
||||
return BadImplementation;
|
||||
|
||||
fd = open(pi->path, 2);
|
||||
if (fd < 0)
|
||||
return BadMatch;
|
||||
|
||||
unsigned long ev[NBITS(EV_MAX)];
|
||||
Kevdev *ke;
|
||||
|
||||
if (ioctl (fd, EVIOCGBIT(0 /*EV*/, sizeof (ev)), ev) < 0)
|
||||
{
|
||||
perror ("EVIOCGBIT 0");
|
||||
close (fd);
|
||||
return BadMatch;
|
||||
}
|
||||
ke = xalloc (sizeof (Kevdev));
|
||||
if (!ke)
|
||||
{
|
||||
close (fd);
|
||||
return BadAlloc;
|
||||
}
|
||||
memset (ke, '\0', sizeof (Kevdev));
|
||||
if (ISBITSET (ev, EV_KEY))
|
||||
{
|
||||
if (ioctl (fd, EVIOCGBIT (EV_KEY, sizeof (ke->keybits)),
|
||||
ke->keybits) < 0)
|
||||
{
|
||||
perror ("EVIOCGBIT EV_KEY");
|
||||
xfree (ke);
|
||||
close (fd);
|
||||
return BadMatch;
|
||||
}
|
||||
}
|
||||
if (ISBITSET (ev, EV_REL))
|
||||
{
|
||||
if (ioctl (fd, EVIOCGBIT (EV_REL, sizeof (ke->relbits)),
|
||||
ke->relbits) < 0)
|
||||
{
|
||||
perror ("EVIOCGBIT EV_REL");
|
||||
xfree (ke);
|
||||
close (fd);
|
||||
return BadMatch;
|
||||
}
|
||||
for (ke->max_rel = REL_MAX; ke->max_rel >= 0; ke->max_rel--)
|
||||
if (ISBITSET(ke->relbits, ke->max_rel))
|
||||
break;
|
||||
}
|
||||
if (ISBITSET (ev, EV_ABS))
|
||||
{
|
||||
int i;
|
||||
|
||||
if (ioctl (fd, EVIOCGBIT (EV_ABS, sizeof (ke->absbits)),
|
||||
ke->absbits) < 0)
|
||||
{
|
||||
perror ("EVIOCGBIT EV_ABS");
|
||||
xfree (ke);
|
||||
close (fd);
|
||||
return BadMatch;
|
||||
}
|
||||
for (ke->max_abs = ABS_MAX; ke->max_abs >= 0; ke->max_abs--)
|
||||
if (ISBITSET(ke->absbits, ke->max_abs))
|
||||
break;
|
||||
for (i = 0; i <= ke->max_abs; i++)
|
||||
{
|
||||
if (ISBITSET (ke->absbits, i))
|
||||
if (ioctl (fd, EVIOCGABS(i), &ke->absinfo[i]) < 0)
|
||||
{
|
||||
perror ("EVIOCGABS");
|
||||
break;
|
||||
}
|
||||
ke->prevabs[i] = ABS_UNSET;
|
||||
}
|
||||
if (i <= ke->max_abs)
|
||||
{
|
||||
xfree (ke);
|
||||
close (fd);
|
||||
return BadValue;
|
||||
}
|
||||
}
|
||||
if (!KdRegisterFd (fd, EvdevRead, pi)) {
|
||||
xfree (ke);
|
||||
close (fd);
|
||||
return BadAlloc;
|
||||
}
|
||||
pi->driverPrivate = ke;
|
||||
return Success;
|
||||
}
|
||||
|
||||
static void
|
||||
EvdevFini (void)
|
||||
EvdevDisable (KdPointerInfo *pi)
|
||||
{
|
||||
KdMouseInfo *mi;
|
||||
Kevdev *ke;
|
||||
|
||||
KdUnregisterFds (EvdevInputType, TRUE);
|
||||
for (mi = kdMouseInfo; mi; mi = mi->next)
|
||||
{
|
||||
if (mi->inputType == EvdevInputType)
|
||||
{
|
||||
xfree (mi->driver);
|
||||
mi->driver = 0;
|
||||
mi->inputType = 0;
|
||||
}
|
||||
}
|
||||
if (!pi || !pi->driverPrivate)
|
||||
return;
|
||||
|
||||
KdUnregisterFd (pi, ke->fd, TRUE);
|
||||
xfree (ke);
|
||||
pi->driverPrivate = 0;
|
||||
}
|
||||
|
||||
KdMouseFuncs LinuxEvdevMouseFuncs = {
|
||||
static void
|
||||
EvdevFini (KdPointerInfo *pi)
|
||||
{
|
||||
}
|
||||
|
||||
KdPointerDriver LinuxEvdevMouseDriver = {
|
||||
"evdev",
|
||||
EvdevInit,
|
||||
EvdevEnable,
|
||||
EvdevDisable,
|
||||
EvdevFini,
|
||||
NULL,
|
||||
};
|
||||
|
||||
#if 0
|
||||
|
|
|
@ -2,31 +2,40 @@
|
|||
* $RCSId: xc/programs/Xserver/hw/kdrive/linux/keyboard.c,v 1.10 2001/11/08 10:26:24 keithp Exp $
|
||||
*
|
||||
* Copyright © 1999 Keith Packard
|
||||
* XKB integration © 2006 Nokia Corporation, author: Tomas Frydrych <tf@o-hand.com>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of Keith Packard not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. Keith Packard makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
* LinuxKeyboardRead() XKB code based on xf86KbdLnx.c:
|
||||
* Copyright © 1990,91 by Thomas Roell, Dinkelscherben, Germany.
|
||||
* Copyright © 1994-2001 by The XFree86 Project, Inc.
|
||||
*
|
||||
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the name of the copyright holder(s)
|
||||
* and author(s) shall not be used in advertising or otherwise to promote
|
||||
* the sale, use or other dealings in this Software without prior written
|
||||
* authorization from the copyright holder(s) and author(s).
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <kdrive-config.h>
|
||||
#endif
|
||||
#include "kdrive.h"
|
||||
#include "kkeymap.h"
|
||||
#include <linux/keyboard.h>
|
||||
#include <linux/kd.h>
|
||||
#define XK_PUBLISHING
|
||||
|
@ -34,7 +43,7 @@
|
|||
#include <termios.h>
|
||||
#include <sys/ioctl.h>
|
||||
|
||||
extern int LinuxConsoleFd;
|
||||
extern int LinuxConsoleFd;
|
||||
|
||||
static const KeySym linux_to_x[256] = {
|
||||
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
|
||||
|
@ -103,7 +112,108 @@ static const KeySym linux_to_x[256] = {
|
|||
XK_udiaeresis, XK_yacute, XK_thorn, XK_ydiaeresis
|
||||
};
|
||||
|
||||
static unsigned char tbl[KD_MAX_WIDTH] =
|
||||
#ifdef XKB
|
||||
/*
|
||||
* Getting a keycode from scancode
|
||||
*
|
||||
* With XKB
|
||||
* --------
|
||||
*
|
||||
* We have to enqueue keyboard events using standard X keycodes which correspond
|
||||
* to AT scancode + 8; this means that we need to translate the Linux scancode
|
||||
* provided by the kernel to an AT scancode -- this translation is not linear
|
||||
* and requires that we use a LUT.
|
||||
*
|
||||
*
|
||||
* Without XKB
|
||||
* -----------
|
||||
*
|
||||
* We can use custom keycodes, which makes things simpler; we define our custom
|
||||
* keycodes as Linux scancodes + KD_KEY_OFFSET
|
||||
*/
|
||||
|
||||
/*
|
||||
This LUT translates AT scancodes into Linux ones -- the keymap we create
|
||||
for the core X keyboard protocol has to be AT-scancode based so that it
|
||||
corresponds to the Xkb keymap.
|
||||
*/
|
||||
static unsigned char at2lnx[] =
|
||||
{
|
||||
0x0, /* no valid scancode */
|
||||
0x01, /* KEY_Escape */ 0x02, /* KEY_1 */
|
||||
0x03, /* KEY_2 */ 0x04, /* KEY_3 */
|
||||
0x05, /* KEY_4 */ 0x06, /* KEY_5 */
|
||||
0x07, /* KEY_6 */ 0x08, /* KEY_7 */
|
||||
0x09, /* KEY_8 */ 0x0a, /* KEY_9 */
|
||||
0x0b, /* KEY_0 */ 0x0c, /* KEY_Minus */
|
||||
0x0d, /* KEY_Equal */ 0x0e, /* KEY_BackSpace */
|
||||
0x0f, /* KEY_Tab */ 0x10, /* KEY_Q */
|
||||
0x11, /* KEY_W */ 0x12, /* KEY_E */
|
||||
0x13, /* KEY_R */ 0x14, /* KEY_T */
|
||||
0x15, /* KEY_Y */ 0x16, /* KEY_U */
|
||||
0x17, /* KEY_I */ 0x18, /* KEY_O */
|
||||
0x19, /* KEY_P */ 0x1a, /* KEY_LBrace */
|
||||
0x1b, /* KEY_RBrace */ 0x1c, /* KEY_Enter */
|
||||
0x1d, /* KEY_LCtrl */ 0x1e, /* KEY_A */
|
||||
0x1f, /* KEY_S */ 0x20, /* KEY_D */
|
||||
0x21, /* KEY_F */ 0x22, /* KEY_G */
|
||||
0x23, /* KEY_H */ 0x24, /* KEY_J */
|
||||
0x25, /* KEY_K */ 0x26, /* KEY_L */
|
||||
0x27, /* KEY_SemiColon */ 0x28, /* KEY_Quote */
|
||||
0x29, /* KEY_Tilde */ 0x2a, /* KEY_ShiftL */
|
||||
0x2b, /* KEY_BSlash */ 0x2c, /* KEY_Z */
|
||||
0x2d, /* KEY_X */ 0x2e, /* KEY_C */
|
||||
0x2f, /* KEY_V */ 0x30, /* KEY_B */
|
||||
0x31, /* KEY_N */ 0x32, /* KEY_M */
|
||||
0x33, /* KEY_Comma */ 0x34, /* KEY_Period */
|
||||
0x35, /* KEY_Slash */ 0x36, /* KEY_ShiftR */
|
||||
0x37, /* KEY_KP_Multiply */ 0x38, /* KEY_Alt */
|
||||
0x39, /* KEY_Space */ 0x3a, /* KEY_CapsLock */
|
||||
0x3b, /* KEY_F1 */ 0x3c, /* KEY_F2 */
|
||||
0x3d, /* KEY_F3 */ 0x3e, /* KEY_F4 */
|
||||
0x3f, /* KEY_F5 */ 0x40, /* KEY_F6 */
|
||||
0x41, /* KEY_F7 */ 0x42, /* KEY_F8 */
|
||||
0x43, /* KEY_F9 */ 0x44, /* KEY_F10 */
|
||||
0x45, /* KEY_NumLock */ 0x46, /* KEY_ScrollLock */
|
||||
0x47, /* KEY_KP_7 */ 0x48, /* KEY_KP_8 */
|
||||
0x49, /* KEY_KP_9 */ 0x4a, /* KEY_KP_Minus */
|
||||
0x4b, /* KEY_KP_4 */ 0x4c, /* KEY_KP_5 */
|
||||
0x4d, /* KEY_KP_6 */ 0x4e, /* KEY_KP_Plus */
|
||||
0x4f, /* KEY_KP_1 */ 0x50, /* KEY_KP_2 */
|
||||
0x51, /* KEY_KP_3 */ 0x52, /* KEY_KP_0 */
|
||||
0x53, /* KEY_KP_Decimal */ 0x54, /* KEY_SysReqest */
|
||||
0x00, /* 0x55 */ 0x56, /* KEY_Less */
|
||||
0x57, /* KEY_F11 */ 0x58, /* KEY_F12 */
|
||||
0x66, /* KEY_Home */ 0x67, /* KEY_Up */
|
||||
0x68, /* KEY_PgUp */ 0x69, /* KEY_Left */
|
||||
0x5d, /* KEY_Begin */ 0x6a, /* KEY_Right */
|
||||
0x6b, /* KEY_End */ 0x6c, /* KEY_Down */
|
||||
0x6d, /* KEY_PgDown */ 0x6e, /* KEY_Insert */
|
||||
0x6f, /* KEY_Delete */ 0x60, /* KEY_KP_Enter */
|
||||
0x61, /* KEY_RCtrl */ 0x77, /* KEY_Pause */
|
||||
0x63, /* KEY_Print */ 0x62, /* KEY_KP_Divide */
|
||||
0x64, /* KEY_AltLang */ 0x65, /* KEY_Break */
|
||||
0x00, /* KEY_LMeta */ 0x00, /* KEY_RMeta */
|
||||
0x7A, /* KEY_Menu/FOCUS_PF11*/0x00, /* 0x6e */
|
||||
0x7B, /* FOCUS_PF12 */ 0x00, /* 0x70 */
|
||||
0x00, /* 0x71 */ 0x00, /* 0x72 */
|
||||
0x59, /* FOCUS_PF2 */ 0x78, /* FOCUS_PF9 */
|
||||
0x00, /* 0x75 */ 0x00, /* 0x76 */
|
||||
0x5A, /* FOCUS_PF3 */ 0x5B, /* FOCUS_PF4 */
|
||||
0x5C, /* FOCUS_PF5 */ 0x5D, /* FOCUS_PF6 */
|
||||
0x5E, /* FOCUS_PF7 */ 0x5F, /* FOCUS_PF8 */
|
||||
0x7C, /* JAP_86 */ 0x79, /* FOCUS_PF10 */
|
||||
0x00, /* 0x7f */
|
||||
};
|
||||
|
||||
#define NUM_AT_KEYS (sizeof(at2lnx)/sizeof(at2lnx[0]))
|
||||
#define LNX_KEY_INDEX(n) n < NUM_AT_KEYS ? at2lnx[n] : 0
|
||||
|
||||
#else /* not XKB */
|
||||
#define LNX_KEY_INDEX(n) n
|
||||
#endif
|
||||
|
||||
static unsigned char tbl[KD_MAX_WIDTH] =
|
||||
{
|
||||
0,
|
||||
1 << KG_SHIFT,
|
||||
|
@ -112,24 +222,31 @@ static unsigned char tbl[KD_MAX_WIDTH] =
|
|||
};
|
||||
|
||||
static void
|
||||
readKernelMapping(void)
|
||||
readKernelMapping(KdKeyboardInfo *ki)
|
||||
{
|
||||
KeySym *k;
|
||||
int i, j;
|
||||
struct kbentry kbe;
|
||||
int minKeyCode, maxKeyCode;
|
||||
int row;
|
||||
int fd;
|
||||
|
||||
if (!ki)
|
||||
return;
|
||||
|
||||
fd = LinuxConsoleFd;
|
||||
|
||||
minKeyCode = NR_KEYS;
|
||||
maxKeyCode = 0;
|
||||
row = 0;
|
||||
ki->keySyms.mapWidth = KD_MAX_WIDTH;
|
||||
for (i = 0; i < NR_KEYS && row < KD_MAX_LENGTH; ++i)
|
||||
{
|
||||
kbe.kb_index = i;
|
||||
kbe.kb_index = LNX_KEY_INDEX(i);
|
||||
|
||||
k = kdKeymap + row * KD_MAX_WIDTH;
|
||||
k = ki->keySyms.map + row * ki->keySyms.mapWidth;
|
||||
|
||||
for (j = 0; j < KD_MAX_WIDTH; ++j)
|
||||
for (j = 0; j < ki->keySyms.mapWidth; ++j)
|
||||
{
|
||||
unsigned short kval;
|
||||
|
||||
|
@ -137,7 +254,7 @@ readKernelMapping(void)
|
|||
|
||||
kbe.kb_table = tbl[j];
|
||||
kbe.kb_value = 0;
|
||||
if (ioctl(LinuxConsoleFd, KDGKBENT, &kbe))
|
||||
if (ioctl(fd, KDGKBENT, &kbe))
|
||||
continue;
|
||||
|
||||
kval = KVAL(kbe.kb_value);
|
||||
|
@ -362,7 +479,7 @@ readKernelMapping(void)
|
|||
|
||||
if (minKeyCode == NR_KEYS)
|
||||
continue;
|
||||
|
||||
|
||||
if (k[3] == k[2]) k[3] = NoSymbol;
|
||||
if (k[2] == k[1]) k[2] = NoSymbol;
|
||||
if (k[1] == k[0]) k[1] = NoSymbol;
|
||||
|
@ -370,28 +487,223 @@ readKernelMapping(void)
|
|||
if (k[3] == k[0] && k[2] == k[1] && k[2] == NoSymbol) k[3] =NoSymbol;
|
||||
row++;
|
||||
}
|
||||
kdMinScanCode = minKeyCode;
|
||||
kdMaxScanCode = maxKeyCode;
|
||||
ki->minScanCode = minKeyCode;
|
||||
ki->maxScanCode = maxKeyCode;
|
||||
}
|
||||
|
||||
static void
|
||||
LinuxKeyboardLoad (void)
|
||||
{
|
||||
readKernelMapping ();
|
||||
}
|
||||
#ifdef XKB
|
||||
|
||||
/*
|
||||
* We need these to handle extended scancodes correctly (I could just use the
|
||||
* numbers below, but this makes the code more readable
|
||||
*/
|
||||
|
||||
/* The prefix codes */
|
||||
#define KEY_Prefix0 /* special 0x60 */ 96
|
||||
#define KEY_Prefix1 /* special 0x61 */ 97
|
||||
|
||||
/* The raw scancodes */
|
||||
#define KEY_Enter /* Enter 0x1c */ 28
|
||||
#define KEY_LCtrl /* Ctrl(left) 0x1d */ 29
|
||||
#define KEY_Slash /* / (Slash) ? 0x35 */ 53
|
||||
#define KEY_KP_Multiply /* * 0x37 */ 55
|
||||
#define KEY_Alt /* Alt(left) 0x38 */ 56
|
||||
#define KEY_F3 /* F3 0x3d */ 61
|
||||
#define KEY_F4 /* F4 0x3e */ 62
|
||||
#define KEY_F5 /* F5 0x3f */ 63
|
||||
#define KEY_F6 /* F6 0x40 */ 64
|
||||
#define KEY_F7 /* F7 0x41 */ 65
|
||||
#define KEY_ScrollLock /* ScrollLock 0x46 */ 70
|
||||
#define KEY_KP_7 /* 7 Home 0x47 */ 71
|
||||
#define KEY_KP_8 /* 8 Up 0x48 */ 72
|
||||
#define KEY_KP_9 /* 9 PgUp 0x49 */ 73
|
||||
#define KEY_KP_Minus /* - (Minus) 0x4a */ 74
|
||||
#define KEY_KP_4 /* 4 Left 0x4b */ 75
|
||||
#define KEY_KP_5 /* 5 0x4c */ 76
|
||||
#define KEY_KP_6 /* 6 Right 0x4d */ 77
|
||||
#define KEY_KP_Plus /* + (Plus) 0x4e */ 78
|
||||
#define KEY_KP_1 /* 1 End 0x4f */ 79
|
||||
#define KEY_KP_2 /* 2 Down 0x50 */ 80
|
||||
#define KEY_KP_3 /* 3 PgDown 0x51 */ 81
|
||||
#define KEY_KP_0 /* 0 Insert 0x52 */ 82
|
||||
#define KEY_KP_Decimal /* . (Decimal) Delete 0x53 */ 83
|
||||
#define KEY_Home /* Home 0x59 */ 89
|
||||
#define KEY_Up /* Up 0x5a */ 90
|
||||
#define KEY_PgUp /* PgUp 0x5b */ 91
|
||||
#define KEY_Left /* Left 0x5c */ 92
|
||||
#define KEY_Begin /* Begin 0x5d */ 93
|
||||
#define KEY_Right /* Right 0x5e */ 94
|
||||
#define KEY_End /* End 0x5f */ 95
|
||||
#define KEY_Down /* Down 0x60 */ 96
|
||||
#define KEY_PgDown /* PgDown 0x61 */ 97
|
||||
#define KEY_Insert /* Insert 0x62 */ 98
|
||||
#define KEY_Delete /* Delete 0x63 */ 99
|
||||
#define KEY_KP_Enter /* Enter 0x64 */ 100
|
||||
#define KEY_RCtrl /* Ctrl(right) 0x65 */ 101
|
||||
#define KEY_Pause /* Pause 0x66 */ 102
|
||||
#define KEY_Print /* Print 0x67 */ 103
|
||||
#define KEY_KP_Divide /* Divide 0x68 */ 104
|
||||
#define KEY_AltLang /* AtlLang(right) 0x69 */ 105
|
||||
#define KEY_Break /* Break 0x6a */ 106
|
||||
#define KEY_LMeta /* Left Meta 0x6b */ 107
|
||||
#define KEY_RMeta /* Right Meta 0x6c */ 108
|
||||
#define KEY_Menu /* Menu 0x6d */ 109
|
||||
#define KEY_F13 /* F13 0x6e */ 110
|
||||
#define KEY_F14 /* F14 0x6f */ 111
|
||||
#define KEY_F15 /* F15 0x70 */ 112
|
||||
#define KEY_F16 /* F16 0x71 */ 113
|
||||
#define KEY_F17 /* F17 0x72 */ 114
|
||||
#define KEY_KP_DEC /* KP_DEC 0x73 */ 115
|
||||
|
||||
#endif /* XKB */
|
||||
|
||||
|
||||
static void
|
||||
LinuxKeyboardRead (int fd, void *closure)
|
||||
{
|
||||
unsigned char buf[256], *b;
|
||||
int n;
|
||||
unsigned char prefix = 0, scancode = 0;
|
||||
|
||||
while ((n = read (fd, buf, sizeof (buf))) > 0)
|
||||
{
|
||||
while ((n = read (fd, buf, sizeof (buf))) > 0) {
|
||||
b = buf;
|
||||
while (n--)
|
||||
{
|
||||
KdEnqueueKeyboardEvent (b[0] & 0x7f, b[0] & 0x80);
|
||||
while (n--) {
|
||||
#ifdef XKB
|
||||
if (!noXkbExtension) {
|
||||
/*
|
||||
* With xkb we use RAW mode for reading the console, which allows us
|
||||
* process extended scancodes.
|
||||
*
|
||||
* See if this is a prefix extending the following keycode
|
||||
*/
|
||||
if (!prefix && ((b[0] & 0x7f) == KEY_Prefix0))
|
||||
{
|
||||
prefix = KEY_Prefix0;
|
||||
#ifdef DEBUG
|
||||
ErrorF("Prefix0");
|
||||
#endif
|
||||
/* swallow this up */
|
||||
b++;
|
||||
continue;
|
||||
}
|
||||
else if (!prefix && ((b[0] & 0x7f) == KEY_Prefix1))
|
||||
{
|
||||
prefix = KEY_Prefix1;
|
||||
ErrorF("Prefix1");
|
||||
/* swallow this up */
|
||||
b++;
|
||||
continue;
|
||||
}
|
||||
scancode = b[0] & 0x7f;
|
||||
|
||||
switch (prefix) {
|
||||
/* from xf86Events.c */
|
||||
case KEY_Prefix0:
|
||||
{
|
||||
#ifdef DEBUG
|
||||
ErrorF("Prefix0 scancode: 0x%02x\n", scancode);
|
||||
#endif
|
||||
switch (scancode) {
|
||||
case KEY_KP_7:
|
||||
scancode = KEY_Home; break; /* curs home */
|
||||
case KEY_KP_8:
|
||||
scancode = KEY_Up; break; /* curs up */
|
||||
case KEY_KP_9:
|
||||
scancode = KEY_PgUp; break; /* curs pgup */
|
||||
case KEY_KP_4:
|
||||
scancode = KEY_Left; break; /* curs left */
|
||||
case KEY_KP_5:
|
||||
scancode = KEY_Begin; break; /* curs begin */
|
||||
case KEY_KP_6:
|
||||
scancode = KEY_Right; break; /* curs right */
|
||||
case KEY_KP_1:
|
||||
scancode = KEY_End; break; /* curs end */
|
||||
case KEY_KP_2:
|
||||
scancode = KEY_Down; break; /* curs down */
|
||||
case KEY_KP_3:
|
||||
scancode = KEY_PgDown; break; /* curs pgdown */
|
||||
case KEY_KP_0:
|
||||
scancode = KEY_Insert; break; /* curs insert */
|
||||
case KEY_KP_Decimal:
|
||||
scancode = KEY_Delete; break; /* curs delete */
|
||||
case KEY_Enter:
|
||||
scancode = KEY_KP_Enter; break; /* keypad enter */
|
||||
case KEY_LCtrl:
|
||||
scancode = KEY_RCtrl; break; /* right ctrl */
|
||||
case KEY_KP_Multiply:
|
||||
scancode = KEY_Print; break; /* print */
|
||||
case KEY_Slash:
|
||||
scancode = KEY_KP_Divide; break; /* keyp divide */
|
||||
case KEY_Alt:
|
||||
scancode = KEY_AltLang; break; /* right alt */
|
||||
case KEY_ScrollLock:
|
||||
scancode = KEY_Break; break; /* curs break */
|
||||
case 0x5b:
|
||||
scancode = KEY_LMeta; break;
|
||||
case 0x5c:
|
||||
scancode = KEY_RMeta; break;
|
||||
case 0x5d:
|
||||
scancode = KEY_Menu; break;
|
||||
case KEY_F3:
|
||||
scancode = KEY_F13; break;
|
||||
case KEY_F4:
|
||||
scancode = KEY_F14; break;
|
||||
case KEY_F5:
|
||||
scancode = KEY_F15; break;
|
||||
case KEY_F6:
|
||||
scancode = KEY_F16; break;
|
||||
case KEY_F7:
|
||||
scancode = KEY_F17; break;
|
||||
case KEY_KP_Plus:
|
||||
scancode = KEY_KP_DEC; break;
|
||||
/* Ignore virtual shifts (E0 2A, E0 AA, E0 36, E0 B6) */
|
||||
case 0x2A:
|
||||
case 0x36:
|
||||
b++;
|
||||
prefix = 0;
|
||||
continue;
|
||||
default:
|
||||
#ifdef DEBUG
|
||||
ErrorF("Unreported Prefix0 scancode: 0x%02x\n",
|
||||
scancode);
|
||||
#endif
|
||||
/*
|
||||
* "Internet" keyboards are generating lots of new
|
||||
* codes. Let them pass. There is little consistency
|
||||
* between them, so don't bother with symbolic names at
|
||||
* this level.
|
||||
*/
|
||||
scancode += 0x78;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case KEY_Prefix1:
|
||||
{
|
||||
/* we do no handle these */
|
||||
#ifdef DEBUG
|
||||
ErrorF("Prefix1 scancode: 0x%02x\n", scancode);
|
||||
#endif
|
||||
b++;
|
||||
prefix = 0;
|
||||
continue;
|
||||
}
|
||||
|
||||
default: /* should not happen*/
|
||||
case 0: /* do nothing */
|
||||
#ifdef DEBUG
|
||||
ErrorF("Plain scancode: 0x%02x\n", scancode);
|
||||
#endif
|
||||
;
|
||||
}
|
||||
|
||||
prefix = 0;
|
||||
}
|
||||
/* without xkb we use mediumraw mode -- enqueue the scancode as is */
|
||||
else
|
||||
#endif
|
||||
scancode = b[0] & 0x7f;
|
||||
KdEnqueueKeyboardEvent (closure, scancode, b[0] & 0x80);
|
||||
b++;
|
||||
}
|
||||
}
|
||||
|
@ -399,19 +711,30 @@ LinuxKeyboardRead (int fd, void *closure)
|
|||
|
||||
static int LinuxKbdTrans;
|
||||
static struct termios LinuxTermios;
|
||||
static int LinuxKbdType;
|
||||
|
||||
static int
|
||||
LinuxKeyboardEnable (int fd, void *closure)
|
||||
static Status
|
||||
LinuxKeyboardEnable (KdKeyboardInfo *ki)
|
||||
{
|
||||
struct termios nTty;
|
||||
unsigned char buf[256];
|
||||
int n;
|
||||
int fd;
|
||||
|
||||
if (!ki)
|
||||
return !Success;
|
||||
|
||||
fd = LinuxConsoleFd;
|
||||
ki->driverPrivate = (void *) fd;
|
||||
|
||||
ioctl (fd, KDGKBMODE, &LinuxKbdTrans);
|
||||
tcgetattr (fd, &LinuxTermios);
|
||||
|
||||
ioctl(fd, KDSKBMODE, K_MEDIUMRAW);
|
||||
#ifdef XKB
|
||||
if (!noXkbExtension)
|
||||
ioctl(fd, KDSKBMODE, K_RAW);
|
||||
else
|
||||
#else
|
||||
ioctl(fd, KDSKBMODE, K_MEDIUMRAW);
|
||||
#endif
|
||||
nTty = LinuxTermios;
|
||||
nTty.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
|
||||
nTty.c_oflag = 0;
|
||||
|
@ -427,61 +750,56 @@ LinuxKeyboardEnable (int fd, void *closure)
|
|||
*/
|
||||
while ((n = read (fd, buf, sizeof (buf))) > 0)
|
||||
;
|
||||
return fd;
|
||||
KdRegisterFd (fd, LinuxKeyboardRead, ki);
|
||||
return Success;
|
||||
}
|
||||
|
||||
static void
|
||||
LinuxKeyboardDisable (int fd, void *closure)
|
||||
LinuxKeyboardDisable (KdKeyboardInfo *ki)
|
||||
{
|
||||
ioctl(LinuxConsoleFd, KDSKBMODE, LinuxKbdTrans);
|
||||
tcsetattr(LinuxConsoleFd, TCSANOW, &LinuxTermios);
|
||||
int fd;
|
||||
|
||||
if (!ki)
|
||||
return;
|
||||
|
||||
fd = (int) ki->driverPrivate;
|
||||
|
||||
KdUnregisterFd(ki, fd, FALSE);
|
||||
ioctl(fd, KDSKBMODE, LinuxKbdTrans);
|
||||
tcsetattr(fd, TCSANOW, &LinuxTermios);
|
||||
}
|
||||
|
||||
static int
|
||||
LinuxKeyboardInit (void)
|
||||
static Status
|
||||
LinuxKeyboardInit (KdKeyboardInfo *ki)
|
||||
{
|
||||
if (!LinuxKbdType)
|
||||
LinuxKbdType = KdAllocInputType ();
|
||||
if (!ki)
|
||||
return !Success;
|
||||
|
||||
KdRegisterFd (LinuxKbdType, LinuxConsoleFd, LinuxKeyboardRead, 0);
|
||||
LinuxKeyboardEnable (LinuxConsoleFd, 0);
|
||||
KdRegisterFdEnableDisable (LinuxConsoleFd,
|
||||
LinuxKeyboardEnable,
|
||||
LinuxKeyboardDisable);
|
||||
return 1;
|
||||
if (ki->path)
|
||||
xfree(ki->path);
|
||||
ki->path = KdSaveString("console");
|
||||
if (ki->name)
|
||||
xfree(ki->name);
|
||||
ki->name = KdSaveString("Linux console keyboard");
|
||||
|
||||
readKernelMapping (ki);
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
static void
|
||||
LinuxKeyboardFini (void)
|
||||
LinuxKeyboardLeds (KdKeyboardInfo *ki, int leds)
|
||||
{
|
||||
LinuxKeyboardDisable (LinuxConsoleFd, 0);
|
||||
KdUnregisterFds (LinuxKbdType, FALSE);
|
||||
if (!ki)
|
||||
return;
|
||||
|
||||
ioctl ((int)ki->driverPrivate, KDSETLED, leds & 7);
|
||||
}
|
||||
|
||||
static void
|
||||
LinuxKeyboardLeds (int leds)
|
||||
{
|
||||
ioctl (LinuxConsoleFd, KDSETLED, leds & 7);
|
||||
}
|
||||
|
||||
static void
|
||||
LinuxKeyboardBell (int volume, int pitch, int duration)
|
||||
{
|
||||
if (volume && pitch)
|
||||
{
|
||||
ioctl(LinuxConsoleFd, KDMKTONE,
|
||||
((1193190 / pitch) & 0xffff) |
|
||||
(((unsigned long)duration *
|
||||
volume / 50) << 16));
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
KdKeyboardFuncs LinuxKeyboardFuncs = {
|
||||
LinuxKeyboardLoad,
|
||||
LinuxKeyboardInit,
|
||||
LinuxKeyboardLeds,
|
||||
LinuxKeyboardBell,
|
||||
LinuxKeyboardFini,
|
||||
3,
|
||||
KdKeyboardDriver LinuxKeyboardDriver = {
|
||||
"keyboard",
|
||||
.Init = LinuxKeyboardInit,
|
||||
.Enable = LinuxKeyboardEnable,
|
||||
.Leds = LinuxKeyboardLeds,
|
||||
.Disable = LinuxKeyboardDisable,
|
||||
};
|
||||
|
|
|
@ -373,26 +373,6 @@ LinuxEnable (void)
|
|||
enabled = TRUE;
|
||||
}
|
||||
|
||||
static Bool
|
||||
LinuxSpecialKey (KeySym sym)
|
||||
{
|
||||
struct vt_stat vts;
|
||||
int con;
|
||||
|
||||
if (XK_F1 <= sym && sym <= XK_F12)
|
||||
{
|
||||
con = sym - XK_F1 + 1;
|
||||
memset (&vts, '\0', sizeof (vts)); /* valgrind */
|
||||
ioctl (LinuxConsoleFd, VT_GETSTATE, &vts);
|
||||
if (con != vts.v_active && (vts.v_state & (1 << con)))
|
||||
{
|
||||
ioctl (LinuxConsoleFd, VT_ACTIVATE, con);
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static void
|
||||
LinuxDisable (void)
|
||||
{
|
||||
|
@ -456,6 +436,7 @@ LinuxFini (void)
|
|||
}
|
||||
}
|
||||
close(LinuxConsoleFd); /* make the vt-manager happy */
|
||||
LinuxConsoleFd = -1;
|
||||
fd = open ("/dev/tty0", O_RDWR|O_NDELAY, 0);
|
||||
if (fd >= 0)
|
||||
{
|
||||
|
@ -468,13 +449,32 @@ LinuxFini (void)
|
|||
return;
|
||||
}
|
||||
|
||||
void
|
||||
KdOsAddInputDrivers ()
|
||||
{
|
||||
KdAddPointerDriver(&LinuxMouseDriver);
|
||||
KdAddPointerDriver(&MsMouseDriver);
|
||||
KdAddPointerDriver(&Ps2MouseDriver);
|
||||
#ifdef TSLIB
|
||||
KdAddPointerDriver(&TsDriver);
|
||||
#endif
|
||||
KdAddKeyboardDriver(&LinuxKeyboardDriver);
|
||||
}
|
||||
|
||||
static void
|
||||
LinuxBell(int volume, int pitch, int duration)
|
||||
{
|
||||
if (volume && pitch)
|
||||
ioctl(LinuxConsoleFd, KDMKTONE, ((1193190 / pitch) & 0xffff) |
|
||||
(((unsigned long)duration * volume / 50) << 16));
|
||||
}
|
||||
|
||||
KdOsFuncs LinuxFuncs = {
|
||||
LinuxInit,
|
||||
LinuxEnable,
|
||||
LinuxSpecialKey,
|
||||
LinuxDisable,
|
||||
LinuxFini,
|
||||
0
|
||||
.Init = LinuxInit,
|
||||
.Enable = LinuxEnable,
|
||||
.Disable = LinuxDisable,
|
||||
.Fini = LinuxFini,
|
||||
.Bell = LinuxBell,
|
||||
};
|
||||
|
||||
void
|
||||
|
|
|
@ -206,10 +206,10 @@ MouseWriteBytes (int fd, unsigned char *c, int n, int timeout)
|
|||
|
||||
typedef struct _kmouseProt {
|
||||
char *name;
|
||||
Bool (*Complete) (KdMouseInfo *mi, unsigned char *ev, int ne);
|
||||
int (*Valid) (KdMouseInfo *mi, unsigned char *ev, int ne);
|
||||
Bool (*Parse) (KdMouseInfo *mi, unsigned char *ev, int ne);
|
||||
Bool (*Init) (KdMouseInfo *mi);
|
||||
Bool (*Complete) (KdPointerInfo *pi, unsigned char *ev, int ne);
|
||||
int (*Valid) (KdPointerInfo *pi, unsigned char *ev, int ne);
|
||||
Bool (*Parse) (KdPointerInfo *pi, unsigned char *ev, int ne);
|
||||
Bool (*Init) (KdPointerInfo *pi);
|
||||
unsigned char headerMask, headerValid;
|
||||
unsigned char dataMask, dataValid;
|
||||
Bool tty;
|
||||
|
@ -238,9 +238,9 @@ typedef struct _kmouse {
|
|||
unsigned long state; /* private per protocol, init to prot->state */
|
||||
} Kmouse;
|
||||
|
||||
static int mouseValid (KdMouseInfo *mi, unsigned char *ev, int ne)
|
||||
static int mouseValid (KdPointerInfo *pi, unsigned char *ev, int ne)
|
||||
{
|
||||
Kmouse *km = mi->driver;
|
||||
Kmouse *km = pi->driverPrivate;
|
||||
const KmouseProt *prot = km->prot;
|
||||
int i;
|
||||
|
||||
|
@ -255,24 +255,24 @@ static int mouseValid (KdMouseInfo *mi, unsigned char *ev, int ne)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static Bool threeComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
|
||||
static Bool threeComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
|
||||
{
|
||||
return ne == 3;
|
||||
}
|
||||
|
||||
static Bool fourComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
|
||||
static Bool fourComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
|
||||
{
|
||||
return ne == 4;
|
||||
}
|
||||
|
||||
static Bool fiveComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
|
||||
static Bool fiveComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
|
||||
{
|
||||
return ne == 5;
|
||||
}
|
||||
|
||||
static Bool MouseReasonable (KdMouseInfo *mi, unsigned long flags, int dx, int dy)
|
||||
static Bool MouseReasonable (KdPointerInfo *pi, unsigned long flags, int dx, int dy)
|
||||
{
|
||||
Kmouse *km = mi->driver;
|
||||
Kmouse *km = pi->driverPrivate;
|
||||
|
||||
if (km->stage == MouseWorking)
|
||||
return TRUE;
|
||||
|
@ -296,9 +296,9 @@ static Bool MouseReasonable (KdMouseInfo *mi, unsigned long flags, int dx, int d
|
|||
/*
|
||||
* Standard PS/2 mouse protocol
|
||||
*/
|
||||
static Bool ps2Parse (KdMouseInfo *mi, unsigned char *ev, int ne)
|
||||
static Bool ps2Parse (KdPointerInfo *pi, unsigned char *ev, int ne)
|
||||
{
|
||||
Kmouse *km = mi->driver;
|
||||
Kmouse *km = pi->driverPrivate;
|
||||
int dx, dy, dz;
|
||||
unsigned long flags;
|
||||
unsigned long flagsrelease = 0;
|
||||
|
@ -333,21 +333,21 @@ static Bool ps2Parse (KdMouseInfo *mi, unsigned char *ev, int ne)
|
|||
if (ev[0] & 0x20)
|
||||
dy -= 256;
|
||||
dy = -dy;
|
||||
if (!MouseReasonable (mi, flags, dx, dy))
|
||||
if (!MouseReasonable (pi, flags, dx, dy))
|
||||
return FALSE;
|
||||
if (km->stage == MouseWorking)
|
||||
{
|
||||
KdEnqueueMouseEvent (mi, flags, dx, dy);
|
||||
KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
|
||||
if (flagsrelease)
|
||||
{
|
||||
flags &= ~flagsrelease;
|
||||
KdEnqueueMouseEvent (mi, flags, dx, dy);
|
||||
KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static Bool ps2Init (KdMouseInfo *mi);
|
||||
static Bool ps2Init (KdPointerInfo *pi);
|
||||
|
||||
static const KmouseProt ps2Prot = {
|
||||
"ps/2",
|
||||
|
@ -450,9 +450,9 @@ static unsigned char intelli_init[] = {
|
|||
#define NINIT_INTELLI 3
|
||||
|
||||
static int
|
||||
ps2SkipInit (KdMouseInfo *mi, int ninit, Bool ret_next)
|
||||
ps2SkipInit (KdPointerInfo *pi, int ninit, Bool ret_next)
|
||||
{
|
||||
Kmouse *km = mi->driver;
|
||||
Kmouse *km = pi->driverPrivate;
|
||||
int c = -1;
|
||||
int skipping;
|
||||
Bool waiting;
|
||||
|
@ -481,9 +481,9 @@ ps2SkipInit (KdMouseInfo *mi, int ninit, Bool ret_next)
|
|||
}
|
||||
|
||||
static Bool
|
||||
ps2Init (KdMouseInfo *mi)
|
||||
ps2Init (KdPointerInfo *pi)
|
||||
{
|
||||
Kmouse *km = mi->driver;
|
||||
Kmouse *km = pi->driverPrivate;
|
||||
int skipping;
|
||||
Bool waiting;
|
||||
int id;
|
||||
|
@ -499,7 +499,7 @@ ps2Init (KdMouseInfo *mi)
|
|||
return FALSE;
|
||||
skipping = 0;
|
||||
waiting = FALSE;
|
||||
id = ps2SkipInit (mi, 0, TRUE);
|
||||
id = ps2SkipInit (pi, 0, TRUE);
|
||||
switch (id) {
|
||||
case 3:
|
||||
init = wheel_3button_init;
|
||||
|
@ -524,13 +524,13 @@ ps2Init (KdMouseInfo *mi)
|
|||
* initialization string. Make sure any partial event is
|
||||
* skipped
|
||||
*/
|
||||
(void) ps2SkipInit (mi, ninit, FALSE);
|
||||
(void) ps2SkipInit (pi, ninit, FALSE);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static Bool busParse (KdMouseInfo *mi, unsigned char *ev, int ne)
|
||||
static Bool busParse (KdPointerInfo *pi, unsigned char *ev, int ne)
|
||||
{
|
||||
Kmouse *km = mi->driver;
|
||||
Kmouse *km = pi->driverPrivate;
|
||||
int dx, dy;
|
||||
unsigned long flags;
|
||||
|
||||
|
@ -543,10 +543,10 @@ static Bool busParse (KdMouseInfo *mi, unsigned char *ev, int ne)
|
|||
flags |= KD_BUTTON_2;
|
||||
if ((ev[0] & 1) == 0)
|
||||
flags |= KD_BUTTON_3;
|
||||
if (!MouseReasonable (mi, flags, dx, dy))
|
||||
if (!MouseReasonable (pi, flags, dx, dy))
|
||||
return FALSE;
|
||||
if (km->stage == MouseWorking)
|
||||
KdEnqueueMouseEvent (mi, flags, dx, dy);
|
||||
KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
@ -561,9 +561,9 @@ static const KmouseProt busProt = {
|
|||
* Standard MS serial protocol, three bytes
|
||||
*/
|
||||
|
||||
static Bool msParse (KdMouseInfo *mi, unsigned char *ev, int ne)
|
||||
static Bool msParse (KdPointerInfo *pi, unsigned char *ev, int ne)
|
||||
{
|
||||
Kmouse *km = mi->driver;
|
||||
Kmouse *km = pi->driverPrivate;
|
||||
int dx, dy;
|
||||
unsigned long flags;
|
||||
|
||||
|
@ -576,10 +576,10 @@ static Bool msParse (KdMouseInfo *mi, unsigned char *ev, int ne)
|
|||
|
||||
dx = (signed char)(((ev[0] & 0x03) << 6) | (ev[1] & 0x3F));
|
||||
dy = (signed char)(((ev[0] & 0x0C) << 4) | (ev[2] & 0x3F));
|
||||
if (!MouseReasonable (mi, flags, dx, dy))
|
||||
if (!MouseReasonable (pi, flags, dx, dy))
|
||||
return FALSE;
|
||||
if (km->stage == MouseWorking)
|
||||
KdEnqueueMouseEvent (mi, flags, dx, dy);
|
||||
KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
@ -600,9 +600,9 @@ static const KmouseProt msProt = {
|
|||
* first byte of a synchronized protocol stream and see if it's got
|
||||
* any bits turned on that can't occur in that fourth byte
|
||||
*/
|
||||
static Bool logiComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
|
||||
static Bool logiComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
|
||||
{
|
||||
Kmouse *km = mi->driver;
|
||||
Kmouse *km = pi->driverPrivate;
|
||||
|
||||
if ((ev[0] & 0x40) == 0x40)
|
||||
return ne == 3;
|
||||
|
@ -611,9 +611,9 @@ static Bool logiComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
|
|||
return FALSE;
|
||||
}
|
||||
|
||||
static int logiValid (KdMouseInfo *mi, unsigned char *ev, int ne)
|
||||
static int logiValid (KdPointerInfo *pi, unsigned char *ev, int ne)
|
||||
{
|
||||
Kmouse *km = mi->driver;
|
||||
Kmouse *km = pi->driverPrivate;
|
||||
const KmouseProt *prot = km->prot;
|
||||
int i;
|
||||
|
||||
|
@ -632,9 +632,9 @@ static int logiValid (KdMouseInfo *mi, unsigned char *ev, int ne)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static Bool logiParse (KdMouseInfo *mi, unsigned char *ev, int ne)
|
||||
static Bool logiParse (KdPointerInfo *pi, unsigned char *ev, int ne)
|
||||
{
|
||||
Kmouse *km = mi->driver;
|
||||
Kmouse *km = pi->driverPrivate;
|
||||
int dx, dy;
|
||||
unsigned long flags;
|
||||
|
||||
|
@ -660,10 +660,10 @@ static Bool logiParse (KdMouseInfo *mi, unsigned char *ev, int ne)
|
|||
flags |= km->state & (KD_BUTTON_1|KD_BUTTON_3);
|
||||
}
|
||||
|
||||
if (!MouseReasonable (mi, flags, dx, dy))
|
||||
if (!MouseReasonable (pi, flags, dx, dy))
|
||||
return FALSE;
|
||||
if (km->stage == MouseWorking)
|
||||
KdEnqueueMouseEvent (mi, flags, dx, dy);
|
||||
KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
@ -682,9 +682,9 @@ static const KmouseProt logiProt = {
|
|||
/*
|
||||
* Mouse systems protocol, 5 bytes
|
||||
*/
|
||||
static Bool mscParse (KdMouseInfo *mi, unsigned char *ev, int ne)
|
||||
static Bool mscParse (KdPointerInfo *pi, unsigned char *ev, int ne)
|
||||
{
|
||||
Kmouse *km = mi->driver;
|
||||
Kmouse *km = pi->driverPrivate;
|
||||
int dx, dy;
|
||||
unsigned long flags;
|
||||
|
||||
|
@ -699,10 +699,10 @@ static Bool mscParse (KdMouseInfo *mi, unsigned char *ev, int ne)
|
|||
dx = (signed char)(ev[1]) + (signed char)(ev[3]);
|
||||
dy = - ((signed char)(ev[2]) + (signed char)(ev[4]));
|
||||
|
||||
if (!MouseReasonable (mi, flags, dx, dy))
|
||||
if (!MouseReasonable (pi, flags, dx, dy))
|
||||
return FALSE;
|
||||
if (km->stage == MouseWorking)
|
||||
KdEnqueueMouseEvent (mi, flags, dx, dy);
|
||||
KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
@ -810,8 +810,8 @@ MouseNextProtocol (Kmouse *km)
|
|||
static void
|
||||
MouseRead (int mousePort, void *closure)
|
||||
{
|
||||
KdMouseInfo *mi = closure;
|
||||
Kmouse *km = mi->driver;
|
||||
KdPointerInfo *pi = closure;
|
||||
Kmouse *km = pi->driverPrivate;
|
||||
unsigned char event[MAX_MOUSE];
|
||||
int ne;
|
||||
int c;
|
||||
|
@ -835,7 +835,7 @@ MouseRead (int mousePort, void *closure)
|
|||
break;
|
||||
}
|
||||
event[ne++] = c;
|
||||
i = (*km->prot->Valid) (mi, event, ne);
|
||||
i = (*km->prot->Valid) (pi, event, ne);
|
||||
if (i != 0)
|
||||
{
|
||||
#ifdef DEBUG
|
||||
|
@ -867,9 +867,9 @@ MouseRead (int mousePort, void *closure)
|
|||
}
|
||||
else
|
||||
{
|
||||
if ((*km->prot->Complete) (mi, event, ne))
|
||||
if ((*km->prot->Complete) (pi, event, ne))
|
||||
{
|
||||
if ((*km->prot->Parse) (mi, event, ne))
|
||||
if ((*km->prot->Parse) (pi, event, ne))
|
||||
{
|
||||
switch (km->stage)
|
||||
{
|
||||
|
@ -896,7 +896,7 @@ MouseRead (int mousePort, void *closure)
|
|||
km->invalid = 0;
|
||||
km->tested = 0;
|
||||
km->valid = 0;
|
||||
if (km->prot->Init && !(*km->prot->Init) (mi))
|
||||
if (km->prot->Init && !(*km->prot->Init) (pi))
|
||||
km->stage = MouseBroken;
|
||||
}
|
||||
break;
|
||||
|
@ -923,9 +923,9 @@ MouseRead (int mousePort, void *closure)
|
|||
int MouseInputType;
|
||||
|
||||
char *kdefaultMouse[] = {
|
||||
"/dev/input/mice",
|
||||
"/dev/mouse",
|
||||
"/dev/psaux",
|
||||
"/dev/input/mice",
|
||||
"/dev/adbmouse",
|
||||
"/dev/ttyS0",
|
||||
"/dev/ttyS1",
|
||||
|
@ -933,81 +933,97 @@ char *kdefaultMouse[] = {
|
|||
|
||||
#define NUM_DEFAULT_MOUSE (sizeof (kdefaultMouse) / sizeof (kdefaultMouse[0]))
|
||||
|
||||
static Bool
|
||||
MouseInit (void)
|
||||
static Status
|
||||
MouseInit (KdPointerInfo *pi)
|
||||
{
|
||||
int i;
|
||||
int fd;
|
||||
Kmouse *km;
|
||||
KdMouseInfo *mi, *next;
|
||||
int n = 0;
|
||||
char *prot;
|
||||
|
||||
if (!MouseInputType)
|
||||
MouseInputType = KdAllocInputType ();
|
||||
|
||||
for (mi = kdMouseInfo; mi; mi = next)
|
||||
{
|
||||
next = mi->next;
|
||||
prot = mi->prot;
|
||||
if (mi->inputType)
|
||||
continue;
|
||||
if (!mi->name)
|
||||
{
|
||||
for (i = 0; i < NUM_DEFAULT_MOUSE; i++)
|
||||
{
|
||||
fd = open (kdefaultMouse[i], 2);
|
||||
if (fd >= 0)
|
||||
{
|
||||
mi->name = KdSaveString (kdefaultMouse[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
fd = open (mi->name, 2);
|
||||
|
||||
if (fd >= 0)
|
||||
{
|
||||
km = (Kmouse *) xalloc (sizeof (Kmouse));
|
||||
if (km)
|
||||
{
|
||||
km->iob.fd = fd;
|
||||
km->iob.avail = km->iob.used = 0;
|
||||
km->prot = 0;
|
||||
km->i_prot = 0;
|
||||
km->tty = isatty (fd);
|
||||
mi->driver = km;
|
||||
mi->inputType = MouseInputType;
|
||||
MouseFirstProtocol (km, mi->prot);
|
||||
if (KdRegisterFd (MouseInputType, fd, MouseRead, (void *) mi))
|
||||
n++;
|
||||
}
|
||||
else
|
||||
close (fd);
|
||||
}
|
||||
if (!pi)
|
||||
return BadImplementation;
|
||||
|
||||
if (!pi->path || strcmp(pi->path, "auto") == 0) {
|
||||
for (i = 0; i < NUM_DEFAULT_MOUSE; i++) {
|
||||
fd = open (kdefaultMouse[i], 2);
|
||||
if (fd >= 0) {
|
||||
pi->path = KdSaveString (kdefaultMouse[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
else {
|
||||
fd = open (pi->path, 2);
|
||||
}
|
||||
|
||||
if (fd < 0)
|
||||
return BadMatch;
|
||||
|
||||
close(fd);
|
||||
|
||||
km = (Kmouse *) xalloc (sizeof (Kmouse));
|
||||
if (km) {
|
||||
km->iob.avail = km->iob.used = 0;
|
||||
MouseFirstProtocol(km, "exps/2");
|
||||
km->i_prot = 0;
|
||||
km->tty = isatty (fd);
|
||||
km->iob.fd = -1;
|
||||
pi->driverPrivate = km;
|
||||
}
|
||||
else {
|
||||
close (fd);
|
||||
return BadAlloc;
|
||||
}
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
static Status
|
||||
MouseEnable (KdPointerInfo *pi)
|
||||
{
|
||||
Kmouse *km;
|
||||
|
||||
if (!pi || !pi->driverPrivate || !pi->path)
|
||||
return BadImplementation;
|
||||
|
||||
km = pi->driverPrivate;
|
||||
|
||||
km->iob.fd = open(pi->path, 2);
|
||||
if (km->iob.fd < 0)
|
||||
return BadMatch;
|
||||
|
||||
if (!KdRegisterFd (km->iob.fd, MouseRead, pi))
|
||||
{
|
||||
close(km->iob.fd);
|
||||
return BadAlloc;
|
||||
}
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
static void
|
||||
MouseFini (void)
|
||||
MouseDisable (KdPointerInfo *pi)
|
||||
{
|
||||
KdMouseInfo *mi;
|
||||
|
||||
KdUnregisterFds (MouseInputType, TRUE);
|
||||
for (mi = kdMouseInfo; mi; mi = mi->next)
|
||||
{
|
||||
if (mi->inputType == MouseInputType)
|
||||
{
|
||||
xfree (mi->driver);
|
||||
mi->driver = 0;
|
||||
mi->inputType = 0;
|
||||
}
|
||||
}
|
||||
Kmouse *km;
|
||||
if (!pi || !pi->driverPrivate)
|
||||
return;
|
||||
|
||||
km = pi->driverPrivate;
|
||||
KdUnregisterFd (pi, km->iob.fd, TRUE);
|
||||
}
|
||||
|
||||
KdMouseFuncs LinuxMouseFuncs = {
|
||||
static void
|
||||
MouseFini (KdPointerInfo *pi)
|
||||
{
|
||||
xfree (pi->driverPrivate);
|
||||
pi->driverPrivate = NULL;
|
||||
}
|
||||
|
||||
KdPointerDriver LinuxMouseDriver = {
|
||||
"mouse",
|
||||
MouseInit,
|
||||
MouseEnable,
|
||||
MouseDisable,
|
||||
MouseFini,
|
||||
NULL,
|
||||
};
|
||||
|
|
|
@ -90,41 +90,50 @@ MsRead (int port, void *closure)
|
|||
dy = (char)(((b[0] & 0x0C) << 4) | (b[2] & 0x3F));
|
||||
n -= 3;
|
||||
b += 3;
|
||||
KdEnqueueMouseEvent (kdMouseInfo, flags, dx, dy);
|
||||
KdEnqueuePointerEvent (closure, flags, dx, dy, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int MsInputType;
|
||||
static Status
|
||||
MsInit (KdPointerInfo *pi)
|
||||
{
|
||||
if (!pi)
|
||||
return BadImplementation;
|
||||
|
||||
static int
|
||||
MsInit (void)
|
||||
if (!pi->path || strcmp(pi->path, "auto"))
|
||||
pi->path = KdSaveString("/dev/mouse");
|
||||
if (!pi->name)
|
||||
pi->name = KdSaveString("Microsoft protocol mouse");
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
static Status
|
||||
MsEnable (KdPointerInfo *pi)
|
||||
{
|
||||
int port;
|
||||
char *device = "/dev/mouse";
|
||||
struct termios t;
|
||||
int ret;
|
||||
|
||||
if (!MsInputType)
|
||||
MsInputType = KdAllocInputType ();
|
||||
port = open (device, O_RDWR | O_NONBLOCK);
|
||||
port = open (pi->path, O_RDWR | O_NONBLOCK);
|
||||
if(port < 0) {
|
||||
ErrorF("Couldn't open %s (%d)\n", device, (int)errno);
|
||||
ErrorF("Couldn't open %s (%d)\n", pi->path, (int)errno);
|
||||
return 0;
|
||||
} else if (port == 0) {
|
||||
ErrorF("Opening %s returned 0! Please complain to Keith.\n",
|
||||
device);
|
||||
pi->path);
|
||||
goto bail;
|
||||
}
|
||||
|
||||
if(!isatty(port)) {
|
||||
ErrorF("%s is not a tty\n", device);
|
||||
ErrorF("%s is not a tty\n", pi->path);
|
||||
goto bail;
|
||||
}
|
||||
|
||||
ret = tcgetattr(port, &t);
|
||||
if(ret < 0) {
|
||||
ErrorF("Couldn't tcgetattr(%s): %d\n", device, errno);
|
||||
ErrorF("Couldn't tcgetattr(%s): %d\n", pi->path, errno);
|
||||
goto bail;
|
||||
}
|
||||
t.c_iflag &= ~ (IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR |
|
||||
|
@ -140,24 +149,36 @@ MsInit (void)
|
|||
t.c_cc[VTIME] = 0;
|
||||
ret = tcsetattr(port, TCSANOW, &t);
|
||||
if(ret < 0) {
|
||||
ErrorF("Couldn't tcsetattr(%s): %d\n", device, errno);
|
||||
ErrorF("Couldn't tcsetattr(%s): %d\n", pi->path, errno);
|
||||
goto bail;
|
||||
}
|
||||
if (KdRegisterFd (MsInputType, port, MsRead, (void *) 0))
|
||||
return 1;
|
||||
if (KdRegisterFd (port, MsRead, pi))
|
||||
return TRUE;
|
||||
pi->driverPrivate = (void *)port;
|
||||
|
||||
return Success;
|
||||
|
||||
bail:
|
||||
close(port);
|
||||
return 0;
|
||||
return BadMatch;
|
||||
}
|
||||
|
||||
static void
|
||||
MsFini (void)
|
||||
MsDisable (KdPointerInfo *pi)
|
||||
{
|
||||
KdUnregisterFds (MsInputType, TRUE);
|
||||
KdUnregisterFd (pi, (int)pi->driverPrivate, TRUE);
|
||||
}
|
||||
|
||||
KdMouseFuncs MsMouseFuncs = {
|
||||
static void
|
||||
MsFini (KdPointerInfo *pi)
|
||||
{
|
||||
}
|
||||
|
||||
KdPointerDriver MsMouseDriver = {
|
||||
"ms",
|
||||
MsInit,
|
||||
MsFini
|
||||
MsEnable,
|
||||
MsDisable,
|
||||
MsFini,
|
||||
NULL,
|
||||
};
|
||||
|
|
|
@ -112,42 +112,78 @@ Ps2Read (int ps2Port, void *closure)
|
|||
dy = -dy;
|
||||
n -= 3;
|
||||
b += 3;
|
||||
KdEnqueueMouseEvent (kdMouseInfo, flags, dx, dy);
|
||||
KdEnqueuePointerEvent (closure, flags, dx, dy, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int Ps2InputType;
|
||||
|
||||
static int
|
||||
Ps2Init (void)
|
||||
static Status
|
||||
Ps2Init (KdPointerInfo *pi)
|
||||
{
|
||||
int i;
|
||||
int ps2Port;
|
||||
int n;
|
||||
int ps2Port, i;
|
||||
|
||||
if (!Ps2InputType)
|
||||
Ps2InputType = KdAllocInputType ();
|
||||
n = 0;
|
||||
for (i = 0; i < NUM_PS2_NAMES; i++)
|
||||
{
|
||||
ps2Port = open (Ps2Names[i], 0);
|
||||
if (ps2Port >= 0)
|
||||
{
|
||||
if (KdRegisterFd (Ps2InputType, ps2Port, Ps2Read, (void *) i))
|
||||
n++;
|
||||
if (!pi->path) {
|
||||
for (i = 0; i < NUM_PS2_NAMES; i++) {
|
||||
ps2Port = open (Ps2Names[i], 0);
|
||||
if (ps2Port >= 0) {
|
||||
pi->path = KdSaveString (Ps2Names[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return n;
|
||||
else {
|
||||
ps2Port = open (pi->path, 0);
|
||||
}
|
||||
|
||||
if (ps2Port < 0)
|
||||
return BadMatch;
|
||||
|
||||
close(ps2Port);
|
||||
if (!pi->name)
|
||||
pi->name = KdSaveString ("PS/2 Mouse");
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
static Status
|
||||
Ps2Enable (KdPointerInfo *pi)
|
||||
{
|
||||
int fd;
|
||||
|
||||
if (!pi)
|
||||
return BadImplementation;
|
||||
|
||||
fd = open (pi->path, 0);
|
||||
if (fd < 0)
|
||||
return BadMatch;
|
||||
|
||||
if (!KdRegisterFd (fd, Ps2Read, pi)) {
|
||||
close(fd);
|
||||
return BadAlloc;
|
||||
}
|
||||
|
||||
pi->driverPrivate = (void *)fd;
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
Ps2Disable (KdPointerInfo *pi)
|
||||
{
|
||||
KdUnregisterFd (pi, (int)pi->driverPrivate, TRUE);
|
||||
}
|
||||
|
||||
static void
|
||||
Ps2Fini (void)
|
||||
Ps2Fini (KdPointerInfo *pi)
|
||||
{
|
||||
KdUnregisterFds (Ps2InputType, TRUE);
|
||||
}
|
||||
|
||||
KdMouseFuncs Ps2MouseFuncs = {
|
||||
KdPointerDriver Ps2MouseDriver = {
|
||||
"ps2",
|
||||
Ps2Init,
|
||||
Ps2Fini
|
||||
Ps2Enable,
|
||||
Ps2Disable,
|
||||
Ps2Fini,
|
||||
NULL,
|
||||
};
|
||||
|
|
|
@ -75,7 +75,7 @@ TsReadBytes (int fd, char *buf, int len, int min)
|
|||
static void
|
||||
TsRead (int tsPort, void *closure)
|
||||
{
|
||||
KdMouseInfo *mi = closure;
|
||||
KdPointerInfo *pi = closure;
|
||||
TS_EVENT event;
|
||||
int n;
|
||||
long x, y;
|
||||
|
@ -117,7 +117,7 @@ TsRead (int tsPort, void *closure)
|
|||
lastx = 0;
|
||||
lasty = 0;
|
||||
}
|
||||
KdEnqueueMouseEvent (mi, flags, x, y);
|
||||
KdEnqueuePointerEvent (pi, flags, x, y, 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -129,95 +129,83 @@ char *TsNames[] = {
|
|||
|
||||
#define NUM_TS_NAMES (sizeof (TsNames) / sizeof (TsNames[0]))
|
||||
|
||||
int TsInputType;
|
||||
|
||||
static int
|
||||
TsEnable (int fd, void *closure)
|
||||
{
|
||||
KdMouseInfo *mi = (KdMouseInfo *)closure;
|
||||
|
||||
return open (mi->name, 0);
|
||||
}
|
||||
|
||||
static void
|
||||
TsDisable (int fd, void *closure)
|
||||
{
|
||||
close (fd);
|
||||
}
|
||||
|
||||
static int
|
||||
TsInit (void)
|
||||
static Status
|
||||
TsInit (KdPointerInfo *pi)
|
||||
{
|
||||
int i;
|
||||
int fd;
|
||||
KdMouseInfo *mi, *next;
|
||||
int n = 0;
|
||||
|
||||
if (!TsInputType)
|
||||
TsInputType = KdAllocInputType ();
|
||||
|
||||
for (mi = kdMouseInfo; mi; mi = next)
|
||||
{
|
||||
next = mi->next;
|
||||
if (mi->inputType)
|
||||
continue;
|
||||
if (!mi->name)
|
||||
{
|
||||
for (i = 0; i < NUM_TS_NAMES; i++)
|
||||
{
|
||||
fd = open (TsNames[i], 0);
|
||||
if (fd >= 0)
|
||||
{
|
||||
mi->name = KdSaveString (TsNames[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
fd = open (mi->name, 0);
|
||||
if (fd >= 0)
|
||||
{
|
||||
struct h3600_ts_calibration cal;
|
||||
/*
|
||||
* Check to see if this is a touch screen
|
||||
*/
|
||||
if (ioctl (fd, TS_GET_CAL, &cal) != -1)
|
||||
{
|
||||
mi->driver = (void *) fd;
|
||||
mi->inputType = TsInputType;
|
||||
if (KdRegisterFd (TsInputType, fd, TsRead, (void *) mi))
|
||||
{
|
||||
/* Set callbacks for vt switches etc */
|
||||
KdRegisterFdEnableDisable (fd, TsEnable, TsDisable);
|
||||
|
||||
n++;
|
||||
}
|
||||
}
|
||||
else
|
||||
close (fd);
|
||||
if (!pi->path || strcmp(pi->path, "auto") == 0) {
|
||||
for (i = 0; i < NUM_TS_NAMES; i++) {
|
||||
fd = open (TsNames[i], 0);
|
||||
if (fd >= 0) {
|
||||
pi->path = KdSaveString (TsNames[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
fd = open (pi->path, 0);
|
||||
}
|
||||
|
||||
return 0;
|
||||
if (fd < 0) {
|
||||
ErrorF("TsInit: Couldn't open %s\n", pi->path);
|
||||
return BadMatch;
|
||||
}
|
||||
close(fd);
|
||||
|
||||
pi->name = KdSaveString("H3600 Touchscreen");
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
static Status
|
||||
TsEnable (KdPointerInfo *pi)
|
||||
{
|
||||
int fd;
|
||||
|
||||
if (!pi || !pi->path)
|
||||
return BadImplementation;
|
||||
|
||||
fd = open(pi->path, 0);
|
||||
|
||||
if (fd < 0) {
|
||||
ErrorF("TsInit: Couldn't open %s\n", pi->path);
|
||||
return BadMatch;
|
||||
}
|
||||
|
||||
struct h3600_ts_calibration cal;
|
||||
/*
|
||||
* Check to see if this is a touch screen
|
||||
*/
|
||||
if (ioctl (fd, TS_GET_CAL, &cal) != -1) {
|
||||
mi->driverPrivate = (void *) fd;
|
||||
if (!KdRegisterFd (fd, TsRead, (void *) mi)) {
|
||||
close(fd);
|
||||
return BadAlloc;
|
||||
}
|
||||
}
|
||||
else {
|
||||
ErrorF("TsEnable: %s is not a touchscreen\n", pi->path);
|
||||
close (fd);
|
||||
return BadMatch;
|
||||
}
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
static void
|
||||
TsFini (void)
|
||||
TsFini (KdPointerInfo *pi)
|
||||
{
|
||||
KdMouseInfo *mi;
|
||||
|
||||
KdUnregisterFds (TsInputType, TRUE);
|
||||
for (mi = kdMouseInfo; mi; mi = mi->next)
|
||||
{
|
||||
if (mi->inputType == TsInputType)
|
||||
{
|
||||
mi->driver = 0;
|
||||
mi->inputType = 0;
|
||||
}
|
||||
}
|
||||
KdUnregisterFds (pi, (int)pi->driverPrivate, TRUE);
|
||||
mi->driverPrivate = NULL;
|
||||
}
|
||||
|
||||
KdMouseFuncs TsFuncs = {
|
||||
KdPointerDriver TsDriver = {
|
||||
TsInit,
|
||||
TsFini
|
||||
TsEnable,
|
||||
TsDisable,
|
||||
TsFini,
|
||||
NULL,
|
||||
};
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* $RCSId: xc/programs/Xserver/hw/kdrive/linux/tslib.c,v 1.1 2002/11/01 22:27:49 keithp Exp $
|
||||
* TSLIB based touchscreen driver for TinyX
|
||||
* TSLIB based touchscreen driver for KDrive
|
||||
* Porting to new input API and event queueing by Daniel Stone.
|
||||
* Derived from ts.c by Keith Packard
|
||||
* Derived from ps2.c by Jim Gettys
|
||||
*
|
||||
|
@ -8,66 +8,33 @@
|
|||
* Copyright © 2000 Compaq Computer Corporation
|
||||
* Copyright © 2002 MontaVista Software Inc.
|
||||
* Copyright © 2005 OpenedHand Ltd.
|
||||
* Copyright © 2006 Nokia Corporation
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of Keith Packard or Compaq not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. Keith Packard and Compaq makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
* documentation, and that the name of the authors and/or copyright holders
|
||||
* not be used in advertising or publicity pertaining to distribution of the
|
||||
* software without specific, written prior permission. The authors and/or
|
||||
* copyright holders make no representations about the suitability of this
|
||||
* software for any purpose. It is provided "as is" without express or
|
||||
* implied warranty.
|
||||
*
|
||||
* KEITH PACKARD AND COMPAQ DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
|
||||
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
|
||||
* IN NO EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of Michael Taht or MontaVista not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. Michael Taht and Montavista make no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* MICHAEL TAHT AND MONTAVISTA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
|
||||
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
|
||||
* IN NO EVENT SHALL EITHER BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of Matthew Allum or OpenedHand not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. Matthew Allum and OpenedHand make no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* MATTHEW ALLUM AND OPENEDHAND DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
|
||||
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
|
||||
* IN NO EVENT SHALL EITHER BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
* THE AUTHORS AND/OR COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD
|
||||
* TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||||
* AND FITNESS, IN NO EVENT SHALL THE AUTHORS AND/OR COPYRIGHT HOLDERS BE
|
||||
* LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#ifdef HAVE_KDRIVE_CONFIG_H
|
||||
#include <kdrive-config.h>
|
||||
#endif
|
||||
|
||||
#define NEED_EVENTS
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xproto.h>
|
||||
|
@ -77,186 +44,150 @@
|
|||
#include "kdrive.h"
|
||||
#include <sys/ioctl.h>
|
||||
#include <tslib.h>
|
||||
#include <dirent.h>
|
||||
#include <linux/input.h>
|
||||
|
||||
static struct tsdev *tsDev = NULL;
|
||||
|
||||
static char *TsNames[] = {
|
||||
NULL, /* set via TSLIB_TSDEVICE */
|
||||
"/dev/ts",
|
||||
"/dev/touchscreen/0",
|
||||
struct TslibPrivate {
|
||||
int fd;
|
||||
int lastx, lasty;
|
||||
struct tsdev *tsDev;
|
||||
void (*raw_event_hook)(int x, int y, int pressure, void *closure);
|
||||
void *raw_event_closure;
|
||||
int phys_screen;
|
||||
};
|
||||
|
||||
#define NUM_TS_NAMES (sizeof (TsNames) / sizeof (TsNames[0]))
|
||||
|
||||
/* For XCalibrate extension */
|
||||
void (*tslib_raw_event_hook)(int x, int y, int pressure, void *closure);
|
||||
void *tslib_raw_event_closure;
|
||||
|
||||
int TsInputType = 0;
|
||||
int KdTsPhyScreen = 0; /* XXX Togo .. */
|
||||
|
||||
static void
|
||||
TsRead (int tsPort, void *closure)
|
||||
TsRead (int fd, void *closure)
|
||||
{
|
||||
KdMouseInfo *mi = closure;
|
||||
struct ts_sample event;
|
||||
long x, y;
|
||||
unsigned long flags;
|
||||
KdPointerInfo *pi = closure;
|
||||
struct TslibPrivate *private = pi->driverPrivate;
|
||||
struct ts_sample event;
|
||||
long x = 0, y = 0;
|
||||
unsigned long flags;
|
||||
|
||||
if (tslib_raw_event_hook)
|
||||
{
|
||||
/* XCalibrate Ext */
|
||||
if (ts_read_raw(tsDev, &event, 1) == 1)
|
||||
{
|
||||
tslib_raw_event_hook (event.x,
|
||||
event.y,
|
||||
event.pressure,
|
||||
tslib_raw_event_closure);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
while (ts_read(tsDev, &event, 1) == 1)
|
||||
{
|
||||
flags = (event.pressure) ? KD_BUTTON_1 : 0;
|
||||
x = event.x;
|
||||
y = event.y;
|
||||
|
||||
KdEnqueueMouseEvent (mi, flags, x, y);
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
TsLibOpen(char *dev)
|
||||
{
|
||||
if(!(tsDev = ts_open(dev, 0)))
|
||||
return -1;
|
||||
|
||||
if (ts_config(tsDev))
|
||||
return -1;
|
||||
|
||||
return ts_fd(tsDev);
|
||||
}
|
||||
|
||||
static int
|
||||
TslibEnable (int not_needed_fd, void *closure)
|
||||
{
|
||||
KdMouseInfo *mi = closure;
|
||||
int fd = 0;
|
||||
|
||||
if ((fd = TsLibOpen(mi->name)) == -1)
|
||||
ErrorF ("Unable to re-enable TSLib ( on %s )", mi->name);
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
static void
|
||||
TslibDisable (int fd, void *closure)
|
||||
{
|
||||
if (tsDev)
|
||||
ts_close(tsDev);
|
||||
tsDev = NULL;
|
||||
}
|
||||
|
||||
static int
|
||||
TslibInit (void)
|
||||
{
|
||||
int i, j = 0;
|
||||
KdMouseInfo *mi, *next;
|
||||
int fd = 0;
|
||||
int req_type;
|
||||
|
||||
if (!TsInputType)
|
||||
{
|
||||
TsInputType = KdAllocInputType ();
|
||||
KdParseMouse(0); /* allocate safe slot in kdMouseInfo */
|
||||
req_type = 0;
|
||||
if (private->raw_event_hook) {
|
||||
while (ts_read_raw(private->tsDev, &event, 1) == 1)
|
||||
private->raw_event_hook (event.x, event.y, event.pressure,
|
||||
private->raw_event_closure);
|
||||
return;
|
||||
}
|
||||
else req_type = TsInputType; /* is being re-inited */
|
||||
|
||||
for (mi = kdMouseInfo; mi; mi = next)
|
||||
{
|
||||
next = mi->next;
|
||||
|
||||
/* find a usuable slot */
|
||||
if (mi->inputType != req_type)
|
||||
continue;
|
||||
|
||||
/* Check for tslib env var device setting */
|
||||
if ((TsNames[0] = getenv("TSLIB_TSDEVICE")) == NULL)
|
||||
j++;
|
||||
|
||||
if (!mi->name)
|
||||
{
|
||||
for (i = j; i < NUM_TS_NAMES; i++)
|
||||
{
|
||||
fd = TsLibOpen(TsNames[i]);
|
||||
|
||||
if (fd >= 0)
|
||||
{
|
||||
mi->name = KdSaveString (TsNames[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
fd = TsLibOpen(mi->name);
|
||||
|
||||
if (fd >= 0 && tsDev != NULL)
|
||||
{
|
||||
mi->driver = (void *) fd;
|
||||
mi->inputType = TsInputType;
|
||||
|
||||
KdRegisterFd (TsInputType, fd, TsRead, (void *) mi);
|
||||
|
||||
/* Set callbacks for vt switches etc */
|
||||
KdRegisterFdEnableDisable (fd, TslibEnable, TslibDisable);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
ErrorF ("Failed to open TSLib device, tried ");
|
||||
for (i = j; i < NUM_TS_NAMES; i++)
|
||||
ErrorF ("%s ", TsNames[i]);
|
||||
ErrorF (".\n");
|
||||
if (!TsNames[0])
|
||||
ErrorF ("Try setting TSLIB_TSDEVICE to valid /dev entry?\n");
|
||||
|
||||
if (fd > 0)
|
||||
close(fd);
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static void
|
||||
TslibFini (void)
|
||||
{
|
||||
KdMouseInfo *mi;
|
||||
while (ts_read(private->tsDev, &event, 1) == 1) {
|
||||
if (event.pressure) {
|
||||
flags = KD_BUTTON_1;
|
||||
|
||||
KdUnregisterFds (TsInputType, TRUE);
|
||||
for (mi = kdMouseInfo; mi; mi = mi->next)
|
||||
{
|
||||
if (mi->inputType == TsInputType)
|
||||
{
|
||||
if(mi->driver)
|
||||
{
|
||||
ts_close(tsDev);
|
||||
tsDev = NULL;
|
||||
}
|
||||
mi->driver = 0;
|
||||
/*
|
||||
* Here we test for the touch screen driver actually being on the
|
||||
* touch screen, if it is we send absolute coordinates. If not,
|
||||
* then we send delta's so that we can track the entire vga screen.
|
||||
*/
|
||||
if (KdCurScreen == private->phys_screen) {
|
||||
x = event.x;
|
||||
y = event.y;
|
||||
} else {
|
||||
flags |= KD_MOUSE_DELTA;
|
||||
if ((private->lastx == 0) || (private->lasty == 0)) {
|
||||
x = event.x;
|
||||
y = event.y;
|
||||
} else {
|
||||
x = event.x - private->lastx;
|
||||
y = event.y - private->lasty;
|
||||
}
|
||||
}
|
||||
private->lastx = x;
|
||||
private->lasty = y;
|
||||
} else {
|
||||
flags = 0;
|
||||
x = private->lastx;
|
||||
y = private->lasty;
|
||||
}
|
||||
|
||||
/* If below is set to 0, then MouseInit() will trash it,
|
||||
* setting to 'mouse type' ( via server reset). Therefore
|
||||
* Leave it alone and work around in TslibInit() ( see
|
||||
* req_type ).
|
||||
*/
|
||||
/* mi->inputType = 0; */
|
||||
}
|
||||
KdEnqueuePointerEvent (pi, flags, x, y, event.pressure);
|
||||
}
|
||||
}
|
||||
|
||||
KdMouseFuncs TsFuncs = {
|
||||
static Status
|
||||
TslibEnable (KdPointerInfo *pi)
|
||||
{
|
||||
struct TslibPrivate *private = pi->driverPrivate;
|
||||
|
||||
private->raw_event_hook = NULL;
|
||||
private->raw_event_closure = NULL;
|
||||
private->tsDev = ts_open(pi->path, 0);
|
||||
private->fd = ts_fd(private->tsDev);
|
||||
if (!private->tsDev || ts_config(private->tsDev) || private->fd < 0) {
|
||||
ErrorF("[tslib/TslibEnable] failed to open %s\n", pi->path);
|
||||
if (private->fd > 0);
|
||||
close(private->fd);
|
||||
return BadAlloc;
|
||||
}
|
||||
|
||||
KdRegisterFd(private->fd, TsRead, pi);
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
TslibDisable (KdPointerInfo *pi)
|
||||
{
|
||||
struct TslibPrivate *private = pi->driverPrivate;
|
||||
|
||||
if (private->fd)
|
||||
KdUnregisterFd(pi, private->fd, TRUE);
|
||||
|
||||
if (private->tsDev)
|
||||
ts_close(private->tsDev);
|
||||
|
||||
private->fd = 0;
|
||||
private->tsDev = NULL;
|
||||
}
|
||||
|
||||
|
||||
static Status
|
||||
TslibInit (KdPointerInfo *pi)
|
||||
{
|
||||
int fd = 0, i = 0;
|
||||
DIR *inputdir = NULL;
|
||||
struct dirent *inputent = NULL;
|
||||
struct tsdev *tsDev = NULL;
|
||||
struct TslibPrivate *private = NULL;
|
||||
|
||||
if (!pi || !pi->dixdev)
|
||||
return !Success;
|
||||
|
||||
pi->driverPrivate = (struct TslibPrivate *)
|
||||
xcalloc(sizeof(struct TslibPrivate), 1);
|
||||
if (!pi->driverPrivate)
|
||||
return !Success;
|
||||
|
||||
private = pi->driverPrivate;
|
||||
/* hacktastic */
|
||||
private->phys_screen = 0;
|
||||
pi->nAxes = 3;
|
||||
pi->name = KdSaveString("Touchscreen");
|
||||
pi->inputClass = KD_TOUCHSCREEN;
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
TslibFini (KdPointerInfo *pi)
|
||||
{
|
||||
if (pi->driverPrivate) {
|
||||
xfree(pi->driverPrivate);
|
||||
pi->driverPrivate = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
KdPointerDriver TsDriver = {
|
||||
"tslib",
|
||||
TslibInit,
|
||||
TslibFini
|
||||
TslibEnable,
|
||||
TslibDisable,
|
||||
TslibFini,
|
||||
NULL,
|
||||
};
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user