Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/xorg-server/patches/xorg-server-1.17.1-dix-add-unaccelerated-valuators-to-the-valuatormask.patch

    Contents of /trunk/xorg-server/patches/xorg-server-1.17.1-dix-add-unaccelerated-valuators-to-the-valuatormask.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 2576 - (show annotations) (download)
    Mon Jun 15 13:02:17 2015 UTC (8 years, 10 months ago) by niro
    File size: 7618 byte(s) 
    -fixed garbage patches
    1 From e1a7f4bb5333b0271d29f785eb55f1c3273e626a Mon Sep 17 00:00:00 2001
    2 From: Peter Hutterer <peter.hutterer@who-t.net>
    3 Date: Tue, 5 May 2015 14:18:54 +1000
    4 Subject: [PATCH] dix: Add unaccelerated valuators to the ValuatorMask
    5
    6 Allows a mask to carry both accelerated and unaccelerated motion at the same
    7 time.
    8
    9 This is required for xf86-input-libinput where the pointer acceleration
    10 happens in libinput already, but parts of the server, specifically raw events
    11 and DGA rely on device-specific unaccelerated data.
    12
    13 To ease integration add this as a second set to the ValuatorMask rather than
    14 extending all APIs to carry a second, possibly NULL set of valuators.
    15
    16 Note that a valuator mask should only be used in either accel/unaccel or
    17 standard mode at any time. Switching requires either a valuator_mask_zero()
    18 call or unsetting all valuators one-by-one. Trying to mix the two will produce
    19 a warning.
    20
    21 The server has a shortcut for changing a mask with the
    22 valuator_mask_drop_unaccelerated() call. This saves us from having to loop
    23 through all valuators on every event, we can just drop the bits we know we
    24 don't want.
    25
    26 Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
    27 Reviewed-by: Hans de Goede <hdegoede@redhat.com>
    28 ---
    29 dix/inpututils.c | 82 +++++++++++++++++++++++++++++++++++++++---
    30 hw/xfree86/common/xf86Module.h | 2 +-
    31 include/input.h | 15 ++++++++
    32 include/inpututils.h | 2 ++
    33 4 files changed, 95 insertions(+), 6 deletions(-)
    34
    35 diff --git a/dix/inpututils.c b/dix/inpututils.c
    36 index 5c2a32d..1363988 100644
    37 --- a/dix/inpututils.c
    38 +++ b/dix/inpututils.c
    39 @@ -505,11 +505,8 @@ valuator_mask_isset(const ValuatorMask *mask, int valuator)
    40 return mask->last_bit >= valuator && BitIsOn(mask->mask, valuator);
    41 }
    42
    43 -/**
    44 - * Set the valuator to the given floating-point data.
    45 - */
    46 -void
    47 -valuator_mask_set_double(ValuatorMask *mask, int valuator, double data)
    48 +static inline void
    49 +_valuator_mask_set_double(ValuatorMask *mask, int valuator, double data)
    50 {
    51 mask->last_bit = max(valuator, mask->last_bit);
    52 SetBit(mask->mask, valuator);
    53 @@ -517,6 +514,17 @@ valuator_mask_set_double(ValuatorMask *mask, int valuator, double data)
    54 }
    55
    56 /**
    57 + * Set the valuator to the given floating-point data.
    58 + */
    59 +void
    60 +valuator_mask_set_double(ValuatorMask *mask, int valuator, double data)
    61 +{
    62 + BUG_WARN_MSG(mask->has_unaccelerated,
    63 + "Do not mix valuator types, zero mask first\n");
    64 + _valuator_mask_set_double(mask, valuator, data);
    65 +}
    66 +
    67 +/**
    68 * Set the valuator to the given integer data.
    69 */
    70 void
    71 @@ -594,11 +602,15 @@ valuator_mask_unset(ValuatorMask *mask, int valuator)
    72
    73 ClearBit(mask->mask, valuator);
    74 mask->valuators[valuator] = 0.0;
    75 + mask->unaccelerated[valuator] = 0.0;
    76
    77 for (i = 0; i <= mask->last_bit; i++)
    78 if (valuator_mask_isset(mask, i))
    79 lastbit = max(lastbit, i);
    80 mask->last_bit = lastbit;
    81 +
    82 + if (mask->last_bit == -1)
    83 + mask->has_unaccelerated = FALSE;
    84 }
    85 }
    86
    87 @@ -611,6 +623,66 @@ valuator_mask_copy(ValuatorMask *dest, const ValuatorMask *src)
    88 valuator_mask_zero(dest);
    89 }
    90
    91 +Bool
    92 +valuator_mask_has_unaccelerated(const ValuatorMask *mask)
    93 +{
    94 + return mask->has_unaccelerated;
    95 +}
    96 +
    97 +void
    98 +valuator_mask_drop_unaccelerated(ValuatorMask *mask)
    99 +{
    100 + memset(mask->unaccelerated, 0, sizeof(mask->unaccelerated));
    101 + mask->has_unaccelerated = FALSE;
    102 +}
    103 +
    104 +/**
    105 + * Set both accelerated and unaccelerated value for this mask.
    106 + */
    107 +void
    108 +valuator_mask_set_unaccelerated(ValuatorMask *mask,
    109 + int valuator,
    110 + double accel,
    111 + double unaccel)
    112 +{
    113 + BUG_WARN_MSG(mask->last_bit != -1 && !mask->has_unaccelerated,
    114 + "Do not mix valuator types, zero mask first\n");
    115 + _valuator_mask_set_double(mask, valuator, accel);
    116 + mask->has_unaccelerated = TRUE;
    117 + mask->unaccelerated[valuator] = unaccel;
    118 +}
    119 +
    120 +double
    121 +valuator_mask_get_accelerated(const ValuatorMask *mask,
    122 + int valuator)
    123 +{
    124 + return valuator_mask_get_double(mask, valuator);
    125 +}
    126 +
    127 +double
    128 +valuator_mask_get_unaccelerated(const ValuatorMask *mask,
    129 + int valuator)
    130 +{
    131 + return mask->unaccelerated[valuator];
    132 +}
    133 +
    134 +Bool
    135 +valuator_mask_fetch_unaccelerated(const ValuatorMask *mask,
    136 + int valuator,
    137 + double *accel,
    138 + double *unaccel)
    139 +{
    140 + if (valuator_mask_isset(mask, valuator)) {
    141 + if (accel)
    142 + *accel = valuator_mask_get_accelerated(mask, valuator);
    143 + if (unaccel)
    144 + *unaccel = valuator_mask_get_unaccelerated(mask, valuator);
    145 + return TRUE;
    146 + }
    147 + else
    148 + return FALSE;
    149 +}
    150 +
    151 int
    152 CountBits(const uint8_t * mask, int len)
    153 {
    154 diff --git a/hw/xfree86/common/xf86Module.h b/hw/xfree86/common/xf86Module.h
    155 index e68fe9c..6133641 100644
    156 --- a/hw/xfree86/common/xf86Module.h
    157 +++ b/hw/xfree86/common/xf86Module.h
    158 @@ -81,7 +81,7 @@ typedef enum {
    159 */
    160 #define ABI_ANSIC_VERSION SET_ABI_VERSION(0, 4)
    161 #define ABI_VIDEODRV_VERSION SET_ABI_VERSION(19, 0)
    162 -#define ABI_XINPUT_VERSION SET_ABI_VERSION(21, 0)
    163 +#define ABI_XINPUT_VERSION SET_ABI_VERSION(21, 1)
    164 #define ABI_EXTENSION_VERSION SET_ABI_VERSION(9, 0)
    165 #define ABI_FONT_VERSION SET_ABI_VERSION(0, 6)
    166
    167 diff --git a/include/input.h b/include/input.h
    168 index bf22dc7..0a4c4f7 100644
    169 --- a/include/input.h
    170 +++ b/include/input.h
    171 @@ -674,6 +674,21 @@ extern _X_EXPORT Bool valuator_mask_fetch(const ValuatorMask *mask,
    172 extern _X_EXPORT Bool valuator_mask_fetch_double(const ValuatorMask *mask,
    173 int valnum, double *val);
    174
    175 +extern _X_EXPORT Bool valuator_mask_has_unaccelerated(const ValuatorMask *mask);
    176 +extern _X_EXPORT void valuator_mask_set_unaccelerated(ValuatorMask *mask,
    177 + int valuator,
    178 + double accel,
    179 + double unaccel);
    180 +extern _X_EXPORT double valuator_mask_get_accelerated(const ValuatorMask *mask,
    181 + int valuator);
    182 +extern _X_EXPORT double valuator_mask_get_unaccelerated(const ValuatorMask *mask,
    183 + int valuator);
    184 +extern _X_EXPORT Bool valuator_mask_fetch_unaccelerated(const ValuatorMask *mask,
    185 + int valuator,
    186 + double *accel,
    187 + double *unaccel);
    188 +extern _X_HIDDEN void valuator_mask_drop_unaccelerated(ValuatorMask *mask);
    189 +
    190 /* InputOption handling interface */
    191 extern _X_EXPORT InputOption *input_option_new(InputOption *list,
    192 const char *key,
    193 diff --git a/include/inpututils.h b/include/inpututils.h
    194 index 53c96ba..4e90815 100644
    195 --- a/include/inpututils.h
    196 +++ b/include/inpututils.h
    197 @@ -36,8 +36,10 @@ extern Mask event_filters[MAXDEVICES][MAXEVENTS];
    198
    199 struct _ValuatorMask {
    200 int8_t last_bit; /* highest bit set in mask */
    201 + int8_t has_unaccelerated;
    202 uint8_t mask[(MAX_VALUATORS + 7) / 8];
    203 double valuators[MAX_VALUATORS]; /* valuator data */
    204 + double unaccelerated[MAX_VALUATORS]; /* valuator data */
    205 };
    206
    207 extern void verify_internal_event(const InternalEvent *ev);
    208 --
    209 2.4.1
    210