Magellan Linux

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

    Annotation 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 - (hide annotations) (download)
    Mon Jun 15 13:02:17 2015 UTC (8 years, 11 months ago) by niro
    File size: 7618 byte(s) 
    -fixed garbage patches
    1 niro 2576 From e1a7f4bb5333b0271d29f785eb55f1c3273e626a Mon Sep 17 00:00:00 2001
    2     From: Peter Hutterer <peter.hutterer@who-t.net>
    3 niro 2575 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 niro 2576 Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
    27     Reviewed-by: Hans de Goede <hdegoede@redhat.com>
    28     ---
    29 niro 2575 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 niro 2576 --- 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 niro 2575 }
    42    
    43 niro 2576 -/**
    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 niro 2575 {
    51 niro 2576 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 niro 2575 }
    55    
    56     /**
    57 niro 2576 + * 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 niro 2575 * Set the valuator to the given integer data.
    69     */
    70     void
    71 niro 2576 @@ -594,11 +602,15 @@ valuator_mask_unset(ValuatorMask *mask, int valuator)
    72 niro 2575
    73 niro 2576 ClearBit(mask->mask, valuator);
    74     mask->valuators[valuator] = 0.0;
    75     + mask->unaccelerated[valuator] = 0.0;
    76 niro 2575
    77 niro 2576 for (i = 0; i <= mask->last_bit; i++)
    78 niro 2575 if (valuator_mask_isset(mask, i))
    79     lastbit = max(lastbit, i);
    80 niro 2576 mask->last_bit = lastbit;
    81     +
    82     + if (mask->last_bit == -1)
    83     + mask->has_unaccelerated = FALSE;
    84 niro 2575 }
    85     }
    86    
    87 niro 2576 @@ -611,6 +623,66 @@ valuator_mask_copy(ValuatorMask *dest, const ValuatorMask *src)
    88 niro 2575 valuator_mask_zero(dest);
    89     }
    90    
    91 niro 2576 +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 niro 2575 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 niro 2576 --- a/hw/xfree86/common/xf86Module.h
    157     +++ b/hw/xfree86/common/xf86Module.h
    158     @@ -81,7 +81,7 @@ typedef enum {
    159 niro 2575 */
    160     #define ABI_ANSIC_VERSION SET_ABI_VERSION(0, 4)
    161     #define ABI_VIDEODRV_VERSION SET_ABI_VERSION(19, 0)
    162 niro 2576 -#define ABI_XINPUT_VERSION SET_ABI_VERSION(21, 0)
    163     +#define ABI_XINPUT_VERSION SET_ABI_VERSION(21, 1)
    164 niro 2575 #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 niro 2576 --- 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 niro 2575 extern _X_EXPORT Bool valuator_mask_fetch_double(const ValuatorMask *mask,
    173     int valnum, double *val);
    174    
    175 niro 2576 +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 niro 2575 /* 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 niro 2576 --- a/include/inpututils.h
    196     +++ b/include/inpututils.h
    197     @@ -36,8 +36,10 @@ extern Mask event_filters[MAXDEVICES][MAXEVENTS];
    198 niro 2575
    199     struct _ValuatorMask {
    200     int8_t last_bit; /* highest bit set in mask */
    201 niro 2576 + int8_t has_unaccelerated;
    202 niro 2575 uint8_t mask[(MAX_VALUATORS + 7) / 8];
    203     double valuators[MAX_VALUATORS]; /* valuator data */
    204 niro 2576 + double unaccelerated[MAX_VALUATORS]; /* valuator data */
    205 niro 2575 };
    206    
    207     extern void verify_internal_event(const InternalEvent *ev);
    208 niro 2576 --
    209 niro 2575 2.4.1
    210