429  * Alloc a valuator mask large enough for num_valuators.
434     /* alloc a fixed size mask for now and ignore num_valuators. in the  in valuator_mask_new()
437     ValuatorMask *mask = calloc(1, sizeof(ValuatorMask));  in valuator_mask_new()  local
439     if (mask == NULL)  in valuator_mask_new()
442     mask->last_bit = -1;  in valuator_mask_new()
443     return mask;  in valuator_mask_new()
447 valuator_mask_free(ValuatorMask **mask)  in valuator_mask_free()  argument
449     free(*mask);  in valuator_mask_free()
450     *mask = NULL;  in valuator_mask_free()
458 valuator_mask_set_range(ValuatorMask *mask, int first_valuator,  in valuator_mask_set_range()  argument
463     valuator_mask_zero(mask);  in valuator_mask_set_range()
467         valuator_mask_set(mask, i, valuators[i - first_valuator]);  in valuator_mask_set_range()
471  * Reset mask to zero.
474 valuator_mask_zero(ValuatorMask *mask)  in valuator_mask_zero()  argument
476     memset(mask, 0, sizeof(*mask));  in valuator_mask_zero()
477     mask->last_bit = -1;  in valuator_mask_zero()
481  * Returns the current size of the mask (i.e. the highest number of
485 valuator_mask_size(const ValuatorMask *mask)  in valuator_mask_size()  argument
487     return mask->last_bit + 1;  in valuator_mask_size()
491  * Returns the number of valuators set in the given mask.
494 valuator_mask_num_valuators(const ValuatorMask *mask)  in valuator_mask_num_valuators()  argument
496     return CountBits(mask->mask, min(mask->last_bit + 1, MAX_VALUATORS));  in valuator_mask_num_valuators()
500  * Return true if the valuator is set in the mask, or false otherwise.
503 valuator_mask_isset(const ValuatorMask *mask, int valuator)  in valuator_mask_isset()  argument
505     return mask->last_bit >= valuator && BitIsOn(mask->mask, valuator);  in valuator_mask_isset()
509 _valuator_mask_set_double(ValuatorMask *mask, int valuator, double data)  in _valuator_mask_set_double()  argument
511     mask->last_bit = max(valuator, mask->last_bit);  in _valuator_mask_set_double()
512     SetBit(mask->mask, valuator);  in _valuator_mask_set_double()
513     mask->valuators[valuator] = data;  in _valuator_mask_set_double()
520 valuator_mask_set_double(ValuatorMask *mask, int valuator, double data)  in valuator_mask_set_double()  argument
522     BUG_WARN_MSG(mask->has_unaccelerated,  in valuator_mask_set_double()
523                  "Do not mix valuator types, zero mask first\n");  in valuator_mask_set_double()
524     _valuator_mask_set_double(mask, valuator, data);  in valuator_mask_set_double()
531 valuator_mask_set(ValuatorMask *mask, int valuator, int data)  in valuator_mask_set()  argument
533     valuator_mask_set_double(mask, valuator, data);  in valuator_mask_set()
537  * Return the requested valuator value as a double. If the mask bit is not
541 valuator_mask_get_double(const ValuatorMask *mask, int valuator)  in valuator_mask_get_double()  argument
543     return mask->valuators[valuator];  in valuator_mask_get_double()
548  * If the mask bit is not set for the given valuator, the returned value is
552 valuator_mask_get(const ValuatorMask *mask, int valuator)  in valuator_mask_get()  argument
554     return trunc(valuator_mask_get_double(mask, valuator));  in valuator_mask_get()
558  * Set value to the requested valuator. If the mask bit is set for this
561  * If the mask bit is not set for this valuator, value is unchanged and
565 valuator_mask_fetch_double(const ValuatorMask *mask, int valuator,  in valuator_mask_fetch_double()  argument
568     if (valuator_mask_isset(mask, valuator)) {  in valuator_mask_fetch_double()
569         *value = valuator_mask_get_double(mask, valuator);  in valuator_mask_fetch_double()
577  * Set value to the requested valuator. If the mask bit is set for this
580  * If the mask bit is not set for this valuator, value is unchanged and
584 valuator_mask_fetch(const ValuatorMask *mask, int valuator, int *value)  in valuator_mask_fetch()  argument
586     if (valuator_mask_isset(mask, valuator)) {  in valuator_mask_fetch()
587         *value = valuator_mask_get(mask, valuator);  in valuator_mask_fetch()
595  * Remove the valuator from the mask.
598 valuator_mask_unset(ValuatorMask *mask, int valuator)  in valuator_mask_unset()  argument
600     if (mask->last_bit >= valuator) {  in valuator_mask_unset()
603         ClearBit(mask->mask, valuator);  in valuator_mask_unset()
604         mask->valuators[valuator] = 0.0;  in valuator_mask_unset()
605         mask->unaccelerated[valuator] = 0.0;  in valuator_mask_unset()
607         for (i = 0; i <= mask->last_bit; i++)  in valuator_mask_unset()
608             if (valuator_mask_isset(mask, i))  in valuator_mask_unset()
610         mask->last_bit = lastbit;  in valuator_mask_unset()
612         if (mask->last_bit == -1)  in valuator_mask_unset()
613             mask->has_unaccelerated = FALSE;  in valuator_mask_unset()
627 valuator_mask_has_unaccelerated(const ValuatorMask *mask)  in valuator_mask_has_unaccelerated()  argument
629     return mask->has_unaccelerated;  in valuator_mask_has_unaccelerated()
633 valuator_mask_drop_unaccelerated(ValuatorMask *mask)  in valuator_mask_drop_unaccelerated()  argument
635     memset(mask->unaccelerated, 0, sizeof(mask->unaccelerated));  in valuator_mask_drop_unaccelerated()
636     mask->has_unaccelerated = FALSE;  in valuator_mask_drop_unaccelerated()
640 valuator_mask_set_absolute_unaccelerated(ValuatorMask *mask,  in valuator_mask_set_absolute_unaccelerated()  argument
645     BUG_WARN_MSG(mask->last_bit != -1 && !mask->has_unaccelerated,  in valuator_mask_set_absolute_unaccelerated()
646                  "Do not mix valuator types, zero mask first\n");  in valuator_mask_set_absolute_unaccelerated()
647     _valuator_mask_set_double(mask, valuator, absolute);  in valuator_mask_set_absolute_unaccelerated()
648     mask->has_unaccelerated = TRUE;  in valuator_mask_set_absolute_unaccelerated()
649     mask->unaccelerated[valuator] = unaccel;  in valuator_mask_set_absolute_unaccelerated()
653  * Set both accelerated and unaccelerated value for this mask.
656 valuator_mask_set_unaccelerated(ValuatorMask *mask,  in valuator_mask_set_unaccelerated()  argument
661     BUG_WARN_MSG(mask->last_bit != -1 && !mask->has_unaccelerated,  in valuator_mask_set_unaccelerated()
662                  "Do not mix valuator types, zero mask first\n");  in valuator_mask_set_unaccelerated()
663     _valuator_mask_set_double(mask, valuator, accel);  in valuator_mask_set_unaccelerated()
664     mask->has_unaccelerated = TRUE;  in valuator_mask_set_unaccelerated()
665     mask->unaccelerated[valuator] = unaccel;  in valuator_mask_set_unaccelerated()
669 valuator_mask_get_accelerated(const ValuatorMask *mask,  in valuator_mask_get_accelerated()  argument
672     return valuator_mask_get_double(mask, valuator);  in valuator_mask_get_accelerated()
676 valuator_mask_get_unaccelerated(const ValuatorMask *mask,  in valuator_mask_get_unaccelerated()  argument
679     return mask->unaccelerated[valuator];  in valuator_mask_get_unaccelerated()
683 valuator_mask_fetch_unaccelerated(const ValuatorMask *mask,  in valuator_mask_fetch_unaccelerated()  argument
688     if (valuator_mask_isset(mask, valuator)) {  in valuator_mask_fetch_unaccelerated()
690             *accel = valuator_mask_get_accelerated(mask, valuator);  in valuator_mask_fetch_unaccelerated()
692             *unaccel = valuator_mask_get_unaccelerated(mask, valuator);  in valuator_mask_fetch_unaccelerated()
700 CountBits(const uint8_t * mask, int len)  in CountBits()  argument
706         if (BitIsOn(mask, i))  in CountBits()
804  * Return the event filter mask for the given device and the given core or
807 Mask
814  * Return the event filter mask for the given device and the given core or
817 Mask
1047  * @return The new mask or NULL on allocation error.
1055     XI2Mask *mask;  in xi2mask_new_with_size()  local
1061     mask = calloc(1, alloc_size);  in xi2mask_new_with_size()
1063     if (!mask)  in xi2mask_new_with_size()
1066     mask->nmasks = nmasks;  in xi2mask_new_with_size()
1067     mask->mask_size = size;  in xi2mask_new_with_size()
1069     mask->masks = (unsigned char **)(mask + 1);  in xi2mask_new_with_size()
1070     cursor = (unsigned char *)(mask + 1) + nmasks * sizeof(unsigned char *);  in xi2mask_new_with_size()
1073         mask->masks[i] = cursor;  in xi2mask_new_with_size()
1076     return mask;  in xi2mask_new_with_size()
1080  * Create a new XI2 mask of the standard size, i.e. for all devices + fake
1083  * @return The new mask or NULL on allocation error.
1092  * Frees memory associated with mask and resets mask to NULL.
1095 xi2mask_free(XI2Mask **mask)  in xi2mask_free()  argument
1097     if (!(*mask))  in xi2mask_free()
1100     free((*mask));  in xi2mask_free()
1101     *mask = NULL;  in xi2mask_free()
1110 xi2mask_isset_for_device(XI2Mask *mask, const DeviceIntPtr dev, int event_type)  in xi2mask_isset_for_device()  argument
1113     BUG_WARN(dev->id >= mask->nmasks);  in xi2mask_isset_for_device()
1114     BUG_WARN(bits_to_bytes(event_type + 1) > mask->mask_size);  in xi2mask_isset_for_device()
1116     return BitIsOn(mask->masks[dev->id], event_type);  in xi2mask_isset_for_device()
1126 xi2mask_isset(XI2Mask *mask, const DeviceIntPtr dev, int event_type)  in xi2mask_isset()  argument
1130     if (xi2mask_isset_for_device(mask, inputInfo.all_devices, event_type))  in xi2mask_isset()
1132     else if (xi2mask_isset_for_device(mask, dev, event_type))  in xi2mask_isset()
1134 …else if (IsMaster(dev) && xi2mask_isset_for_device(mask, inputInfo.all_master_devices, event_type))  in xi2mask_isset()
1141  * Set the mask bit for this event type for this device.
1144 xi2mask_set(XI2Mask *mask, int deviceid, int event_type)  in xi2mask_set()  argument
1147     BUG_WARN(deviceid >= mask->nmasks);  in xi2mask_set()
1148     BUG_WARN(bits_to_bytes(event_type + 1) > mask->mask_size);  in xi2mask_set()
1150     SetBit(mask->masks[deviceid], event_type);  in xi2mask_set()
1158 xi2mask_zero(XI2Mask *mask, int deviceid)  in xi2mask_zero()  argument
1162     BUG_WARN(deviceid > 0 && deviceid >= mask->nmasks);  in xi2mask_zero()
1165         memset(mask->masks[deviceid], 0, mask->mask_size);  in xi2mask_zero()
1167         for (i = 0; i < mask->nmasks; i++)  in xi2mask_zero()
1168             memset(mask->masks[i], 0, mask->mask_size);  in xi2mask_zero()
1186  * @return The number of masks in mask
1189 xi2mask_num_masks(const XI2Mask *mask)  in xi2mask_num_masks()  argument
1191     return mask->nmasks;  in xi2mask_num_masks()
1195  * @return The size of each mask in bytes
1198 xi2mask_mask_size(const XI2Mask *mask)  in xi2mask_mask_size()  argument
1200     return mask->mask_size;  in xi2mask_mask_size()
1204  * Set the mask for the given deviceid to the source mask.
1205  * If the mask given is larger than the target memory, only the overlapping
1209 xi2mask_set_one_mask(XI2Mask *xi2mask, int deviceid, const unsigned char *mask,  in xi2mask_set_one_mask()  argument
1215     memcpy(xi2mask->masks[deviceid], mask, min(xi2mask->mask_size, mask_size));  in xi2mask_set_one_mask()
1222 xi2mask_get_one_mask(const XI2Mask *mask, int deviceid)  in xi2mask_get_one_mask()  argument
1225     BUG_WARN(deviceid >= mask->nmasks);  in xi2mask_get_one_mask()
1227     return mask->masks[deviceid];  in xi2mask_get_one_mask()