xserver: Branch 'input-hotplug' - 8 commits
Daniel Stone
daniels at kemper.freedesktop.org
Thu Aug 10 14:15:19 EEST 2006
GL/glx/glxdri.c | 10 ---
dix/devices.c | 5 +
dix/events.c | 119 ++++++++++++++++++++-----------------
hw/kdrive/src/kinput.c | 27 ++++----
hw/xfree86/common/xf86AutoConfig.c | 1
hw/xfree86/common/xf86Xinput.c | 75 ++++++++++++-----------
include/input.h | 8 +-
os/utils.c | 1
8 files changed, 132 insertions(+), 114 deletions(-)
New commits:
diff-tree 172d45b9b75f95c997d1e9358040eead496e2a06 (from parents)
Merge: 3832a3d7db0f3b5d7167e3b3b5ea6d6b3d96351a db82e12fac5eaa16a39fc1bd0bc31ad95089dc95
Author: Daniel Stone <daniel at fooishbar.org>
Date: Thu Aug 10 14:14:54 2006 +0300
Merge branch 'master' of git+ssh://git.freedesktop.org/git/xorg/xserver into input-hotplug
diff-tree 3832a3d7db0f3b5d7167e3b3b5ea6d6b3d96351a (from 9f188416bb6b4837d4c3f8773053d5eee0ff0ee1)
Author: Daniel Stone <daniel at fooishbar.org>
Date: Thu Aug 10 14:13:51 2006 +0300
GKVE: don't repeat modifiers when using XKB
Make sure we don't ever repeat modifiers (previously was repeating when
using XKB); only do explicit KP/KR repeats in the non-XKB case. XKB will
take care of repeating when we're using it.
diff --git a/dix/events.c b/dix/events.c
index 5706aac..171e277 100644
--- a/dix/events.c
+++ b/dix/events.c
@@ -4737,20 +4737,22 @@ int GetKeyboardValuatorEvents(xEvent *ev
* FIXME: In theory, if you're repeating with two keyboards,
* you could get unbalanced events here. */
if (type == KeyPress &&
- ((pDev->key->down[key_code >> 3] & (key_code & 7)) & 1)
-#ifdef XKB
- && noXkbExtension
-#endif
- ) {
+ ((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;
- numEvents += GetKeyboardValuatorEvents(events, pDev,
- KeyRelease, key_code,
- num_valuators, valuators);
- events += numEvents;
+
+#ifdef XKB
+ if (noXkbExtension)
+#endif
+ {
+ numEvents += GetKeyboardValuatorEvents(events, pDev,
+ KeyRelease, key_code,
+ num_valuators, valuators);
+ events += numEvents;
+ }
}
ms = GetTimeInMillis();
diff-tree 9f188416bb6b4837d4c3f8773053d5eee0ff0ee1 (from 539d1f33475484d35fb5a377efc76dba2d868e3f)
Author: Daniel Stone <daniel at fooishbar.org>
Date: Thu Aug 10 14:00:34 2006 +0300
core devices: clear devicePrivates on close
diff --git a/dix/devices.c b/dix/devices.c
index 69f1e7b..63b206a 100644
--- a/dix/devices.c
+++ b/dix/devices.c
@@ -270,6 +270,7 @@ CoreKeyboardProc(DeviceIntPtr pDev, int
* ... yeah.
*/
pDev->key->xkbInfo = NULL;
+ pDev->devPrivates[CoreDevicePrivatesIndex].ptr = NULL;
break;
default:
@@ -298,6 +299,10 @@ CorePointerProc(DeviceIntPtr pDev, int w
pDev->valuator->lasty = pDev->valuator->axisVal[1];
break;
+ case DEVICE_CLOSE:
+ pDev->devPrivates[CoreDevicePrivatesIndex].ptr = NULL;
+ break;
+
default:
break;
}
diff-tree 539d1f33475484d35fb5a377efc76dba2d868e3f (from 5506b4ad200745236f997c121e8200179c47b749)
Author: Daniel Stone <daniel at fooishbar.org>
Date: Thu Aug 10 14:00:14 2006 +0300
GKVE/GPE: have DDX allocate events
Don't allocate events on every GKE/GKVE/GPE call, just have the DDX manage
it instead. Introduce GetMaximumEventsNum(), which is the maximum number
of events these functions will ever produce.
diff --git a/dix/events.c b/dix/events.c
index f0b9e16..5706aac 100644
--- a/dix/events.c
+++ b/dix/events.c
@@ -4658,22 +4658,39 @@ WriteEventsToClient(ClientPtr pClient, i
}
}
+/* Maximum number of valuators, divided by six, rounded up. */
+#define MAX_VALUATOR_EVENTS 6
+
+/**
+ * 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());
+ */
+int
+GetMaximumEventsNum() {
+ /* Two base events -- core and device, plus valuator events. Multiply
+ * by two if we're doing key repeats. */
+ return 2 * (2 + MAX_VALUATOR_EVENTS);
+}
+
/**
* Convenience wrapper around GetKeyboardValuatorEvents, that takes no
* valuators.
*/
int
-GetKeyboardEvents(xEvent **xE, DeviceIntPtr pDev, int type, int key_code) {
- return GetKeyboardValuatorEvents(xE, pDev, type, key_code, 0, NULL);
+GetKeyboardEvents(xEvent *events, DeviceIntPtr pDev, int type, int key_code) {
+ return GetKeyboardValuatorEvents(events, pDev, type, key_code, 0, NULL);
}
/**
* Returns a set of keyboard events for KeyPress/KeyRelease, optionally
* also with valuator events. Handles Xi and XKB.
*
- * xE will be set to an array of events, which must be freed by the user;
- * the return value is the number of events in xE, which is not
- * NULL-terminated.
+ * 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.
*
* If pDev is set to send core events, then the keymap on the core
* keyboard will be pivoted to that of the new keyboard and the appropriate
@@ -4683,18 +4700,21 @@ GetKeyboardEvents(xEvent **xE, DeviceInt
* key press will trigger a matching KeyRelease, as well as the
* KeyPresses.
*/
-int GetKeyboardValuatorEvents(xEvent **xE, DeviceIntPtr pDev, int type,
+int GetKeyboardValuatorEvents(xEvent *events, DeviceIntPtr pDev, int type,
int key_code, int num_valuators,
int *valuators) {
int numEvents = 0, numRepeatEvents = 0, ms = 0, first_valuator = 0, i = 0;
deviceKeyButtonPointer *kbp = NULL;
deviceValuator *xv = NULL;
- xEvent *ev = NULL, *repeatEvents = NULL;
+ xEvent *repeatEvents = NULL;
KeyClassPtr ckeyc;
#ifdef XKB
xkbMapNotify mn;
#endif
+ if (!events)
+ return 0;
+
if (type != KeyPress && type != KeyRelease)
return 0;
@@ -4707,8 +4727,11 @@ int GetKeyboardValuatorEvents(xEvent **x
else
numEvents = 1;
- if (num_valuators)
- numEvents += (num_valuators % 6) + 1;
+ if (num_valuators) {
+ if ((num_valuators / 6) + 1 > MAX_VALUATOR_EVENTS)
+ num_valuators = MAX_VALUATOR_EVENTS;
+ numEvents += (num_valuators / 6) + 1;
+ }
/* Handle core repeating, via press/release/press/release.
* FIXME: In theory, if you're repeating with two keyboards,
@@ -4724,26 +4747,15 @@ int GetKeyboardValuatorEvents(xEvent **x
!(pDev->kbdfeed->ctrl.autoRepeats[key_code >> 3]
& (1 << (key_code & 7))))
return 0;
- numEvents += GetKeyboardValuatorEvents(&repeatEvents, pDev,
+ numEvents += GetKeyboardValuatorEvents(events, pDev,
KeyRelease, key_code,
num_valuators, valuators);
+ events += numEvents;
}
- ev = (xEvent *)xcalloc(sizeof(xEvent), numEvents);
- if (!ev)
- return 0;
-
- if (repeatEvents) {
- for (i = 0; i < numRepeatEvents; i++) {
- ev = repeatEvents++;
- ev++;
- }
- }
-
- *xE = ev;
ms = GetTimeInMillis();
- kbp = (deviceKeyButtonPointer *) ev;
+ kbp = (deviceKeyButtonPointer *) events;
kbp->time = ms;
kbp->deviceid = pDev->id;
if (type == KeyPress)
@@ -4754,7 +4766,7 @@ int GetKeyboardValuatorEvents(xEvent **x
if (num_valuators) {
kbp->deviceid |= MORE_EVENTS;
while (first_valuator < num_valuators) {
- xv = (deviceValuator *) ++ev;
+ xv = (deviceValuator *) ++events;
xv->type = DeviceValuator;
xv->first_valuator = first_valuator;
xv->num_valuators = num_valuators;
@@ -4781,10 +4793,10 @@ int GetKeyboardValuatorEvents(xEvent **x
}
if (pDev->coreEvents) {
- ev++;
- ev->u.keyButtonPointer.time = ms;
- ev->u.u.type = type;
- ev->u.u.detail = key_code;
+ events++;
+ events->u.keyButtonPointer.time = ms;
+ events->u.u.type = type;
+ events->u.u.detail = key_code;
if (inputInfo.keyboard->devPrivates[CoreDevicePrivatesIndex].ptr !=
pDev) {
@@ -4796,8 +4808,6 @@ int GetKeyboardValuatorEvents(xEvent **x
memcpy(ckeyc->modifierKeyMap, pDev->key->modifierKeyMap,
(8 * pDev->key->maxKeysPerModifier));
ckeyc->maxKeysPerModifier = pDev->key->maxKeysPerModifier;
- ckeyc->curKeySyms.map = NULL;
- ckeyc->curKeySyms.mapWidth = 0;
ckeyc->curKeySyms.minKeyCode = pDev->key->curKeySyms.minKeyCode;
ckeyc->curKeySyms.maxKeyCode = pDev->key->curKeySyms.maxKeyCode;
SetKeySymsMap(&ckeyc->curKeySyms, &pDev->key->curKeySyms);
@@ -4911,13 +4921,14 @@ acceleratePointer(DeviceIntPtr pDev, int
* Generate a series of xEvents (returned in xE) representing pointer
* motion, or button presses. Xi and XKB-aware.
*
- * xE is not NULL-terminated; the return value is the number of events.
- * The user is responsible for freeing these events.
+ * 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.
*/
int
-GetPointerEvents(xEvent **xE, DeviceIntPtr pDev, int type, int buttons,
+GetPointerEvents(xEvent *events, DeviceIntPtr pDev, int type, int buttons,
int flags, int num_valuators, int *valuators) {
- int numEvents, ms, first_valuator = 0;
+ int numEvents = 0, ms = 0, first_valuator = 0;
deviceKeyButtonPointer *kbp = NULL;
deviceValuator *xv = NULL;
AxisInfoPtr axes = NULL;
@@ -4942,20 +4953,18 @@ GetPointerEvents(xEvent **xE, DeviceIntP
numEvents = 1;
if (type == MotionNotify) {
- if (num_valuators > 2)
+ if (num_valuators > 2) {
+ if (((num_valuators / 6) + 1) > MAX_VALUATOR_EVENTS)
+ num_valuators = MAX_VALUATOR_EVENTS;
numEvents += (num_valuators / 6) + 1;
+ }
else if (num_valuators < 2)
return 0;
}
- ev = (xEvent *)xcalloc(sizeof(xEvent), numEvents);
- if (!ev)
- return 0;
-
- *xE = ev;
ms = GetTimeInMillis();
- kbp = (deviceKeyButtonPointer *) ev;
+ kbp = (deviceKeyButtonPointer *) events;
kbp->time = ms;
kbp->deviceid = pDev->id;
@@ -5053,7 +5062,7 @@ GetPointerEvents(xEvent **xE, DeviceIntP
flags & POINTER_ABSOLUTE)) {
kbp->deviceid |= MORE_EVENTS;
while (first_valuator < num_valuators) {
- xv = (deviceValuator *) ++ev;
+ xv = (deviceValuator *) ++events;
xv->type = DeviceValuator;
xv->first_valuator = first_valuator;
xv->num_valuators = num_valuators;
@@ -5086,11 +5095,11 @@ GetPointerEvents(xEvent **xE, DeviceIntP
}
if (pDev->coreEvents) {
- ev++;
- ev->u.u.type = type;
- ev->u.keyButtonPointer.time = ms;
- ev->u.keyButtonPointer.rootX = kbp->root_x;
- ev->u.keyButtonPointer.rootY = kbp->root_y;
+ events++;
+ events->u.u.type = type;
+ events->u.keyButtonPointer.time = ms;
+ events->u.keyButtonPointer.rootX = kbp->root_x;
+ events->u.keyButtonPointer.rootY = kbp->root_y;
cp->valuator->lastx = kbp->root_x;
cp->valuator->lasty = kbp->root_y;
#ifdef DEBUG
@@ -5101,10 +5110,10 @@ GetPointerEvents(xEvent **xE, DeviceIntP
ErrorF("GPE: core detail is %d\n", buttons);
#endif
/* Core buttons remapping shouldn't be transitive. */
- ev->u.u.detail = pDev->button->map[buttons];
+ events->u.u.detail = pDev->button->map[buttons];
}
else {
- ev->u.u.detail = 0;
+ events->u.u.detail = 0;
}
if (inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr !=
diff --git a/hw/kdrive/src/kinput.c b/hw/kdrive/src/kinput.c
index 1718fda..fc4592a 100644
--- a/hw/kdrive/src/kinput.c
+++ b/hw/kdrive/src/kinput.c
@@ -69,6 +69,8 @@ static struct KdConfigDevice *kdConfigPo
static KdKeyboardDriver *kdKeyboardDrivers = NULL;
static KdPointerDriver *kdPointerDrivers = NULL;
+static xEvent *kdEvents = NULL;
+
static Bool kdInputEnabled;
static Bool kdOffScreen;
static unsigned long kdOffScreenTime;
@@ -1271,6 +1273,11 @@ KdInitInput (void)
ErrorF("Failed to add keyboard!\n");
}
+ if (!kdEvents)
+ kdEvents = (xEvent *)xcalloc(sizeof(xEvent), GetMaximumEventsNum());
+ if (!kdEvents)
+ FatalError("Couldn't allocate event buffer\n");
+
mieqInit();
}
@@ -1849,7 +1856,6 @@ KdHandleKeyboardEvent (KdKeyboardInfo *k
void
KdReleaseAllKeys (void)
{
- xEvent *xE;
int key, nEvents, i;
KdKeyboardInfo *ki;
@@ -1860,9 +1866,9 @@ KdReleaseAllKeys (void)
key++) {
if (IsKeyDown(ki, key)) {
KdHandleKeyboardEvent(ki, KeyRelease, key);
- nEvents = GetKeyboardEvents(&xE, ki->dixdev, KeyRelease, key);
+ nEvents = GetKeyboardEvents(kdEvents, ki->dixdev, KeyRelease, key);
for (i = 0; i < nEvents; i++)
- KdQueueEvent (xE++);
+ KdQueueEvent (kdEvents + i);
}
}
}
@@ -1897,7 +1903,6 @@ KdEnqueueKeyboardEvent(KdKeyboardInfo
KeyClassPtr keyc = NULL;
KeybdCtrl *ctrl = NULL;
int type, nEvents, i;
- xEvent *xE = NULL;
#ifdef DEBUG
ErrorF("enqueuing kb event (scancode %d, %s)\n", scan_code, is_up ? "up" : "down");
@@ -1939,12 +1944,12 @@ KdEnqueueKeyboardEvent(KdKeyboardInfo
KdCheckSpecialKeys(ki, type, key_code);
KdHandleKeyboardEvent(ki, type, key_code);
- nEvents = GetKeyboardEvents(&xE, ki->dixdev, type, key_code);
+ nEvents = GetKeyboardEvents(kdEvents, ki->dixdev, type, key_code);
#ifdef DEBUG
ErrorF("KdEnqueueKeyboardEvent: got %d events from GKE\n", nEvents);
#endif
for (i = 0; i < nEvents; i++)
- KdQueueEvent(xE++);
+ KdQueueEvent(kdEvents + i);
}
else {
ErrorF("driver %s wanted to post scancode %d outside of [%d, %d]!\n",
@@ -2047,8 +2052,7 @@ void
_KdEnqueuePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z,
int b, int absrel, Bool force)
{
- xEvent *xE = NULL;
- int n = 0, i = 0;
+ int nEvents = 0, i = 0;
int valuators[3] = { x, y, z };
#ifdef DEBUG
@@ -2060,9 +2064,10 @@ _KdEnqueuePointerEvent (KdPointerInfo *p
if (!force && KdHandlePointerEvent(pi, type, x, y, z, b, absrel))
return;
- n = GetPointerEvents(&xE, pi->dixdev, type, b, absrel, 3, valuators);
- for (i = 0; i < n; i++)
- KdQueueEvent(xE++);
+ nEvents = GetPointerEvents(kdEvents, pi->dixdev, type, b, absrel, 3,
+ valuators);
+ for (i = 0; i < nEvents; i++)
+ KdQueueEvent(kdEvents + i);
}
void
diff --git a/hw/xfree86/common/xf86Xinput.c b/hw/xfree86/common/xf86Xinput.c
index 91db82e..070645d 100644
--- a/hw/xfree86/common/xf86Xinput.c
+++ b/hw/xfree86/common/xf86Xinput.c
@@ -108,6 +108,8 @@ static int debug_level = 0;
#define DBG(lvl, f)
#endif
+static xEvent *xf86Events = NULL;
+
static Bool
xf86SendDragEvents(DeviceIntPtr device)
{
@@ -639,7 +641,6 @@ xf86PostMotionEvent(DeviceIntPtr device,
int i = 0, nevents = 0;
Bool drag = xf86SendDragEvents(device);
LocalDevicePtr local = (LocalDevicePtr) device->public.devicePrivate;
- xEvent *events = NULL;
int *valuators = NULL;
int flags = 0;
@@ -662,15 +663,16 @@ xf86PostMotionEvent(DeviceIntPtr device,
#endif
}
- nevents = GetPointerEvents(&events, device, MotionNotify, 0,
+ if (!xf86Events)
+ xf86Events = (xEvent *)xcalloc(sizeof(xEvent), GetMaximumEventsNum());
+ if (!xf86Events)
+ FatalError("Couldn't allocate event store\n");
+
+ nevents = GetPointerEvents(xf86Events, device, MotionNotify, 0,
flags, num_valuators, valuators);
- for (i = 0; i < nevents; i++) {
- if (events->u.keyButtonPointer.time > xf86Info.lastEventTime)
- xf86Info.lastEventTime = events->u.keyButtonPointer.time;
- mieqEnqueue(events + i);
- }
- xfree(events);
+ for (i = 0; i < nevents; i++)
+ mieqEnqueue(xf86Events + i);
#if 0
if (HAS_MOTION_HISTORY(local)) {
@@ -791,7 +793,6 @@ xf86PostButtonEvent(DeviceIntPtr device,
va_list var;
int *valuators = NULL;
int i = 0, nevents = 0;
- xEvent *events = NULL;
#ifdef DEBUG
ErrorF("xf86PostButtonEvent BEGIN 0x%x(%s) button=%d down=%s is_absolute=%s\n",
@@ -810,18 +811,19 @@ xf86PostButtonEvent(DeviceIntPtr device,
valuators[i] = va_arg(var, int);
}
- nevents = GetPointerEvents(&events, device,
+ if (!xf86Events)
+ xf86Events = (xEvent *)xcalloc(sizeof(xEvent), GetMaximumEventsNum());
+ if (!xf86Events)
+ FatalError("Couldn't allocate event store\n");
+
+ nevents = GetPointerEvents(xf86Events, device,
is_down ? ButtonPress : ButtonRelease, button,
is_absolute ? POINTER_ABSOLUTE :
POINTER_RELATIVE,
num_valuators, valuators);
- for (i = 0; i < nevents; i++) {
- if (events->u.keyButtonPointer.time > xf86Info.lastEventTime)
- xf86Info.lastEventTime = events->u.keyButtonPointer.time;
- mieqEnqueue(events + i);
- }
- xfree(events);
+ for (i = 0; i < nevents; i++)
+ mieqEnqueue(xf86Events + i);
}
_X_EXPORT void
@@ -835,38 +837,39 @@ xf86PostKeyEvent(DeviceIntPtr device,
{
va_list var;
int i = 0, nevents = 0, *valuators = NULL;
- xEvent *events = NULL;
/* instil confidence in the user */
ErrorF("this function has never been tested properly. if things go quite "
"badly south after this message, then xf86PostKeyEvent is "
"broken.\n");
+ if (!xf86Events)
+ xf86Events = (xEvent *)xcalloc(sizeof(xEvent), GetMaximumEventsNum());
+ if (!xf86Events)
+ FatalError("Couldn't allocate event store\n");
+
/* the spec says that dkp/dkr events should only get valuators in
* absolute mode. the spec knows all. BOW BEFORE etc. */
if (is_absolute) {
- nevents = GetKeyboardValuatorEvents(&events, device,
- is_down ? KeyPress : KeyRelease,
- key_code, num_valuators,
- valuators);
valuators = xcalloc(sizeof(int), num_valuators);
va_start(var, num_valuators);
for (i = 0; i < num_valuators; i++)
valuators[i] = va_arg(var, int);
va_end(var);
+
+ nevents = GetKeyboardValuatorEvents(xf86Events, device,
+ is_down ? KeyPress : KeyRelease,
+ key_code, num_valuators,
+ valuators);
}
else {
- nevents = GetKeyboardEvents(&events, device,
+ nevents = GetKeyboardEvents(xf86Events, device,
is_down ? KeyPress : KeyRelease,
key_code);
}
- for (i = 0; i < nevents; i++) {
- if (events->u.keyButtonPointer.time > xf86Info.lastEventTime)
- xf86Info.lastEventTime = events->u.keyButtonPointer.time;
- mieqEnqueue(events + i);
- }
- xfree(events);
+ for (i = 0; i < nevents; i++)
+ mieqEnqueue(xf86Events + i);
}
_X_EXPORT void
@@ -874,7 +877,6 @@ xf86PostKeyboardEvent(DeviceIntPtr
unsigned int key_code,
int is_down)
{
- xEvent *events = NULL;
int nevents = 0, i = 0;
#ifdef DEBUG
@@ -882,15 +884,16 @@ xf86PostKeyboardEvent(DeviceIntPtr
is_down ? "down" : "up", device->id);
#endif
- nevents = GetKeyboardEvents(&events, device,
+ if (!xf86Events)
+ xf86Events = (xEvent *)xcalloc(sizeof(xEvent), GetMaximumEventsNum());
+ if (!xf86Events)
+ FatalError("Couldn't allocate event store\n");
+
+ nevents = GetKeyboardEvents(xf86Events, device,
is_down ? KeyPress : KeyRelease, key_code);
- for (i = 0; i < nevents; i++) {
- if (events->u.keyButtonPointer.time > xf86Info.lastEventTime)
- xf86Info.lastEventTime = events->u.keyButtonPointer.time;
- mieqEnqueue(events + i);
- }
- xfree(events);
+ for (i = 0; i < nevents; i++)
+ mieqEnqueue(xf86Events + i);
}
/*
diff --git a/include/input.h b/include/input.h
index d1791e7..6572db5 100644
--- a/include/input.h
+++ b/include/input.h
@@ -377,8 +377,10 @@ extern void InitInput(
int /*argc*/,
char ** /*argv*/);
+extern int GetMaximumEventsNum(void);
+
extern int GetPointerEvents(
- xEvent **xE,
+ xEvent *events,
DeviceIntPtr pDev,
int type,
int buttons,
@@ -387,13 +389,13 @@ extern int GetPointerEvents(
int *valuators);
extern int GetKeyboardEvents(
- xEvent **xE,
+ xEvent *events,
DeviceIntPtr pDev,
int type,
int key_code);
extern int GetKeyboardValuatorEvents(
- xEvent **xE,
+ xEvent *events,
DeviceIntPtr pDev,
int type,
int key_code,
diff-tree db82e12fac5eaa16a39fc1bd0bc31ad95089dc95 (from fcd4167e8913f77bdf9e17a6955d0f2a9f4eeb10)
Author: Adam Jackson <ajax at benzedrine.nwnk.net>
Date: Wed Aug 9 14:55:17 2006 -0400
Remove TargetRefresh option from the autoconfig logic.
The default target of 75Hz is almost always wrong for LCDs.
diff --git a/hw/xfree86/common/xf86AutoConfig.c b/hw/xfree86/common/xf86AutoConfig.c
index 37cf52e..4dcc997 100644
--- a/hw/xfree86/common/xf86AutoConfig.c
+++ b/hw/xfree86/common/xf86AutoConfig.c
@@ -71,7 +71,6 @@
#define BUILTIN_MONITOR_SECTION \
"Section \"Monitor\"\n" \
"\tIdentifier\t" BUILTIN_MONITOR_NAME "\n" \
- "\tOption\t\"TargetRefresh\"\t\"75.0\"\n" \
"EndSection\n\n"
#define BUILTIN_SCREEN_NAME \
diff-tree fcd4167e8913f77bdf9e17a6955d0f2a9f4eeb10 (from 767f372dd02232469f9fd804b811a17eaf762e1e)
Author: Adam Jackson <ajax at benzedrine.nwnk.net>
Date: Wed Aug 9 14:48:51 2006 -0400
Remove the bc flag from the -help text, since it's gone.
diff --git a/os/utils.c b/os/utils.c
index 7a4bd11..b15700f 100644
--- a/os/utils.c
+++ b/os/utils.c
@@ -580,7 +580,6 @@ void UseMsg(void)
#endif
ErrorF("-audit int set audit trail level\n");
ErrorF("-auth file select authorization file\n");
- ErrorF("bc enable bug compatibility\n");
ErrorF("-br create root window with black background\n");
ErrorF("+bs enable any backing store support\n");
ErrorF("-bs disable any backing store support\n");
diff-tree 767f372dd02232469f9fd804b811a17eaf762e1e (from parents)
Merge: c4f5de6cc3b935025829af971b0b8010c1ecfedb 462bb61b0fe968fae1b99cf98ec6f7de09105dcd
Author: Tilman Sauerbeck <tilman at code-monkey.de>
Date: Wed Aug 9 20:23:30 2006 +0200
Merge branch 'master' of git+ssh://git.freedesktop.org/git/xorg/xserver
diff-tree c4f5de6cc3b935025829af971b0b8010c1ecfedb (from 12dbd8a02f797ad57a1be683a02a1fcb1ca35438)
Author: Tilman Sauerbeck <tilman at code-monkey.de>
Date: Wed Aug 9 20:21:52 2006 +0200
Sanitized glxdri's Block/Wakeuphandler calling.
__glXDRIleaveServer() and _enterServer() used to call DRIDoBlockHandler
(resp DRIDoWakeupHandler) directly. They are now calling DRIBlockHandler
(resp DRIWakeupHandler) to account for driver specific block/wakeup
hooks.
diff --git a/GL/glx/glxdri.c b/GL/glx/glxdri.c
index 6a10554..cfa9996 100644
--- a/GL/glx/glxdri.c
+++ b/GL/glx/glxdri.c
@@ -137,19 +137,13 @@ static const char CREATE_NEW_SCREEN_FUNC
static void
__glXDRIleaveServer(void)
{
- int i;
-
- for (i = 0; i < screenInfo.numScreens; i++)
- DRIDoBlockHandler(i, NULL, NULL, NULL);
+ DRIBlockHandler(NULL, NULL, NULL);
}
static void
__glXDRIenterServer(void)
{
- int i;
-
- for (i = 0; i < screenInfo.numScreens; i++)
- DRIDoWakeupHandler(i, NULL, 0, NULL);
+ DRIWakeupHandler(NULL, 0, NULL);
}
static void
More information about the xorg-commit
mailing list