diff options
Diffstat (limited to 'src/3rdparty')
55 files changed, 34539 insertions, 765 deletions
diff --git a/src/3rdparty/double-conversion/bignum.cc b/src/3rdparty/double-conversion/bignum.cc index 2743d67e8d..8892de8f2a 100644 --- a/src/3rdparty/double-conversion/bignum.cc +++ b/src/3rdparty/double-conversion/bignum.cc @@ -104,7 +104,7 @@ void Bignum::AssignDecimalString(Vector<const char> value) { const int kMaxUint64DecimalDigits = 19; Zero(); int length = value.length(); - int pos = 0; + unsigned int pos = 0; // Let's just say that each digit needs 4 bits. while (length >= kMaxUint64DecimalDigits) { uint64_t digits = ReadUInt64(value, pos, kMaxUint64DecimalDigits); diff --git a/src/3rdparty/double-conversion/bignum.h b/src/3rdparty/double-conversion/bignum.h index 5ec3544f57..c385f2237b 100644 --- a/src/3rdparty/double-conversion/bignum.h +++ b/src/3rdparty/double-conversion/bignum.h @@ -49,7 +49,6 @@ class Bignum { void AssignPowerUInt16(uint16_t base, int exponent); - void AddUInt16(uint16_t operand); void AddUInt64(uint64_t operand); void AddBignum(const Bignum& other); // Precondition: this >= other. diff --git a/src/3rdparty/double-conversion/cached-powers.cc b/src/3rdparty/double-conversion/cached-powers.cc index 9536f26927..2b43f06412 100644 --- a/src/3rdparty/double-conversion/cached-powers.cc +++ b/src/3rdparty/double-conversion/cached-powers.cc @@ -131,7 +131,6 @@ static const CachedPower kCachedPowers[] = { {UINT64_2PART_C(0xaf87023b, 9bf0ee6b), 1066, 340}, }; -static const int kCachedPowersLength = ARRAY_SIZE(kCachedPowers); static const int kCachedPowersOffset = 348; // -1 * the first decimal_exponent. static const double kD_1_LOG2_10 = 0.30102999566398114; // 1 / lg(10) // Difference between the decimal exponents in the table above. @@ -144,14 +143,12 @@ void PowersOfTenCache::GetCachedPowerForBinaryExponentRange( int max_exponent, DiyFp* power, int* decimal_exponent) { - (void)max_exponent; // Silence unused parameter warning in release builds - (void)kCachedPowersLength; // Silence unused parameter warning in release builds int kQ = DiyFp::kSignificandSize; double k = ceil((min_exponent + kQ - 1) * kD_1_LOG2_10); int foo = kCachedPowersOffset; int index = (foo + static_cast<int>(k) - 1) / kDecimalExponentDistance + 1; - ASSERT(0 <= index && index < kCachedPowersLength); + ASSERT(0 <= index && index < static_cast<int>(ARRAY_SIZE(kCachedPowers))); CachedPower cached_power = kCachedPowers[index]; ASSERT(min_exponent <= cached_power.binary_exponent); (void) max_exponent; // Mark variable as used. diff --git a/src/3rdparty/double-conversion/diy-fp.h b/src/3rdparty/double-conversion/diy-fp.h index 9dcf8fbdba..2edf34674e 100644 --- a/src/3rdparty/double-conversion/diy-fp.h +++ b/src/3rdparty/double-conversion/diy-fp.h @@ -42,7 +42,7 @@ class DiyFp { static const int kSignificandSize = 64; DiyFp() : f_(0), e_(0) {} - DiyFp(uint64_t f, int e) : f_(f), e_(e) {} + DiyFp(uint64_t significand, int exponent) : f_(significand), e_(exponent) {} // this = this - other. // The exponents of both numbers must be the same and the significand of this @@ -76,22 +76,22 @@ class DiyFp { void Normalize() { ASSERT(f_ != 0); - uint64_t f = f_; - int e = e_; + uint64_t significand = f_; + int exponent = e_; // This method is mainly called for normalizing boundaries. In general // boundaries need to be shifted by 10 bits. We thus optimize for this case. const uint64_t k10MSBits = UINT64_2PART_C(0xFFC00000, 00000000); - while ((f & k10MSBits) == 0) { - f <<= 10; - e -= 10; + while ((significand & k10MSBits) == 0) { + significand <<= 10; + exponent -= 10; } - while ((f & kUint64MSB) == 0) { - f <<= 1; - e--; + while ((significand & kUint64MSB) == 0) { + significand <<= 1; + exponent--; } - f_ = f; - e_ = e; + f_ = significand; + e_ = exponent; } static DiyFp Normalize(const DiyFp& a) { diff --git a/src/3rdparty/double-conversion/double-conversion.cc b/src/3rdparty/double-conversion/double-conversion.cc index 909985be82..6f21a0124c 100644 --- a/src/3rdparty/double-conversion/double-conversion.cc +++ b/src/3rdparty/double-conversion/double-conversion.cc @@ -118,7 +118,7 @@ void DoubleToStringConverter::CreateDecimalRepresentation( StringBuilder* result_builder) const { // Create a representation that is padded with zeros if needed. if (decimal_point <= 0) { - // "0.00000decimal_rep". + // "0.00000decimal_rep" or "0.000decimal_rep00". result_builder->AddCharacter('0'); if (digits_after_point > 0) { result_builder->AddCharacter('.'); @@ -129,7 +129,7 @@ void DoubleToStringConverter::CreateDecimalRepresentation( result_builder->AddPadding('0', remaining_digits); } } else if (decimal_point >= length) { - // "decimal_rep0000.00000" or "decimal_rep.0000" + // "decimal_rep0000.00000" or "decimal_rep.0000". result_builder->AddSubstring(decimal_digits, length); result_builder->AddPadding('0', decimal_point - length); if (digits_after_point > 0) { @@ -137,7 +137,7 @@ void DoubleToStringConverter::CreateDecimalRepresentation( result_builder->AddPadding('0', digits_after_point); } } else { - // "decima.l_rep000" + // "decima.l_rep000". ASSERT(digits_after_point > 0); result_builder->AddSubstring(decimal_digits, decimal_point); result_builder->AddCharacter('.'); @@ -494,10 +494,17 @@ static double SignedZero(bool sign) { // because it constant-propagated the radix and concluded that the last // condition was always true. By moving it into a separate function the // compiler wouldn't warn anymore. +#if _MSC_VER +#pragma optimize("",off) static bool IsDecimalDigitForRadix(int c, int radix) { return '0' <= c && c <= '9' && (c - '0') < radix; } - +#pragma optimize("",on) +#else +static bool inline IsDecimalDigitForRadix(int c, int radix) { + return '0' <= c && c <= '9' && (c - '0') < radix; +} +#endif // Returns true if 'c' is a character digit that is valid for the given radix. // The 'a_character' should be 'a' or 'A'. // @@ -852,9 +859,9 @@ double StringToDoubleConverter::StringToIeee( return junk_string_value_; } } - char sign = '+'; + char exponen_sign = '+'; if (*current == '+' || *current == '-') { - sign = static_cast<char>(*current); + exponen_sign = static_cast<char>(*current); ++current; if (current == end) { if (allow_trailing_junk) { @@ -888,7 +895,7 @@ double StringToDoubleConverter::StringToIeee( ++current; } while (current != end && *current >= '0' && *current <= '9'); - exponent += (sign == '-' ? -num : num); + exponent += (exponen_sign == '-' ? -num : num); } if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) { diff --git a/src/3rdparty/double-conversion/fixed-dtoa.cc b/src/3rdparty/double-conversion/fixed-dtoa.cc index aef65fdc21..0f55a0b6eb 100644 --- a/src/3rdparty/double-conversion/fixed-dtoa.cc +++ b/src/3rdparty/double-conversion/fixed-dtoa.cc @@ -98,7 +98,7 @@ class UInt128 { return high_bits_ == 0 && low_bits_ == 0; } - int BitAt(int position) { + int BitAt(int position) const { if (position >= 64) { return static_cast<int>(high_bits_ >> (position - 64)) & 1; } else { @@ -259,7 +259,8 @@ static void FillFractionals(uint64_t fractionals, int exponent, fractionals -= static_cast<uint64_t>(digit) << point; } // If the first bit after the point is set we have to round up. - if (((fractionals >> (point - 1)) & 1) == 1) { + ASSERT(fractionals == 0 || point - 1 >= 0); + if ((fractionals != 0) && ((fractionals >> (point - 1)) & 1) == 1) { RoundUp(buffer, length, decimal_point); } } else { // We need 128 bits. diff --git a/src/3rdparty/double-conversion/ieee.h b/src/3rdparty/double-conversion/ieee.h index 661141d1a8..b14cf4f717 100644 --- a/src/3rdparty/double-conversion/ieee.h +++ b/src/3rdparty/double-conversion/ieee.h @@ -99,7 +99,7 @@ class Double { } double PreviousDouble() const { - if (d64_ == (kInfinity | kSignMask)) return -Double::Infinity(); + if (d64_ == (kInfinity | kSignMask)) return -Infinity(); if (Sign() < 0) { return Double(d64_ + 1).value(); } else { diff --git a/src/3rdparty/double-conversion/include/double-conversion/utils.h b/src/3rdparty/double-conversion/include/double-conversion/utils.h index 20bfd36c84..ca7646d817 100644 --- a/src/3rdparty/double-conversion/include/double-conversion/utils.h +++ b/src/3rdparty/double-conversion/include/double-conversion/utils.h @@ -33,19 +33,29 @@ #include <assert.h> #ifndef ASSERT -# if defined(WINCE) || defined(_WIN32_WCE) -# define ASSERT(condition) -# else -# define ASSERT(condition) \ +#define ASSERT(condition) \ assert(condition); -# endif #endif #ifndef UNIMPLEMENTED -# define UNIMPLEMENTED() (exit(-1)) +#define UNIMPLEMENTED() (abort()) +#endif +#ifndef DOUBLE_CONVERSION_NO_RETURN +#ifdef _MSC_VER +#define DOUBLE_CONVERSION_NO_RETURN __declspec(noreturn) +#else +#define DOUBLE_CONVERSION_NO_RETURN __attribute__((noreturn)) +#endif #endif #ifndef UNREACHABLE -# define UNREACHABLE() (exit(-1)) +#ifdef _MSC_VER +void DOUBLE_CONVERSION_NO_RETURN abort_noreturn(); +inline void abort_noreturn() { abort(); } +#define UNREACHABLE() (abort_noreturn()) +#else +#define UNREACHABLE() (abort()) #endif +#endif + // Double operations detection based on target architecture. // Linux uses a 80bit wide floating point stack on x86. This induces double @@ -62,11 +72,15 @@ defined(__hppa__) || defined(__ia64__) || \ defined(__mips__) || \ defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) || \ + defined(_POWER) || defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \ defined(__sparc__) || defined(__sparc) || defined(__s390__) || \ defined(__SH4__) || defined(__alpha__) || \ defined(_MIPS_ARCH_MIPS32R2) || \ - defined(__AARCH64EL__) + defined(__AARCH64EL__) || defined(__aarch64__) || \ + defined(__riscv) #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 +#elif defined(__mc68000__) +#undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS #elif defined(_M_IX86) || defined(__i386__) || defined(__i386) #if defined(_WIN32) // Windows uses a 64bit wide floating point stack. @@ -172,8 +186,8 @@ template <typename T> class Vector { public: Vector() : start_(NULL), length_(0) {} - Vector(T* data, int length) : start_(data), length_(length) { - ASSERT(length == 0 || (length > 0 && data != NULL)); + Vector(T* data, int len) : start_(data), length_(len) { + ASSERT(len == 0 || (len > 0 && data != NULL)); } // Returns a vector using the same backing storage as this one, @@ -215,8 +229,8 @@ class Vector { // buffer bounds on all operations in debug mode. class StringBuilder { public: - StringBuilder(char* buffer, int size) - : buffer_(buffer, size), position_(0) { } + StringBuilder(char* buffer, int buffer_size) + : buffer_(buffer, buffer_size), position_(0) { } ~StringBuilder() { if (!is_finalized()) Finalize(); } diff --git a/src/3rdparty/double-conversion/qt_attribution.json b/src/3rdparty/double-conversion/qt_attribution.json index 92118ac779..d41a7ef332 100644 --- a/src/3rdparty/double-conversion/qt_attribution.json +++ b/src/3rdparty/double-conversion/qt_attribution.json @@ -5,8 +5,8 @@ "QtUsage": "Used in Qt Core. Configure with -system-doubleconversion or -no-doubleconversion to avoid.", "Homepage": "https://github.com/google/double-conversion", - "Version": "2.0.1", - "DownloadLocation": "https://github.com/google/double-conversion/commit/2fb03de56faa32bbba5e02222528e7b760f71d77", + "Version": "3.0.0", + "DownloadLocation": "https://github.com/google/double-conversion/commit/ca220cbafa83ca706f028bfbb5adc7eb2f1f90e1", "License": "BSD 3-clause \"New\" or \"Revised\" License", "LicenseId": "BSD-3-Clause", "LicenseFile": "LICENSE", diff --git a/src/3rdparty/double-conversion/strtod.cc b/src/3rdparty/double-conversion/strtod.cc index 34717562bd..17abcbb2a5 100644 --- a/src/3rdparty/double-conversion/strtod.cc +++ b/src/3rdparty/double-conversion/strtod.cc @@ -286,7 +286,7 @@ static bool DiyFpStrtod(Vector<const char> buffer, const int kDenominator = 1 << kDenominatorLog; // Move the remaining decimals into the exponent. exponent += remaining_decimals; - int error = (remaining_decimals == 0 ? 0 : kDenominator / 2); + uint64_t error = (remaining_decimals == 0 ? 0 : kDenominator / 2); int old_e = input.e(); input.Normalize(); diff --git a/src/3rdparty/gradle/gradle/wrapper/gradle-wrapper.jar b/src/3rdparty/gradle/gradle/wrapper/gradle-wrapper.jar Binary files differindex 2b338a935b..f6b961fd5a 100644 --- a/src/3rdparty/gradle/gradle/wrapper/gradle-wrapper.jar +++ b/src/3rdparty/gradle/gradle/wrapper/gradle-wrapper.jar diff --git a/src/3rdparty/gradle/gradle/wrapper/gradle-wrapper.properties b/src/3rdparty/gradle/gradle/wrapper/gradle-wrapper.properties index 4244097b7b..bf3de21830 100644 --- a/src/3rdparty/gradle/gradle/wrapper/gradle-wrapper.properties +++ b/src/3rdparty/gradle/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,5 @@ -#Mon Feb 20 10:43:22 EST 2017 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-4.6-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-3.4-bin.zip diff --git a/src/3rdparty/gradle/gradlew b/src/3rdparty/gradle/gradlew index eeff5ccf0e..cccdd3d517 100755 --- a/src/3rdparty/gradle/gradlew +++ b/src/3rdparty/gradle/gradlew @@ -28,16 +28,16 @@ APP_NAME="Gradle" APP_BASE_NAME=`basename "$0"` # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -DEFAULT_JVM_OPTS="-Xmx1024m -Dfile.encoding=UTF-8" +DEFAULT_JVM_OPTS="" # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD="maximum" -warn ( ) { +warn () { echo "$*" } -die ( ) { +die () { echo echo "$*" echo @@ -155,7 +155,7 @@ if $cygwin ; then fi # Escape application args -save ( ) { +save () { for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done echo " " } diff --git a/src/3rdparty/gradle/gradlew.bat b/src/3rdparty/gradle/gradlew.bat index 65b35a4602..f9553162f1 100644 --- a/src/3rdparty/gradle/gradlew.bat +++ b/src/3rdparty/gradle/gradlew.bat @@ -14,7 +14,7 @@ set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -set DEFAULT_JVM_OPTS=-Xmx1024m -Dfile.encoding=UTF-8 +set DEFAULT_JVM_OPTS= @rem Find java.exe if defined JAVA_HOME goto findJavaFromJavaHome diff --git a/src/3rdparty/libjpeg.pri b/src/3rdparty/libjpeg.pri index a61f28dc5a..0d35bf8941 100644 --- a/src/3rdparty/libjpeg.pri +++ b/src/3rdparty/libjpeg.pri @@ -7,10 +7,8 @@ DEFINES += \ JPEG_LIB_VERSION=80 \ SIZEOF_SIZE_T=__SIZEOF_SIZE_T__ -#Disable warnings in 3rdparty code due to unused arguments -contains(QMAKE_CC, gcc): { - QMAKE_CFLAGS_WARN_ON += -Wno-unused-parameter -Wno-main -} +# Disable warnings in 3rdparty code due to unused arguments +gcc: QMAKE_CFLAGS_WARN_ON += -Wno-unused-parameter -Wno-main INCLUDEPATH += $$PWD/libjpeg/src diff --git a/src/3rdparty/tinycbor/.gitignore b/src/3rdparty/tinycbor/.gitignore new file mode 100644 index 0000000000..3272de3326 --- /dev/null +++ b/src/3rdparty/tinycbor/.gitignore @@ -0,0 +1,81 @@ +# Frequent generated files +callgrind.out.* +pcviewer.cfg +*~ +*.a +*.la +*.core +*.d +*.dylib +*.moc +*.o +*.obj +*.orig +*.swp +*.rej +*.so +*.so.* +*.pbxuser +*.mode1 +*.mode1v3 +*_pch.h.cpp +*_resource.rc +.#* +*.*# +core +.qmake.cache +.qmake.stash +.qmake.vars +.device.vars +tags +.DS_Store +*.debug +Makefile* +*.prl +*.app +*.pro.user* +*.qmlproject.user* +*.gcov +*.gcda +*.gcno +*.flc +.*.swp +tinycbor.pc + +# Visual Studio generated files +*.ib_pdb_index +*.idb +*.ilk +*.pdb +*.sln +*.suo +*.vcproj +*vcproj.*.*.user +*.ncb +*.vcxproj +*.vcxproj.filters +*.vcxproj.user +*.exe.embed.manifest +*.exe_manifest.rc +*.exe_manifest.res + +# MinGW generated files +*.Debug +*.Release + +# INTEGRITY generated files +*.gpj +*.int +*.ael +*.dla +*.dnm +*.dep +*.map + +bin +doc +lib +src/cjson +src/doxygen.log +!/Makefile +.config diff --git a/src/3rdparty/tinycbor/LICENSE b/src/3rdparty/tinycbor/LICENSE new file mode 100644 index 0000000000..4aad977ceb --- /dev/null +++ b/src/3rdparty/tinycbor/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 Intel Corporation + +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 +AUTHORS OR COPYRIGHT HOLDERS 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. diff --git a/src/3rdparty/tinycbor/README b/src/3rdparty/tinycbor/README new file mode 100644 index 0000000000..167efa06e2 --- /dev/null +++ b/src/3rdparty/tinycbor/README @@ -0,0 +1,13 @@ +Concise Binary Object Representation (CBOR) Library +--------------------------------------------------- + +To build TinyCBOR: + + make + +If you want to change the compiler or pass extra compiler flags: + + make CC=clang CFLAGS="-m32 -Oz" LDFLAGS="-m32" + +Documentation: https://intel.github.io/tinycbor/current/ + diff --git a/src/3rdparty/tinycbor/VERSION b/src/3rdparty/tinycbor/VERSION new file mode 100644 index 0000000000..a918a2aa18 --- /dev/null +++ b/src/3rdparty/tinycbor/VERSION @@ -0,0 +1 @@ +0.6.0 diff --git a/src/3rdparty/tinycbor/qt_attribution.json b/src/3rdparty/tinycbor/qt_attribution.json new file mode 100644 index 0000000000..1d61534861 --- /dev/null +++ b/src/3rdparty/tinycbor/qt_attribution.json @@ -0,0 +1,14 @@ +{ + "Id": "tinycbor", + "Name": "TinyCBOR", + "QDocModule": "qtcore", + "QtUsage": "Used for QCborStreamReader and QCborStreamWriter.", + + "Description": "Concise Binary Object Representation (CBOR) Library", + "Homepage": "https://github.com/intel/tinycbor", + "License": "MIT License", + "LicenseId": "MIT", + "LicenseFile": "LICENSE", + "Version": "0.6+patches", + "Copyright": "Copyright (C) 2018 Intel Corporation" +} diff --git a/src/3rdparty/tinycbor/src/cbor.h b/src/3rdparty/tinycbor/src/cbor.h new file mode 100644 index 0000000000..5c7ba74e39 --- /dev/null +++ b/src/3rdparty/tinycbor/src/cbor.h @@ -0,0 +1,722 @@ +/**************************************************************************** +** +** Copyright (C) 2018 Intel Corporation +** +** 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 +** AUTHORS OR COPYRIGHT HOLDERS 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. +** +****************************************************************************/ + +#ifndef CBOR_H +#define CBOR_H + +#ifndef assert +#include <assert.h> +#endif +#include <limits.h> +#include <stddef.h> +#include <stdint.h> +#include <string.h> +#include <stdio.h> + +#include "tinycbor-version.h" + +#define TINYCBOR_VERSION ((TINYCBOR_VERSION_MAJOR << 16) | (TINYCBOR_VERSION_MINOR << 8) | TINYCBOR_VERSION_PATCH) + +#ifdef __cplusplus +extern "C" { +#else +#include <stdbool.h> +#endif + +#ifndef SIZE_MAX +/* Some systems fail to define SIZE_MAX in <stdint.h>, even though C99 requires it... + * Conversion from signed to unsigned is defined in 6.3.1.3 (Signed and unsigned integers) p2, + * which says: "the value is converted by repeatedly adding or subtracting one more than the + * maximum value that can be represented in the new type until the value is in the range of the + * new type." + * So -1 gets converted to size_t by adding SIZE_MAX + 1, which results in SIZE_MAX. + */ +# define SIZE_MAX ((size_t)-1) +#endif + +#ifndef CBOR_API +# define CBOR_API +#endif +#ifndef CBOR_PRIVATE_API +# define CBOR_PRIVATE_API +#endif +#ifndef CBOR_INLINE_API +# if defined(__cplusplus) +# define CBOR_INLINE inline +# define CBOR_INLINE_API inline +# else +# define CBOR_INLINE_API static CBOR_INLINE +# if defined(_MSC_VER) +# define CBOR_INLINE __inline +# elif defined(__GNUC__) +# define CBOR_INLINE __inline__ +# elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +# define CBOR_INLINE inline +# else +# define CBOR_INLINE +# endif +# endif +#endif + +typedef enum CborType { + CborIntegerType = 0x00, + CborByteStringType = 0x40, + CborTextStringType = 0x60, + CborArrayType = 0x80, + CborMapType = 0xa0, + CborTagType = 0xc0, + CborSimpleType = 0xe0, + CborBooleanType = 0xf5, + CborNullType = 0xf6, + CborUndefinedType = 0xf7, + CborHalfFloatType = 0xf9, + CborFloatType = 0xfa, + CborDoubleType = 0xfb, + + CborInvalidType = 0xff /* equivalent to the break byte, so it will never be used */ +} CborType; + +typedef uint64_t CborTag; +typedef enum CborKnownTags { + CborDateTimeStringTag = 0, + CborUnixTime_tTag = 1, + CborPositiveBignumTag = 2, + CborNegativeBignumTag = 3, + CborDecimalTag = 4, + CborBigfloatTag = 5, + CborCOSE_Encrypt0Tag = 16, + CborCOSE_Mac0Tag = 17, + CborCOSE_Sign1Tag = 18, + CborExpectedBase64urlTag = 21, + CborExpectedBase64Tag = 22, + CborExpectedBase16Tag = 23, + CborEncodedCborTag = 24, + CborUrlTag = 32, + CborBase64urlTag = 33, + CborBase64Tag = 34, + CborRegularExpressionTag = 35, + CborMimeMessageTag = 36, + CborCOSE_EncryptTag = 96, + CborCOSE_MacTag = 97, + CborCOSE_SignTag = 98, + CborSignatureTag = 55799 +} CborKnownTags; + +/* #define the constants so we can check with #ifdef */ +#define CborDateTimeStringTag CborDateTimeStringTag +#define CborUnixTime_tTag CborUnixTime_tTag +#define CborPositiveBignumTag CborPositiveBignumTag +#define CborNegativeBignumTag CborNegativeBignumTag +#define CborDecimalTag CborDecimalTag +#define CborBigfloatTag CborBigfloatTag +#define CborCOSE_Encrypt0Tag CborCOSE_Encrypt0Tag +#define CborCOSE_Mac0Tag CborCOSE_Mac0Tag +#define CborCOSE_Sign1Tag CborCOSE_Sign1Tag +#define CborExpectedBase64urlTag CborExpectedBase64urlTag +#define CborExpectedBase64Tag CborExpectedBase64Tag +#define CborExpectedBase16Tag CborExpectedBase16Tag +#define CborEncodedCborTag CborEncodedCborTag +#define CborUrlTag CborUrlTag +#define CborBase64urlTag CborBase64urlTag +#define CborBase64Tag CborBase64Tag +#define CborRegularExpressionTag CborRegularExpressionTag +#define CborMimeMessageTag CborMimeMessageTag +#define CborCOSE_EncryptTag CborCOSE_EncryptTag +#define CborCOSE_MacTag CborCOSE_MacTag +#define CborCOSE_SignTag CborCOSE_SignTag +#define CborSignatureTag CborSignatureTag + +/* Error API */ + +typedef enum CborError { + CborNoError = 0, + + /* errors in all modes */ + CborUnknownError, + CborErrorUnknownLength, /* request for length in array, map, or string with indeterminate length */ + CborErrorAdvancePastEOF, + CborErrorIO, + + /* parser errors streaming errors */ + CborErrorGarbageAtEnd = 256, + CborErrorUnexpectedEOF, + CborErrorUnexpectedBreak, + CborErrorUnknownType, /* can only happen in major type 7 */ + CborErrorIllegalType, /* type not allowed here */ + CborErrorIllegalNumber, + CborErrorIllegalSimpleType, /* types of value less than 32 encoded in two bytes */ + CborErrorNoMoreStringChunks, + + /* parser errors in strict mode parsing only */ + CborErrorUnknownSimpleType = 512, + CborErrorUnknownTag, + CborErrorInappropriateTagForType, + CborErrorDuplicateObjectKeys, + CborErrorInvalidUtf8TextString, + CborErrorExcludedType, + CborErrorExcludedValue, + CborErrorImproperValue, + CborErrorOverlongEncoding, + CborErrorMapKeyNotString, + CborErrorMapNotSorted, + CborErrorMapKeysNotUnique, + + /* encoder errors */ + CborErrorTooManyItems = 768, + CborErrorTooFewItems, + + /* internal implementation errors */ + CborErrorDataTooLarge = 1024, + CborErrorNestingTooDeep, + CborErrorUnsupportedType, + CborErrorUnimplementedValidation, + + /* errors in converting to JSON */ + CborErrorJsonObjectKeyIsAggregate = 1280, + CborErrorJsonObjectKeyNotString, + CborErrorJsonNotImplemented, + + CborErrorOutOfMemory = (int) (~0U / 2 + 1), + CborErrorInternalError = (int) (~0U / 2) /* INT_MAX on two's complement machines */ +} CborError; + +CBOR_API const char *cbor_error_string(CborError error); + +/* Encoder API */ + +typedef enum CborEncoderAppendType +{ + CborEncoderAppendCborData = 0, + CborEncoderAppendStringData = 1 +} CborEncoderAppendType; + +typedef CborError (*CborEncoderWriteFunction)(void *, const void *, size_t, CborEncoderAppendType); + +enum CborEncoderFlags +{ + CborIteratorFlag_WriterFunction = 0x01, + CborIteratorFlag_ContainerIsMap_ = 0x20 +}; + +struct CborEncoder +{ + union { + uint8_t *ptr; + ptrdiff_t bytes_needed; + CborEncoderWriteFunction writer; + } data; + uint8_t *end; + size_t remaining; + int flags; +}; +typedef struct CborEncoder CborEncoder; + +static const size_t CborIndefiniteLength = SIZE_MAX; + +#ifndef CBOR_NO_ENCODER_API +CBOR_API void cbor_encoder_init(CborEncoder *encoder, uint8_t *buffer, size_t size, int flags); +CBOR_API void cbor_encoder_init_writer(CborEncoder *encoder, CborEncoderWriteFunction writer, void *); +CBOR_API CborError cbor_encode_uint(CborEncoder *encoder, uint64_t value); +CBOR_API CborError cbor_encode_int(CborEncoder *encoder, int64_t value); +CBOR_API CborError cbor_encode_negative_int(CborEncoder *encoder, uint64_t absolute_value); +CBOR_API CborError cbor_encode_simple_value(CborEncoder *encoder, uint8_t value); +CBOR_API CborError cbor_encode_tag(CborEncoder *encoder, CborTag tag); +CBOR_API CborError cbor_encode_text_string(CborEncoder *encoder, const char *string, size_t length); +CBOR_INLINE_API CborError cbor_encode_text_stringz(CborEncoder *encoder, const char *string) +{ return cbor_encode_text_string(encoder, string, strlen(string)); } +CBOR_API CborError cbor_encode_byte_string(CborEncoder *encoder, const uint8_t *string, size_t length); +CBOR_API CborError cbor_encode_floating_point(CborEncoder *encoder, CborType fpType, const void *value); + +CBOR_INLINE_API CborError cbor_encode_boolean(CborEncoder *encoder, bool value) +{ return cbor_encode_simple_value(encoder, (int)value - 1 + (CborBooleanType & 0x1f)); } +CBOR_INLINE_API CborError cbor_encode_null(CborEncoder *encoder) +{ return cbor_encode_simple_value(encoder, CborNullType & 0x1f); } +CBOR_INLINE_API CborError cbor_encode_undefined(CborEncoder *encoder) +{ return cbor_encode_simple_value(encoder, CborUndefinedType & 0x1f); } + +CBOR_INLINE_API CborError cbor_encode_half_float(CborEncoder *encoder, const void *value) +{ return cbor_encode_floating_point(encoder, CborHalfFloatType, value); } +CBOR_INLINE_API CborError cbor_encode_float(CborEncoder *encoder, float value) +{ return cbor_encode_floating_point(encoder, CborFloatType, &value); } +CBOR_INLINE_API CborError cbor_encode_double(CborEncoder *encoder, double value) +{ return cbor_encode_floating_point(encoder, CborDoubleType, &value); } + +CBOR_API CborError cbor_encoder_create_array(CborEncoder *encoder, CborEncoder *arrayEncoder, size_t length); +CBOR_API CborError cbor_encoder_create_map(CborEncoder *encoder, CborEncoder *mapEncoder, size_t length); +CBOR_API CborError cbor_encoder_close_container(CborEncoder *encoder, const CborEncoder *containerEncoder); +CBOR_API CborError cbor_encoder_close_container_checked(CborEncoder *encoder, const CborEncoder *containerEncoder); + +CBOR_INLINE_API uint8_t *_cbor_encoder_get_buffer_pointer(const CborEncoder *encoder) +{ + return encoder->data.ptr; +} + +CBOR_INLINE_API size_t cbor_encoder_get_buffer_size(const CborEncoder *encoder, const uint8_t *buffer) +{ + return (size_t)(encoder->data.ptr - buffer); +} + +CBOR_INLINE_API size_t cbor_encoder_get_extra_bytes_needed(const CborEncoder *encoder) +{ + return encoder->end ? 0 : (size_t)encoder->data.bytes_needed; +} +#endif /* CBOR_NO_ENCODER_API */ + +/* Parser API */ + +enum CborParserGlobalFlags +{ + CborParserFlag_ExternalSource = 0x01 +}; + +enum CborParserIteratorFlags +{ + /* used for all types, but not during string chunk iteration + * (values are static-asserted, don't change) */ + CborIteratorFlag_IntegerValueIs64Bit = 0x01, + CborIteratorFlag_IntegerValueTooLarge = 0x02, + + /* used only for CborIntegerType */ + CborIteratorFlag_NegativeInteger = 0x04, + + /* used only during string iteration */ + CborIteratorFlag_BeforeFirstStringChunk = 0x04, + CborIteratorFlag_IteratingStringChunks = 0x08, + + /* used for arrays, maps and strings, including during chunk iteration */ + CborIteratorFlag_UnknownLength = 0x10, + + /* used for maps, but must be kept for all types + * (ContainerIsMap value must be CborMapType - CborArrayType) */ + CborIteratorFlag_ContainerIsMap = 0x20, + CborIteratorFlag_NextIsMapKey = 0x40 +}; + +struct CborValue; +struct CborParserOperations +{ + bool (*can_read_bytes)(void *token, size_t len); + void *(*read_bytes)(void *token, void *dst, size_t offset, size_t len); + void (*advance_bytes)(void *token, size_t len); + CborError (*transfer_string)(void *token, const void **userptr, size_t offset, size_t len); +}; + +struct CborParser +{ + union { + const uint8_t *end; + const struct CborParserOperations *ops; + } source; + enum CborParserGlobalFlags flags; +}; +typedef struct CborParser CborParser; + +struct CborValue +{ + const CborParser *parser; + union { + const uint8_t *ptr; + void *token; + } source; + uint32_t remaining; + uint16_t extra; + uint8_t type; + uint8_t flags; +}; +typedef struct CborValue CborValue; + +#ifndef CBOR_NO_PARSER_API +CBOR_API CborError cbor_parser_init(const uint8_t *buffer, size_t size, uint32_t flags, CborParser *parser, CborValue *it); +CBOR_API CborError cbor_parser_init_reader(const struct CborParserOperations *ops, CborParser *parser, CborValue *it, void *token); + +CBOR_API CborError cbor_value_validate_basic(const CborValue *it); + +CBOR_INLINE_API bool cbor_value_at_end(const CborValue *it) +{ return it->remaining == 0; } +CBOR_INLINE_API const uint8_t *cbor_value_get_next_byte(const CborValue *it) +{ return it->source.ptr; } +CBOR_API CborError cbor_value_reparse(CborValue *it); +CBOR_API CborError cbor_value_advance_fixed(CborValue *it); +CBOR_API CborError cbor_value_advance(CborValue *it); +CBOR_INLINE_API bool cbor_value_is_container(const CborValue *it) +{ return it->type == CborArrayType || it->type == CborMapType; } +CBOR_API CborError cbor_value_enter_container(const CborValue *it, CborValue *recursed); +CBOR_API CborError cbor_value_leave_container(CborValue *it, const CborValue *recursed); + +CBOR_PRIVATE_API uint64_t _cbor_value_decode_int64_internal(const CborValue *value); +CBOR_INLINE_API uint64_t _cbor_value_extract_int64_helper(const CborValue *value) +{ + return value->flags & CborIteratorFlag_IntegerValueTooLarge ? + _cbor_value_decode_int64_internal(value) : value->extra; +} + +CBOR_INLINE_API bool cbor_value_is_valid(const CborValue *value) +{ return value && value->type != CborInvalidType; } +CBOR_INLINE_API CborType cbor_value_get_type(const CborValue *value) +{ return (CborType)value->type; } + +/* Null & undefined type */ +CBOR_INLINE_API bool cbor_value_is_null(const CborValue *value) +{ return value->type == CborNullType; } +CBOR_INLINE_API bool cbor_value_is_undefined(const CborValue *value) +{ return value->type == CborUndefinedType; } + +/* Booleans */ +CBOR_INLINE_API bool cbor_value_is_boolean(const CborValue *value) +{ return value->type == CborBooleanType; } +CBOR_INLINE_API CborError cbor_value_get_boolean(const CborValue *value, bool *result) +{ + assert(cbor_value_is_boolean(value)); + *result = !!value->extra; + return CborNoError; +} + +/* Simple types */ +CBOR_INLINE_API bool cbor_value_is_simple_type(const CborValue *value) +{ return value->type == CborSimpleType; } +CBOR_INLINE_API CborError cbor_value_get_simple_type(const CborValue *value, uint8_t *result) +{ + assert(cbor_value_is_simple_type(value)); + *result = (uint8_t)value->extra; + return CborNoError; +} + +/* Integers */ +CBOR_INLINE_API bool cbor_value_is_integer(const CborValue *value) +{ return value->type == CborIntegerType; } +CBOR_INLINE_API bool cbor_value_is_unsigned_integer(const CborValue *value) +{ return cbor_value_is_integer(value) && (value->flags & CborIteratorFlag_NegativeInteger) == 0; } +CBOR_INLINE_API bool cbor_value_is_negative_integer(const CborValue *value) +{ return cbor_value_is_integer(value) && (value->flags & CborIteratorFlag_NegativeInteger); } + +CBOR_INLINE_API CborError cbor_value_get_raw_integer(const CborValue *value, uint64_t *result) +{ + assert(cbor_value_is_integer(value)); + *result = _cbor_value_extract_int64_helper(value); + return CborNoError; +} + +CBOR_INLINE_API CborError cbor_value_get_uint64(const CborValue *value, uint64_t *result) +{ + assert(cbor_value_is_unsigned_integer(value)); + *result = _cbor_value_extract_int64_helper(value); + return CborNoError; +} + +CBOR_INLINE_API CborError cbor_value_get_int64(const CborValue *value, int64_t *result) +{ + assert(cbor_value_is_integer(value)); + *result = (int64_t) _cbor_value_extract_int64_helper(value); + if (value->flags & CborIteratorFlag_NegativeInteger) + *result = -*result - 1; + return CborNoError; +} + +CBOR_INLINE_API CborError cbor_value_get_int(const CborValue *value, int *result) +{ + assert(cbor_value_is_integer(value)); + *result = (int) _cbor_value_extract_int64_helper(value); + if (value->flags & CborIteratorFlag_NegativeInteger) + *result = -*result - 1; + return CborNoError; +} + +CBOR_API CborError cbor_value_get_int64_checked(const CborValue *value, int64_t *result); +CBOR_API CborError cbor_value_get_int_checked(const CborValue *value, int *result); + +CBOR_INLINE_API bool cbor_value_is_length_known(const CborValue *value) +{ return (value->flags & CborIteratorFlag_UnknownLength) == 0; } + +/* Tags */ +CBOR_INLINE_API bool cbor_value_is_tag(const CborValue *value) +{ return value->type == CborTagType; } +CBOR_INLINE_API CborError cbor_value_get_tag(const CborValue *value, CborTag *result) +{ + assert(cbor_value_is_tag(value)); + *result = _cbor_value_extract_int64_helper(value); + return CborNoError; +} +CBOR_API CborError cbor_value_skip_tag(CborValue *it); + +/* Strings */ +CBOR_INLINE_API bool cbor_value_is_byte_string(const CborValue *value) +{ return value->type == CborByteStringType; } +CBOR_INLINE_API bool cbor_value_is_text_string(const CborValue *value) +{ return value->type == CborTextStringType; } + +CBOR_INLINE_API CborError cbor_value_get_string_length(const CborValue *value, size_t *length) +{ + uint64_t v; + assert(cbor_value_is_byte_string(value) || cbor_value_is_text_string(value)); + if (!cbor_value_is_length_known(value)) + return CborErrorUnknownLength; + v = _cbor_value_extract_int64_helper(value); + *length = (size_t)v; + if (*length != v) + return CborErrorDataTooLarge; + return CborNoError; +} + +CBOR_PRIVATE_API CborError _cbor_value_copy_string(const CborValue *value, void *buffer, + size_t *buflen, CborValue *next); +CBOR_PRIVATE_API CborError _cbor_value_dup_string(const CborValue *value, void **buffer, + size_t *buflen, CborValue *next); + +CBOR_API CborError cbor_value_calculate_string_length(const CborValue *value, size_t *length); + +CBOR_INLINE_API CborError cbor_value_copy_text_string(const CborValue *value, char *buffer, + size_t *buflen, CborValue *next) +{ + assert(cbor_value_is_text_string(value)); + return _cbor_value_copy_string(value, buffer, buflen, next); +} +CBOR_INLINE_API CborError cbor_value_copy_byte_string(const CborValue *value, uint8_t *buffer, + size_t *buflen, CborValue *next) +{ + assert(cbor_value_is_byte_string(value)); + return _cbor_value_copy_string(value, buffer, buflen, next); +} + +CBOR_INLINE_API CborError cbor_value_dup_text_string(const CborValue *value, char **buffer, + size_t *buflen, CborValue *next) +{ + assert(cbor_value_is_text_string(value)); + return _cbor_value_dup_string(value, (void **)buffer, buflen, next); +} +CBOR_INLINE_API CborError cbor_value_dup_byte_string(const CborValue *value, uint8_t **buffer, + size_t *buflen, CborValue *next) +{ + assert(cbor_value_is_byte_string(value)); + return _cbor_value_dup_string(value, (void **)buffer, buflen, next); +} + +CBOR_PRIVATE_API CborError _cbor_value_get_string_chunk_size(const CborValue *value, size_t *len); +CBOR_INLINE_API CborError cbor_value_get_string_chunk_size(const CborValue *value, size_t *len) +{ + assert(value->flags & CborIteratorFlag_IteratingStringChunks); + return _cbor_value_get_string_chunk_size(value, len); +} + +CBOR_INLINE_API bool cbor_value_string_iteration_at_end(const CborValue *value) +{ + size_t dummy; + return cbor_value_get_string_chunk_size(value, &dummy) == CborErrorNoMoreStringChunks; +} + +CBOR_PRIVATE_API CborError _cbor_value_begin_string_iteration(CborValue *value); +CBOR_INLINE_API CborError cbor_value_begin_string_iteration(CborValue *value) +{ + assert(cbor_value_is_text_string(value) || cbor_value_is_byte_string(value)); + assert(!(value->flags & CborIteratorFlag_IteratingStringChunks)); + return _cbor_value_begin_string_iteration(value); +} + +CBOR_PRIVATE_API CborError _cbor_value_finish_string_iteration(CborValue *value); +CBOR_INLINE_API CborError cbor_value_finish_string_iteration(CborValue *value) +{ + assert(cbor_value_string_iteration_at_end(value)); + return _cbor_value_finish_string_iteration(value); +} + +CBOR_PRIVATE_API CborError _cbor_value_get_string_chunk(const CborValue *value, const void **bufferptr, + size_t *len, CborValue *next); +CBOR_INLINE_API CborError cbor_value_get_text_string_chunk(const CborValue *value, const char **bufferptr, + size_t *len, CborValue *next) +{ + assert(cbor_value_is_text_string(value)); + return _cbor_value_get_string_chunk(value, (const void **)bufferptr, len, next); +} +CBOR_INLINE_API CborError cbor_value_get_byte_string_chunk(const CborValue *value, const uint8_t **bufferptr, + size_t *len, CborValue *next) +{ + assert(cbor_value_is_byte_string(value)); + return _cbor_value_get_string_chunk(value, (const void **)bufferptr, len, next); +} + +CBOR_API CborError cbor_value_text_string_equals(const CborValue *value, const char *string, bool *result); + +/* Maps and arrays */ +CBOR_INLINE_API bool cbor_value_is_array(const CborValue *value) +{ return value->type == CborArrayType; } +CBOR_INLINE_API bool cbor_value_is_map(const CborValue *value) +{ return value->type == CborMapType; } + +CBOR_INLINE_API CborError cbor_value_get_array_length(const CborValue *value, size_t *length) +{ + uint64_t v; + assert(cbor_value_is_array(value)); + if (!cbor_value_is_length_known(value)) + return CborErrorUnknownLength; + v = _cbor_value_extract_int64_helper(value); + *length = (size_t)v; + if (*length != v) + return CborErrorDataTooLarge; + return CborNoError; +} + +CBOR_INLINE_API CborError cbor_value_get_map_length(const CborValue *value, size_t *length) +{ + uint64_t v; + assert(cbor_value_is_map(value)); + if (!cbor_value_is_length_known(value)) + return CborErrorUnknownLength; + v = _cbor_value_extract_int64_helper(value); + *length = (size_t)v; + if (*length != v) + return CborErrorDataTooLarge; + return CborNoError; +} + +CBOR_API CborError cbor_value_map_find_value(const CborValue *map, const char *string, CborValue *element); + +/* Floating point */ +CBOR_INLINE_API bool cbor_value_is_half_float(const CborValue *value) +{ return value->type == CborHalfFloatType; } +CBOR_INLINE_API CborError cbor_value_get_half_float(const CborValue *value, void *result) +{ + assert(cbor_value_is_half_float(value)); + assert((value->flags & CborIteratorFlag_IntegerValueTooLarge) == 0); + + /* size has been computed already */ + memcpy(result, &value->extra, sizeof(value->extra)); + return CborNoError; +} + +CBOR_INLINE_API bool cbor_value_is_float(const CborValue *value) +{ return value->type == CborFloatType; } +CBOR_INLINE_API CborError cbor_value_get_float(const CborValue *value, float *result) +{ + uint32_t data; + assert(cbor_value_is_float(value)); + assert(value->flags & CborIteratorFlag_IntegerValueTooLarge); + data = (uint32_t)_cbor_value_decode_int64_internal(value); + memcpy(result, &data, sizeof(*result)); + return CborNoError; +} + +CBOR_INLINE_API bool cbor_value_is_double(const CborValue *value) +{ return value->type == CborDoubleType; } +CBOR_INLINE_API CborError cbor_value_get_double(const CborValue *value, double *result) +{ + uint64_t data; + assert(cbor_value_is_double(value)); + assert(value->flags & CborIteratorFlag_IntegerValueTooLarge); + data = _cbor_value_decode_int64_internal(value); + memcpy(result, &data, sizeof(*result)); + return CborNoError; +} + +/* Validation API */ +#ifndef CBOR_NO_VALIDATION_API + +enum CborValidationFlags { + /* Bit mapping: + * bits 0-7 (8 bits): canonical format + * bits 8-11 (4 bits): canonical format & strict mode + * bits 12-20 (8 bits): strict mode + * bits 21-31 (10 bits): other + */ + + CborValidateShortestIntegrals = 0x0001, + CborValidateShortestFloatingPoint = 0x0002, + CborValidateShortestNumbers = CborValidateShortestIntegrals | CborValidateShortestFloatingPoint, + CborValidateNoIndeterminateLength = 0x0100, + CborValidateMapIsSorted = 0x0200 | CborValidateNoIndeterminateLength, + + CborValidateCanonicalFormat = 0x0fff, + + CborValidateMapKeysAreUnique = 0x1000 | CborValidateMapIsSorted, + CborValidateTagUse = 0x2000, + CborValidateUtf8 = 0x4000, + + CborValidateStrictMode = 0xfff00, + + CborValidateMapKeysAreString = 0x100000, + CborValidateNoUndefined = 0x200000, + CborValidateNoTags = 0x400000, + CborValidateFiniteFloatingPoint = 0x800000, + /* unused = 0x1000000, */ + /* unused = 0x2000000, */ + + CborValidateNoUnknownSimpleTypesSA = 0x4000000, + CborValidateNoUnknownSimpleTypes = 0x8000000 | CborValidateNoUnknownSimpleTypesSA, + CborValidateNoUnknownTagsSA = 0x10000000, + CborValidateNoUnknownTagsSR = 0x20000000 | CborValidateNoUnknownTagsSA, + CborValidateNoUnknownTags = 0x40000000 | CborValidateNoUnknownTagsSR, + + CborValidateCompleteData = (int)0x80000000, + + CborValidateStrictest = (int)~0U, + CborValidateBasic = 0 +}; + +CBOR_API CborError cbor_value_validate(const CborValue *it, uint32_t flags); +#endif /* CBOR_NO_VALIDATION_API */ + +/* Human-readable (dump) API */ +#ifndef CBOR_NO_PRETTY_API + +enum CborPrettyFlags { + CborPrettyNumericEncodingIndicators = 0x01, + CborPrettyTextualEncodingIndicators = 0, + + CborPrettyIndicateIndeterminateLength = 0x02, + CborPrettyIndicateIndetermineLength = CborPrettyIndicateIndeterminateLength, /* deprecated */ + CborPrettyIndicateOverlongNumbers = 0x04, + + CborPrettyShowStringFragments = 0x100, + CborPrettyMergeStringFragments = 0, + + CborPrettyDefaultFlags = CborPrettyIndicateIndeterminateLength +}; + +typedef CborError (*CborStreamFunction)(void *token, const char *fmt, ...) +#ifdef __GNUC__ + __attribute__((__format__(printf, 2, 3))) +#endif +; + +CBOR_API CborError cbor_value_to_pretty_stream(CborStreamFunction streamFunction, void *token, CborValue *value, int flags); + +/* The following API requires a hosted C implementation (uses FILE*) */ +#if !defined(__STDC_HOSTED__) || __STDC_HOSTED__-0 == 1 +CBOR_API CborError cbor_value_to_pretty_advance_flags(FILE *out, CborValue *value, int flags); +CBOR_API CborError cbor_value_to_pretty_advance(FILE *out, CborValue *value); +CBOR_INLINE_API CborError cbor_value_to_pretty(FILE *out, const CborValue *value) +{ + CborValue copy = *value; + return cbor_value_to_pretty_advance_flags(out, ©, CborPrettyDefaultFlags); +} +#endif /* __STDC_HOSTED__ check */ + +#endif /* CBOR_NO_PRETTY_API */ + +#endif /* CBOR_NO_PARSER_API */ + +#ifdef __cplusplus +} +#endif + +#endif /* CBOR_H */ + diff --git a/src/3rdparty/tinycbor/src/cborencoder.c b/src/3rdparty/tinycbor/src/cborencoder.c new file mode 100644 index 0000000000..52a4025be1 --- /dev/null +++ b/src/3rdparty/tinycbor/src/cborencoder.c @@ -0,0 +1,677 @@ +/**************************************************************************** +** +** Copyright (C) 2018 Intel Corporation +** +** 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 +** AUTHORS OR COPYRIGHT HOLDERS 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. +** +****************************************************************************/ + +#ifndef _BSD_SOURCE +#define _BSD_SOURCE 1 +#endif +#ifndef _DEFAULT_SOURCE +#define _DEFAULT_SOURCE 1 +#endif +#ifndef __STDC_LIMIT_MACROS +# define __STDC_LIMIT_MACROS 1 +#endif + +#include "cbor.h" +#include "cborinternal_p.h" +#include "compilersupport_p.h" + +#include <stdlib.h> +#include <string.h> + +/** + * \defgroup CborEncoding Encoding to CBOR + * \brief Group of functions used to encode data to CBOR. + * + * CborEncoder is used to encode data into a CBOR stream. The outermost + * CborEncoder is initialized by calling cbor_encoder_init(), with the buffer + * where the CBOR stream will be stored. The outermost CborEncoder is usually + * used to encode exactly one item, most often an array or map. It is possible + * to encode more than one item, but care must then be taken on the decoder + * side to ensure the state is reset after each item was decoded. + * + * Nested CborEncoder objects are created using cbor_encoder_create_array() and + * cbor_encoder_create_map(), later closed with cbor_encoder_close_container() + * or cbor_encoder_close_container_checked(). The pairs of creation and closing + * must be exactly matched and their parameters are always the same. + * + * CborEncoder writes directly to the user-supplied buffer, without extra + * buffering. CborEncoder does not allocate memory and CborEncoder objects are + * usually created on the stack of the encoding functions. + * + * The example below initializes a CborEncoder object with a buffer and encodes + * a single integer. + * + * \code + * uint8_t buf[16]; + * CborEncoder encoder; + * cbor_encoder_init(&encoder, &buf, sizeof(buf), 0); + * cbor_encode_int(&encoder, some_value); + * \endcode + * + * As explained before, usually the outermost CborEncoder object is used to add + * one array or map, which in turn contains multiple elements. The example + * below creates a CBOR map with one element: a key "foo" and a boolean value. + * + * \code + * uint8_t buf[16]; + * CborEncoder encoder, mapEncoder; + * cbor_encoder_init(&encoder, &buf, sizeof(buf), 0); + * cbor_encoder_create_map(&encoder, &mapEncoder, 1); + * cbor_encode_text_stringz(&mapEncoder, "foo"); + * cbor_encode_boolean(&mapEncoder, some_value); + * cbor_encoder_close_container(&encoder, &mapEncoder); + * \endcode + * + * <h3 class="groupheader">Error checking and buffer size</h3> + * + * All functions operating on CborEncoder return a condition of type CborError. + * If the encoding was successful, they return CborNoError. Some functions do + * extra checking on the input provided and may return some other error + * conditions (for example, cbor_encode_simple_value() checks that the type is + * of the correct type). + * + * In addition, all functions check whether the buffer has enough bytes to + * encode the item being appended. If that is not possible, they return + * CborErrorOutOfMemory. + * + * It is possible to continue with the encoding of data past the first function + * that returns CborErrorOutOfMemory. CborEncoder functions will not overrun + * the buffer, but will instead count how many more bytes are needed to + * complete the encoding. At the end, you can obtain that count by calling + * cbor_encoder_get_extra_bytes_needed(). + * + * \section1 Finalizing the encoding + * + * Once all items have been appended and the containers have all been properly + * closed, the user-supplied buffer will contain the CBOR stream and may be + * immediately used. To obtain the size of the buffer, call + * cbor_encoder_get_buffer_size() with the original buffer pointer. + * + * The example below illustrates how one can encode an item with error checking + * and then pass on the buffer for network sending. + * + * \code + * uint8_t buf[16]; + * CborError err; + * CborEncoder encoder, mapEncoder; + * cbor_encoder_init(&encoder, &buf, sizeof(buf), 0); + * err = cbor_encoder_create_map(&encoder, &mapEncoder, 1); + * if (!err) + * return err; + * err = cbor_encode_text_stringz(&mapEncoder, "foo"); + * if (!err) + * return err; + * err = cbor_encode_boolean(&mapEncoder, some_value); + * if (!err) + * return err; + * err = cbor_encoder_close_container_checked(&encoder, &mapEncoder); + * if (!err) + * return err; + * + * size_t len = cbor_encoder_get_buffer_size(&encoder, buf); + * send_payload(buf, len); + * return CborNoError; + * \endcode + * + * Finally, the example below expands on the one above and also + * deals with dynamically growing the buffer if the initial allocation wasn't + * big enough. Note the two places where the error checking was replaced with + * an cbor_assertion, showing where the author assumes no error can occur. + * + * \code + * uint8_t *encode_string_array(const char **strings, int n, size_t *bufsize) + * { + * CborError err; + * CborEncoder encoder, arrayEncoder; + * size_t size = 256; + * uint8_t *buf = NULL; + * + * while (1) { + * int i; + * size_t more_bytes; + * uint8_t *nbuf = realloc(buf, size); + * if (nbuf == NULL) + * goto error; + * buf = nbuf; + * + * cbor_encoder_init(&encoder, &buf, size, 0); + * err = cbor_encoder_create_array(&encoder, &arrayEncoder, n); + * cbor_assert(err); // can't fail, the buffer is always big enough + * + * for (i = 0; i < n; ++i) { + * err = cbor_encode_text_stringz(&arrayEncoder, strings[i]); + * if (err && err != CborErrorOutOfMemory) + * goto error; + * } + * + * err = cbor_encoder_close_container_checked(&encoder, &arrayEncoder); + * cbor_assert(err); // shouldn't fail! + * + * more_bytes = cbor_encoder_get_extra_bytes_needed(encoder); + * if (more_size) { + * // buffer wasn't big enough, try again + * size += more_bytes; + * continue; + * } + * + * *bufsize = cbor_encoder_get_buffer_size(encoder, buf); + * return buf; + * } + * error: + * free(buf); + * return NULL; + * } + * \endcode + */ + +/** + * \addtogroup CborEncoding + * @{ + */ + +/** + * \struct CborEncoder + * Structure used to encode to CBOR. + */ + +/** + * Initializes a CborEncoder structure \a encoder by pointing it to buffer \a + * buffer of size \a size. The \a flags field is currently unused and must be + * zero. + */ +void cbor_encoder_init(CborEncoder *encoder, uint8_t *buffer, size_t size, int flags) +{ + encoder->data.ptr = buffer; + encoder->end = buffer + size; + encoder->remaining = 2; + encoder->flags = flags; +} + +void cbor_encoder_init_writer(CborEncoder *encoder, CborEncoderWriteFunction writer, void *token) +{ +#ifdef CBOR_ENCODER_WRITE_FUNCTION + (void) writer; +#else + encoder->data.writer = writer; +#endif + encoder->end = (uint8_t *)token; + encoder->remaining = 2; + encoder->flags = CborIteratorFlag_WriterFunction; +} + +static inline void put16(void *where, uint16_t v) +{ + v = cbor_htons(v); + memcpy(where, &v, sizeof(v)); +} + +/* Note: Since this is currently only used in situations where OOM is the only + * valid error, we KNOW this to be true. Thus, this function now returns just 'true', + * but if in the future, any function starts returning a non-OOM error, this will need + * to be changed to the test. At the moment, this is done to prevent more branches + * being created in the tinycbor output */ +static inline bool isOomError(CborError err) +{ + if (CBOR_ENCODER_WRITER_CONTROL < 0) + return true; + + /* CborErrorOutOfMemory is the only negative error code, intentionally + * so we can write the test like this */ + return (int)err < 0; +} + +static inline void put32(void *where, uint32_t v) +{ + v = cbor_htonl(v); + memcpy(where, &v, sizeof(v)); +} + +static inline void put64(void *where, uint64_t v) +{ + v = cbor_htonll(v); + memcpy(where, &v, sizeof(v)); +} + +static inline bool would_overflow(CborEncoder *encoder, size_t len) +{ + ptrdiff_t remaining = (ptrdiff_t)encoder->end; + remaining -= remaining ? (ptrdiff_t)encoder->data.ptr : encoder->data.bytes_needed; + remaining -= (ptrdiff_t)len; + return unlikely(remaining < 0); +} + +static inline void advance_ptr(CborEncoder *encoder, size_t n) +{ + if (encoder->end) + encoder->data.ptr += n; + else + encoder->data.bytes_needed += n; +} + +static inline CborError append_to_buffer(CborEncoder *encoder, const void *data, size_t len, + CborEncoderAppendType appendType) +{ + if (CBOR_ENCODER_WRITER_CONTROL >= 0) { + if (encoder->flags & CborIteratorFlag_WriterFunction || CBOR_ENCODER_WRITER_CONTROL != 0) { +# ifdef CBOR_ENCODER_WRITE_FUNCTION + return CBOR_ENCODER_WRITE_FUNCTION(encoder->end, data, len, appendType); +# else + return encoder->data.writer(encoder->end, data, len, appendType); +# endif + } + } + +#if CBOR_ENCODER_WRITER_CONTROL <= 0 + if (would_overflow(encoder, len)) { + if (encoder->end != NULL) { + len -= encoder->end - encoder->data.ptr; + encoder->end = NULL; + encoder->data.bytes_needed = 0; + } + + advance_ptr(encoder, len); + return CborErrorOutOfMemory; + } + + memcpy(encoder->data.ptr, data, len); + encoder->data.ptr += len; +#endif + return CborNoError; +} + +static inline CborError append_byte_to_buffer(CborEncoder *encoder, uint8_t byte) +{ + return append_to_buffer(encoder, &byte, 1, CborEncoderAppendCborData); +} + +static inline CborError encode_number_no_update(CborEncoder *encoder, uint64_t ui, uint8_t shiftedMajorType) +{ + /* Little-endian would have been so much more convenient here: + * We could just write at the beginning of buf but append_to_buffer + * only the necessary bytes. + * Since it has to be big endian, do it the other way around: + * write from the end. */ + uint64_t buf[2]; + uint8_t *const bufend = (uint8_t *)buf + sizeof(buf); + uint8_t *bufstart = bufend - 1; + put64(buf + 1, ui); /* we probably have a bunch of zeros in the beginning */ + + if (ui < Value8Bit) { + *bufstart += shiftedMajorType; + } else { + uint8_t more = 0; + if (ui > 0xffU) + ++more; + if (ui > 0xffffU) + ++more; + if (ui > 0xffffffffU) + ++more; + bufstart -= (size_t)1 << more; + *bufstart = shiftedMajorType + Value8Bit + more; + } + + return append_to_buffer(encoder, bufstart, bufend - bufstart, CborEncoderAppendCborData); +} + +static inline void saturated_decrement(CborEncoder *encoder) +{ + if (encoder->remaining) + --encoder->remaining; +} + +static inline CborError encode_number(CborEncoder *encoder, uint64_t ui, uint8_t shiftedMajorType) +{ + saturated_decrement(encoder); + return encode_number_no_update(encoder, ui, shiftedMajorType); +} + +/** + * Appends the unsigned 64-bit integer \a value to the CBOR stream provided by + * \a encoder. + * + * \sa cbor_encode_negative_int, cbor_encode_int + */ +CborError cbor_encode_uint(CborEncoder *encoder, uint64_t value) +{ + return encode_number(encoder, value, UnsignedIntegerType << MajorTypeShift); +} + +/** + * Appends the negative 64-bit integer whose absolute value is \a + * absolute_value to the CBOR stream provided by \a encoder. + * + * If the value \a absolute_value is zero, this function encodes -2^64. + * + * \sa cbor_encode_uint, cbor_encode_int + */ +CborError cbor_encode_negative_int(CborEncoder *encoder, uint64_t absolute_value) +{ + return encode_number(encoder, absolute_value - 1, NegativeIntegerType << MajorTypeShift); +} + +/** + * Appends the signed 64-bit integer \a value to the CBOR stream provided by + * \a encoder. + * + * \sa cbor_encode_negative_int, cbor_encode_uint + */ +CborError cbor_encode_int(CborEncoder *encoder, int64_t value) +{ + /* adapted from code in RFC 7049 appendix C (pseudocode) */ + uint64_t ui = value >> 63; /* extend sign to whole length */ + uint8_t majorType = ui & 0x20; /* extract major type */ + ui ^= value; /* complement negatives */ + return encode_number(encoder, ui, majorType); +} + +/** + * Appends the CBOR Simple Type of value \a value to the CBOR stream provided by + * \a encoder. + * + * This function may return error CborErrorIllegalSimpleType if the \a value + * variable contains a number that is not a valid simple type. + */ +CborError cbor_encode_simple_value(CborEncoder *encoder, uint8_t value) +{ +#ifndef CBOR_ENCODER_NO_CHECK_USER + /* check if this is a valid simple type */ + if (value >= HalfPrecisionFloat && value <= Break) + return CborErrorIllegalSimpleType; +#endif + return encode_number(encoder, value, SimpleTypesType << MajorTypeShift); +} + +/** + * Appends the floating-point value of type \a fpType and pointed to by \a + * value to the CBOR stream provided by \a encoder. The value of \a fpType must + * be one of CborHalfFloatType, CborFloatType or CborDoubleType, otherwise the + * behavior of this function is undefined. + * + * This function is useful for code that needs to pass through floating point + * values but does not wish to have the actual floating-point code. + * + * \sa cbor_encode_half_float, cbor_encode_float, cbor_encode_double + */ +CborError cbor_encode_floating_point(CborEncoder *encoder, CborType fpType, const void *value) +{ + unsigned size; + uint8_t buf[1 + sizeof(uint64_t)]; + cbor_assert(fpType == CborHalfFloatType || fpType == CborFloatType || fpType == CborDoubleType); + buf[0] = fpType; + + size = 2U << (fpType - CborHalfFloatType); + if (size == 8) + put64(buf + 1, *(const uint64_t*)value); + else if (size == 4) + put32(buf + 1, *(const uint32_t*)value); + else + put16(buf + 1, *(const uint16_t*)value); + saturated_decrement(encoder); + return append_to_buffer(encoder, buf, size + 1, CborEncoderAppendCborData); +} + +/** + * Appends the CBOR tag \a tag to the CBOR stream provided by \a encoder. + * + * \sa CborTag + */ +CborError cbor_encode_tag(CborEncoder *encoder, CborTag tag) +{ + /* tags don't count towards the number of elements in an array or map */ + return encode_number_no_update(encoder, tag, TagType << MajorTypeShift); +} + +static CborError encode_string(CborEncoder *encoder, size_t length, uint8_t shiftedMajorType, const void *string) +{ + CborError err = encode_number(encoder, length, shiftedMajorType); + if (err && !isOomError(err)) + return err; + return append_to_buffer(encoder, string, length, CborEncoderAppendStringData); +} + +/** + * \fn CborError cbor_encode_text_stringz(CborEncoder *encoder, const char *string) + * + * Appends the null-terminated text string \a string to the CBOR stream + * provided by \a encoder. CBOR requires that \a string be valid UTF-8, but + * TinyCBOR makes no verification of correctness. The terminating null is not + * included in the stream. + * + * \sa cbor_encode_text_string, cbor_encode_byte_string + */ + +/** + * Appends the text string \a string of length \a length to the CBOR stream + * provided by \a encoder. CBOR requires that \a string be valid UTF-8, but + * TinyCBOR makes no verification of correctness. + * + * \sa CborError cbor_encode_text_stringz, cbor_encode_byte_string + */ +CborError cbor_encode_byte_string(CborEncoder *encoder, const uint8_t *string, size_t length) +{ + return encode_string(encoder, length, ByteStringType << MajorTypeShift, string); +} + +/** + * Appends the byte string \a string of length \a length to the CBOR stream + * provided by \a encoder. CBOR byte strings are arbitrary raw data. + * + * \sa cbor_encode_text_stringz, cbor_encode_text_string + */ +CborError cbor_encode_text_string(CborEncoder *encoder, const char *string, size_t length) +{ + return encode_string(encoder, length, TextStringType << MajorTypeShift, string); +} + +#ifdef __GNUC__ +__attribute__((noinline)) +#endif +static CborError create_container(CborEncoder *encoder, CborEncoder *container, size_t length, uint8_t shiftedMajorType) +{ + CborError err; + container->data.ptr = encoder->data.ptr; + container->end = encoder->end; + saturated_decrement(encoder); + container->remaining = length + 1; /* overflow ok on CborIndefiniteLength */ + + cbor_static_assert((int)CborIteratorFlag_ContainerIsMap_ == (int)CborIteratorFlag_ContainerIsMap); + cbor_static_assert(((MapType << MajorTypeShift) & CborIteratorFlag_ContainerIsMap) == CborIteratorFlag_ContainerIsMap); + cbor_static_assert(((ArrayType << MajorTypeShift) & CborIteratorFlag_ContainerIsMap) == 0); + container->flags = shiftedMajorType & CborIteratorFlag_ContainerIsMap; + if (CBOR_ENCODER_WRITER_CONTROL == 0) + container->flags |= encoder->flags & CborIteratorFlag_WriterFunction; + + if (length == CborIndefiniteLength) { + container->flags |= CborIteratorFlag_UnknownLength; + err = append_byte_to_buffer(container, shiftedMajorType + IndefiniteLength); + } else { + if (shiftedMajorType & CborIteratorFlag_ContainerIsMap) + container->remaining += length; + err = encode_number_no_update(container, length, shiftedMajorType); + } + return err; +} + +/** + * Creates a CBOR array in the CBOR stream provided by \a encoder and + * initializes \a arrayEncoder so that items can be added to the array using + * the CborEncoder functions. The array must be terminated by calling either + * cbor_encoder_close_container() or cbor_encoder_close_container_checked() + * with the same \a encoder and \a arrayEncoder parameters. + * + * The number of items inserted into the array must be exactly \a length items, + * otherwise the stream is invalid. If the number of items is not known when + * creating the array, the constant \ref CborIndefiniteLength may be passed as + * length instead. + * + * \sa cbor_encoder_create_map + */ +CborError cbor_encoder_create_array(CborEncoder *encoder, CborEncoder *arrayEncoder, size_t length) +{ + return create_container(encoder, arrayEncoder, length, ArrayType << MajorTypeShift); +} + +/** + * Creates a CBOR map in the CBOR stream provided by \a encoder and + * initializes \a mapEncoder so that items can be added to the map using + * the CborEncoder functions. The map must be terminated by calling either + * cbor_encoder_close_container() or cbor_encoder_close_container_checked() + * with the same \a encoder and \a mapEncoder parameters. + * + * The number of pair of items inserted into the map must be exactly \a length + * items, otherwise the stream is invalid. If the number is not known + * when creating the map, the constant \ref CborIndefiniteLength may be passed as + * length instead. + * + * \b{Implementation limitation:} TinyCBOR cannot encode more than SIZE_MAX/2 + * key-value pairs in the stream. If the length \a length is larger than this + * value (and is not \ref CborIndefiniteLength), this function returns error + * CborErrorDataTooLarge. + * + * \sa cbor_encoder_create_array + */ +CborError cbor_encoder_create_map(CborEncoder *encoder, CborEncoder *mapEncoder, size_t length) +{ + if (length != CborIndefiniteLength && length > SIZE_MAX / 2) + return CborErrorDataTooLarge; + return create_container(encoder, mapEncoder, length, MapType << MajorTypeShift); +} + +/** + * Closes the CBOR container (array or map) provided by \a containerEncoder and + * updates the CBOR stream provided by \a encoder. Both parameters must be the + * same as were passed to cbor_encoder_create_array() or + * cbor_encoder_create_map(). + * + * Since version 0.5, this function verifies that the number of items (or pairs + * of items, in the case of a map) was correct. It is no longer necessary to call + * cbor_encoder_close_container_checked() instead. + * + * \sa cbor_encoder_create_array(), cbor_encoder_create_map() + */ +CborError cbor_encoder_close_container(CborEncoder *encoder, const CborEncoder *containerEncoder) +{ + if (encoder->end && !(encoder->flags & CborIteratorFlag_WriterFunction)) + encoder->data.ptr = containerEncoder->data.ptr; + else + encoder->data.bytes_needed = containerEncoder->data.bytes_needed; + encoder->end = containerEncoder->end; + if (containerEncoder->flags & CborIteratorFlag_UnknownLength) + return append_byte_to_buffer(encoder, BreakByte); + + if (containerEncoder->remaining != 1) + return containerEncoder->remaining == 0 ? CborErrorTooManyItems : CborErrorTooFewItems; + + if (!encoder->end) + return CborErrorOutOfMemory; /* keep the state */ + return CborNoError; +} + +/** + * \fn CborError cbor_encode_boolean(CborEncoder *encoder, bool value) + * + * Appends the boolean value \a value to the CBOR stream provided by \a encoder. + */ + +/** + * \fn CborError cbor_encode_null(CborEncoder *encoder) + * + * Appends the CBOR type representing a null value to the CBOR stream provided + * by \a encoder. + * + * \sa cbor_encode_undefined() + */ + +/** + * \fn CborError cbor_encode_undefined(CborEncoder *encoder) + * + * Appends the CBOR type representing an undefined value to the CBOR stream + * provided by \a encoder. + * + * \sa cbor_encode_null() + */ + +/** + * \fn CborError cbor_encode_half_float(CborEncoder *encoder, const void *value) + * + * Appends the IEEE 754 half-precision (16-bit) floating point value pointed to + * by \a value to the CBOR stream provided by \a encoder. + * + * \sa cbor_encode_floating_point(), cbor_encode_float(), cbor_encode_double() + */ + +/** + * \fn CborError cbor_encode_float(CborEncoder *encoder, float value) + * + * Appends the IEEE 754 single-precision (32-bit) floating point value \a value + * to the CBOR stream provided by \a encoder. + * + * \sa cbor_encode_floating_point(), cbor_encode_half_float(), cbor_encode_double() + */ + +/** + * \fn CborError cbor_encode_double(CborEncoder *encoder, double value) + * + * Appends the IEEE 754 double-precision (64-bit) floating point value \a value + * to the CBOR stream provided by \a encoder. + * + * \sa cbor_encode_floating_point(), cbor_encode_half_float(), cbor_encode_float() + */ + +/** + * \fn size_t cbor_encoder_get_buffer_size(const CborEncoder *encoder, const uint8_t *buffer) + * + * Returns the total size of the buffer starting at \a buffer after the + * encoding finished without errors. The \a encoder and \a buffer arguments + * must be the same as supplied to cbor_encoder_init(). + * + * If the encoding process had errors, the return value of this function is + * meaningless. If the only errors were CborErrorOutOfMemory, instead use + * cbor_encoder_get_extra_bytes_needed() to find out by how much to grow the + * buffer before encoding again. + * + * See \ref CborEncoding for an example of using this function. + * + * \sa cbor_encoder_init(), cbor_encoder_get_extra_bytes_needed(), CborEncoding + */ + +/** + * \fn size_t cbor_encoder_get_extra_bytes_needed(const CborEncoder *encoder) + * + * Returns how many more bytes the original buffer supplied to + * cbor_encoder_init() needs to be extended by so that no CborErrorOutOfMemory + * condition will happen for the encoding. If the buffer was big enough, this + * function returns 0. The \a encoder must be the original argument as passed + * to cbor_encoder_init(). + * + * This function is usually called after an encoding sequence ended with one or + * more CborErrorOutOfMemory errors, but no other error. If any other error + * happened, the return value of this function is meaningless. + * + * See \ref CborEncoding for an example of using this function. + * + * \sa cbor_encoder_init(), cbor_encoder_get_buffer_size(), CborEncoding + */ + +/** @} */ diff --git a/src/3rdparty/tinycbor/src/cborerrorstrings.c b/src/3rdparty/tinycbor/src/cborerrorstrings.c new file mode 100644 index 0000000000..1dd8ae25bd --- /dev/null +++ b/src/3rdparty/tinycbor/src/cborerrorstrings.c @@ -0,0 +1,188 @@ +/**************************************************************************** +** +** Copyright (C) 2018 Intel Corporation +** +** 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 +** AUTHORS OR COPYRIGHT HOLDERS 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. +** +****************************************************************************/ + +#include "cbor.h" + +#ifndef _ +# define _(msg) msg +#endif + +/** + * \enum CborError + * \ingroup CborGlobals + * The CborError enum contains the possible error values used by the CBOR encoder and decoder. + * + * TinyCBOR functions report success by returning CborNoError, or one error + * condition by returning one of the values below. One exception is the + * out-of-memory condition (CborErrorOutOfMemory), which the functions for \ref + * CborEncoding may report in bit-wise OR with other conditions. + * + * This technique allows code to determine whether the only error condition was + * a lack of buffer space, which may not be a fatal condition if the buffer can + * be resized. Additionally, the functions for \ref CborEncoding may continue + * to be used even after CborErrorOutOfMemory is returned, and instead they + * will simply calculate the extra space needed. + * + * \value CborNoError No error occurred + * \omitvalue CborUnknownError + * \value CborErrorUnknownLength Request for the length of an array, map or string whose length is not provided in the CBOR stream + * \value CborErrorAdvancePastEOF Not enough data in the stream to decode item (decoding would advance past end of stream) + * \value CborErrorIO An I/O error occurred, probably due to an out-of-memory situation + * \value CborErrorGarbageAtEnd Bytes exist past the end of the CBOR stream + * \value CborErrorUnexpectedEOF End of stream reached unexpectedly + * \value CborErrorUnexpectedBreak A CBOR break byte was found where not expected + * \value CborErrorUnknownType An unknown type (future extension to CBOR) was found in the stream + * \value CborErrorIllegalType An invalid type was found while parsing a chunked CBOR string + * \value CborErrorIllegalNumber An illegal initial byte (encoding unspecified additional information) was found + * \value CborErrorIllegalSimpleType An illegal encoding of a CBOR Simple Type of value less than 32 was found + * \omitvalue CborErrorUnknownSimpleType + * \omitvalue CborErrorUnknownTag + * \omitvalue CborErrorInappropriateTagForType + * \omitvalue CborErrorDuplicateObjectKeys + * \value CborErrorInvalidUtf8TextString Illegal UTF-8 encoding found while parsing CBOR Text String + * \value CborErrorTooManyItems Too many items were added to CBOR map or array of pre-determined length + * \value CborErrorTooFewItems Too few items were added to CBOR map or array of pre-determined length + * \value CborErrorDataTooLarge Data item size exceeds TinyCBOR's implementation limits + * \value CborErrorNestingTooDeep Data item nesting exceeds TinyCBOR's implementation limits + * \omitvalue CborErrorUnsupportedType + * \value CborErrorJsonObjectKeyIsAggregate Conversion to JSON failed because the key in a map is a CBOR map or array + * \value CborErrorJsonObjectKeyNotString Conversion to JSON failed because the key in a map is not a text string + * \value CborErrorOutOfMemory During CBOR encoding, the buffer provided is insufficient for encoding the data item; + * in other situations, TinyCBOR failed to allocate memory + * \value CborErrorInternalError An internal error occurred in TinyCBOR + */ + +/** + * \ingroup CborGlobals + * Returns the error string corresponding to the CBOR error condition \a error. + */ +const char *cbor_error_string(CborError error) +{ + switch (error) { + case CborNoError: + return ""; + + case CborUnknownError: + return _("unknown error"); + + case CborErrorOutOfMemory: + return _("out of memory/need more memory"); + + case CborErrorUnknownLength: + return _("unknown length (attempted to get the length of a map/array/string of indeterminate length"); + + case CborErrorAdvancePastEOF: + return _("attempted to advance past EOF"); + + case CborErrorIO: + return _("I/O error"); + + case CborErrorGarbageAtEnd: + return _("garbage after the end of the content"); + + case CborErrorUnexpectedEOF: + return _("unexpected end of data"); + + case CborErrorUnexpectedBreak: + return _("unexpected 'break' byte"); + + case CborErrorUnknownType: + return _("illegal byte (encodes future extension type)"); + + case CborErrorIllegalType: + return _("mismatched string type in chunked string"); + + case CborErrorIllegalNumber: + return _("illegal initial byte (encodes unspecified additional information)"); + + case CborErrorIllegalSimpleType: + return _("illegal encoding of simple type smaller than 32"); + + case CborErrorNoMoreStringChunks: + return _("no more byte or text strings available"); + + case CborErrorUnknownSimpleType: + return _("unknown simple type"); + + case CborErrorUnknownTag: + return _("unknown tag"); + + case CborErrorInappropriateTagForType: + return _("inappropriate tag for type"); + + case CborErrorDuplicateObjectKeys: + return _("duplicate keys in object"); + + case CborErrorInvalidUtf8TextString: + return _("invalid UTF-8 content in string"); + + case CborErrorExcludedType: + return _("excluded type found"); + + case CborErrorExcludedValue: + return _("excluded value found"); + + case CborErrorImproperValue: + case CborErrorOverlongEncoding: + return _("value encoded in non-canonical form"); + + case CborErrorMapKeyNotString: + case CborErrorJsonObjectKeyNotString: + return _("key in map is not a string"); + + case CborErrorMapNotSorted: + return _("map is not sorted"); + + case CborErrorMapKeysNotUnique: + return _("map keys are not unique"); + + case CborErrorTooManyItems: + return _("too many items added to encoder"); + + case CborErrorTooFewItems: + return _("too few items added to encoder"); + + case CborErrorDataTooLarge: + return _("internal error: data too large"); + + case CborErrorNestingTooDeep: + return _("internal error: too many nested containers found in recursive function"); + + case CborErrorUnsupportedType: + return _("unsupported type"); + + case CborErrorUnimplementedValidation: + return _("validation not implemented for the current parser state"); + + case CborErrorJsonObjectKeyIsAggregate: + return _("conversion to JSON failed: key in object is an array or map"); + + case CborErrorJsonNotImplemented: + return _("conversion to JSON failed: open_memstream unavailable"); + + case CborErrorInternalError: + return _("internal error"); + } + return cbor_error_string(CborUnknownError); +} diff --git a/src/3rdparty/tinycbor/src/cborinternal_p.h b/src/3rdparty/tinycbor/src/cborinternal_p.h new file mode 100644 index 0000000000..8d77f28466 --- /dev/null +++ b/src/3rdparty/tinycbor/src/cborinternal_p.h @@ -0,0 +1,245 @@ +/**************************************************************************** +** +** Copyright (C) 2018 Intel Corporation +** +** 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 +** AUTHORS OR COPYRIGHT HOLDERS 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. +** +****************************************************************************/ + +#ifndef CBORINTERNAL_P_H +#define CBORINTERNAL_P_H + +#include "compilersupport_p.h" + +#ifndef CBOR_INTERNAL_API +# define CBOR_INTERNAL_API +#endif + +#ifndef CBOR_PARSER_MAX_RECURSIONS +# define CBOR_PARSER_MAX_RECURSIONS 1024 +#endif + +#ifndef CBOR_ENCODER_WRITER_CONTROL +# define CBOR_ENCODER_WRITER_CONTROL 0 +#endif +#ifndef CBOR_PARSER_READER_CONTROL +# define CBOR_PARSER_READER_CONTROL 0 +#endif + +/* + * CBOR Major types + * Encoded in the high 3 bits of the descriptor byte + * See http://tools.ietf.org/html/rfc7049#section-2.1 + */ +typedef enum CborMajorTypes { + UnsignedIntegerType = 0U, + NegativeIntegerType = 1U, + ByteStringType = 2U, + TextStringType = 3U, + ArrayType = 4U, + MapType = 5U, /* a.k.a. object */ + TagType = 6U, + SimpleTypesType = 7U +} CborMajorTypes; + +/* + * CBOR simple and floating point types + * Encoded in the low 8 bits of the descriptor byte when the + * Major Type is 7. + */ +typedef enum CborSimpleTypes { + FalseValue = 20, + TrueValue = 21, + NullValue = 22, + UndefinedValue = 23, + SimpleTypeInNextByte = 24, /* not really a simple type */ + HalfPrecisionFloat = 25, /* ditto */ + SinglePrecisionFloat = 26, /* ditto */ + DoublePrecisionFloat = 27, /* ditto */ + Break = 31 +} CborSimpleTypes; + +enum { + SmallValueBitLength = 5U, + SmallValueMask = (1U << SmallValueBitLength) - 1, /* 31 */ + Value8Bit = 24U, + Value16Bit = 25U, + Value32Bit = 26U, + Value64Bit = 27U, + IndefiniteLength = 31U, + + MajorTypeShift = SmallValueBitLength, + MajorTypeMask = (int) (~0U << MajorTypeShift), + + BreakByte = (unsigned)Break | (SimpleTypesType << MajorTypeShift) +}; + +static inline void copy_current_position(CborValue *dst, const CborValue *src) +{ + /* This "if" is here for pedantry only: the two branches should perform + * the same memory operation. */ + if (src->parser->flags & CborParserFlag_ExternalSource) + dst->source.token = src->source.token; + else + dst->source.ptr = src->source.ptr; +} + +static inline bool can_read_bytes(const CborValue *it, size_t n) +{ + if (CBOR_PARSER_READER_CONTROL >= 0) { + if (it->parser->flags & CborParserFlag_ExternalSource || CBOR_PARSER_READER_CONTROL != 0) { +#ifdef CBOR_PARSER_CAN_READ_BYTES_FUNCTION + return CBOR_PARSER_CAN_READ_BYTES_FUNCTION(it->source.token, n); +#else + return it->parser->source.ops->can_read_bytes(it->source.token, n); +#endif + } + } + + /* Convert the pointer subtraction to size_t since end >= ptr + * (this prevents issues with (ptrdiff_t)n becoming negative). + */ + return (size_t)(it->parser->source.end - it->source.ptr) >= n; +} + +static inline void advance_bytes(CborValue *it, size_t n) +{ + if (CBOR_PARSER_READER_CONTROL >= 0) { + if (it->parser->flags & CborParserFlag_ExternalSource || CBOR_PARSER_READER_CONTROL != 0) { +#ifdef CBOR_PARSER_ADVANCE_BYTES_FUNCTION + CBOR_PARSER_ADVANCE_BYTES_FUNCTION(it->source.token, n); +#else + it->parser->source.ops->advance_bytes(it->source.token, n); +#endif + return; + } + } + + it->source.ptr += n; +} + +static inline CborError transfer_string(CborValue *it, const void **ptr, size_t offset, size_t len) +{ + if (CBOR_PARSER_READER_CONTROL >= 0) { + if (it->parser->flags & CborParserFlag_ExternalSource || CBOR_PARSER_READER_CONTROL != 0) { +#ifdef CBOR_PARSER_TRANSFER_STRING_FUNCTION + return CBOR_PARSER_TRANSFER_STRING_FUNCTION(it->source.token, ptr, offset, len); +#else + return it->parser->source.ops->transfer_string(it->source.token, ptr, offset, len); +#endif + } + } + + it->source.ptr += offset; + if (can_read_bytes(it, len)) { + *CONST_CAST(const void **, ptr) = it->source.ptr; + it->source.ptr += len; + return CborNoError; + } + return CborErrorUnexpectedEOF; +} + +static inline void *read_bytes_unchecked(const CborValue *it, void *dst, size_t offset, size_t n) +{ + if (CBOR_PARSER_READER_CONTROL >= 0) { + if (it->parser->flags & CborParserFlag_ExternalSource || CBOR_PARSER_READER_CONTROL != 0) { +#ifdef CBOR_PARSER_READ_BYTES_FUNCTION + return CBOR_PARSER_READ_BYTES_FUNCTION(it->source.token, dst, offset, n); +#else + return it->parser->source.ops->read_bytes(it->source.token, dst, offset, n); +#endif + } + } + + return memcpy(dst, it->source.ptr + offset, n); +} + +#ifdef __GNUC__ +__attribute__((warn_unused_result)) +#endif +static inline void *read_bytes(const CborValue *it, void *dst, size_t offset, size_t n) +{ + if (can_read_bytes(it, offset + n)) + return read_bytes_unchecked(it, dst, offset, n); + return NULL; +} + +static inline uint16_t read_uint8(const CborValue *it, size_t offset) +{ + uint8_t result; + read_bytes_unchecked(it, &result, offset, sizeof(result)); + return result; +} + +static inline uint16_t read_uint16(const CborValue *it, size_t offset) +{ + uint16_t result; + read_bytes_unchecked(it, &result, offset, sizeof(result)); + return cbor_ntohs(result); +} + +static inline uint32_t read_uint32(const CborValue *it, size_t offset) +{ + uint32_t result; + read_bytes_unchecked(it, &result, offset, sizeof(result)); + return cbor_ntohl(result); +} + +static inline uint64_t read_uint64(const CborValue *it, size_t offset) +{ + uint64_t result; + read_bytes_unchecked(it, &result, offset, sizeof(result)); + return cbor_ntohll(result); +} + +static inline CborError extract_number_checked(const CborValue *it, uint64_t *value, size_t *bytesUsed) +{ + uint8_t descriptor; + size_t bytesNeeded = 0; + + /* We've already verified that there's at least one byte to be read */ + read_bytes_unchecked(it, &descriptor, 0, 1); + descriptor &= SmallValueMask; + if (descriptor < Value8Bit) { + *value = descriptor; + } else if (unlikely(descriptor > Value64Bit)) { + return CborErrorIllegalNumber; + } else { + bytesNeeded = (size_t)(1 << (descriptor - Value8Bit)); + if (!can_read_bytes(it, 1 + bytesNeeded)) + return CborErrorUnexpectedEOF; + if (descriptor <= Value16Bit) { + if (descriptor == Value16Bit) + *value = read_uint16(it, 1); + else + *value = read_uint8(it, 1); + } else { + if (descriptor == Value32Bit) + *value = read_uint32(it, 1); + else + *value = read_uint64(it, 1); + } + } + + if (bytesUsed) + *bytesUsed = bytesNeeded; + return CborNoError; +} + +#endif /* CBORINTERNAL_P_H */ diff --git a/src/3rdparty/tinycbor/src/cborjson.h b/src/3rdparty/tinycbor/src/cborjson.h new file mode 100644 index 0000000000..8ff27b9202 --- /dev/null +++ b/src/3rdparty/tinycbor/src/cborjson.h @@ -0,0 +1,62 @@ +/**************************************************************************** +** +** Copyright (C) 2015 Intel Corporation +** +** 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 +** AUTHORS OR COPYRIGHT HOLDERS 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. +** +****************************************************************************/ + +#ifndef CBORJSON_H +#define CBORJSON_H + +#include "cbor.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* Conversion to JSON */ +enum CborToJsonFlags +{ + CborConvertAddMetadata = 1, + CborConvertTagsToObjects = 2, + CborConvertIgnoreTags = 0, + + CborConvertObeyByteStringTags = 0, + CborConvertByteStringsToBase64Url = 4, + + CborConvertRequireMapStringKeys = 0, + CborConvertStringifyMapKeys = 8, + + CborConvertDefaultFlags = 0 +}; + +CBOR_API CborError cbor_value_to_json_advance(FILE *out, CborValue *value, int flags); +CBOR_INLINE_API CborError cbor_value_to_json(FILE *out, const CborValue *value, int flags) +{ + CborValue copy = *value; + return cbor_value_to_json_advance(out, ©, flags); +} + +#ifdef __cplusplus +} +#endif + +#endif /* CBORJSON_H */ + diff --git a/src/3rdparty/tinycbor/src/cborparser.c b/src/3rdparty/tinycbor/src/cborparser.c new file mode 100644 index 0000000000..971230ea61 --- /dev/null +++ b/src/3rdparty/tinycbor/src/cborparser.c @@ -0,0 +1,1526 @@ +/**************************************************************************** +** +** Copyright (C) 2018 Intel Corporation +** +** 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 +** AUTHORS OR COPYRIGHT HOLDERS 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. +** +****************************************************************************/ + +#ifndef _BSD_SOURCE +#define _BSD_SOURCE 1 +#endif +#ifndef _DEFAULT_SOURCE +#define _DEFAULT_SOURCE 1 +#endif +#ifndef __STDC_LIMIT_MACROS +# define __STDC_LIMIT_MACROS 1 +#endif + +#include "cbor.h" +#include "cborinternal_p.h" +#include "compilersupport_p.h" + +#include <string.h> + +/** + * \defgroup CborParsing Parsing CBOR streams + * \brief Group of functions used to parse CBOR streams. + * + * TinyCBOR provides functions for pull-based stream parsing of a CBOR-encoded + * payload. The main data type for the parsing is a CborValue, which behaves + * like an iterator and can be used to extract the encoded data. It is first + * initialized with a call to cbor_parser_init() and is usually used to extract + * exactly one item, most often an array or map. + * + * Nested CborValue objects can be parsed using cbor_value_enter_container(). + * Each call to cbor_value_enter_container() must be matched by a call to + * cbor_value_leave_container(), with the exact same parameters. + * + * The example below initializes a CborParser object, begins the parsing with a + * CborValue and decodes a single integer: + * + * \code + * int extract_int(const uint8_t *buffer, size_t len) + * { + * CborParser parser; + * CborValue value; + * int result; + * cbor_parser_init(buffer, len, 0, &parser, &value); + * cbor_value_get_int(&value, &result); + * return result; + * } + * \endcode + * + * The code above does no error checking, which means it assumes the data comes + * from a source trusted to send one properly-encoded integer. The following + * example does the exact same operation, but includes error checking and + * returns 0 on parsing failure: + * + * \code + * int extract_int(const uint8_t *buffer, size_t len) + * { + * CborParser parser; + * CborValue value; + * int result; + * if (cbor_parser_init(buffer, len, 0, &parser, &value) != CborNoError) + * return 0; + * if (!cbor_value_is_integer(&value) || + * cbor_value_get_int(&value, &result) != CborNoError) + * return 0; + * return result; + * } + * \endcode + * + * Note, in the example above, that one can't distinguish a parsing failure + * from an encoded value of zero. Reporting a parsing error is left as an + * exercise to the reader. + * + * The code above does not execute a range-check either: it is possible that + * the value decoded from the CBOR stream encodes a number larger than what can + * be represented in a variable of type \c{int}. If detecting that case is + * important, the code should call cbor_value_get_int_checked() instead. + * + * <h3 class="groupheader">Memory and parsing constraints</h3> + * + * TinyCBOR is designed to run with little memory and with minimal overhead. + * Except where otherwise noted, the parser functions always run on constant + * time (O(1)), do not recurse and never allocate memory (thus, stack usage is + * bounded and is O(1)). + * + * <h3 class="groupheader">Error handling and preconditions</h3> + * + * All functions operating on a CborValue return a CborError condition, with + * CborNoError standing for the normal situation in which no parsing error + * occurred. All functions may return parsing errors in case the stream cannot + * be decoded properly, be it due to corrupted data or due to reaching the end + * of the input buffer. + * + * Error conditions must not be ignored. All decoder functions have undefined + * behavior if called after an error has been reported, and may crash. + * + * Some functions are also documented to have preconditions, like + * cbor_value_get_int() requiring that the input be an integral value. + * Violation of preconditions also results in undefined behavior and the + * program may crash. + */ + +/** + * \addtogroup CborParsing + * @{ + */ + +/** + * \struct CborValue + * + * This type contains one value parsed from the CBOR stream. Each CborValue + * behaves as an iterator in a StAX-style parser. + * + * \if privatedocs + * Implementation details: the CborValue contains these fields: + * \list + * \li ptr: pointer to the actual data + * \li flags: flags from the decoder + * \li extra: partially decoded integer value (0, 1 or 2 bytes) + * \li remaining: remaining items in this collection after this item or UINT32_MAX if length is unknown + * \endlist + * \endif + */ + +static uint64_t extract_number_and_advance(CborValue *it) +{ + /* This function is only called after we've verified that the number + * here is valid, so we can just use _cbor_value_extract_int64_helper. */ + uint8_t descriptor; + uint64_t v = _cbor_value_extract_int64_helper(it); + + read_bytes_unchecked(it, &descriptor, 0, 1); + descriptor &= SmallValueMask; + + size_t bytesNeeded = descriptor < Value8Bit ? 0 : (1 << (descriptor - Value8Bit)); + advance_bytes(it, bytesNeeded + 1); + + return v; +} + +static bool is_fixed_type(uint8_t type) +{ + return type != CborTextStringType && type != CborByteStringType && type != CborArrayType && + type != CborMapType; +} + +static CborError preparse_value(CborValue *it) +{ + enum { + /* flags to keep */ + FlagsToKeep = CborIteratorFlag_ContainerIsMap | CborIteratorFlag_NextIsMapKey + }; + uint8_t descriptor; + + /* are we at the end? */ + it->type = CborInvalidType; + it->flags &= FlagsToKeep; + if (!read_bytes(it, &descriptor, 0, 1)) + return CborErrorUnexpectedEOF; + + uint8_t type = descriptor & MajorTypeMask; + it->type = type; + it->extra = (descriptor &= SmallValueMask); + + if (descriptor > Value64Bit) { + if (unlikely(descriptor != IndefiniteLength)) + return type == CborSimpleType ? CborErrorUnknownType : CborErrorIllegalNumber; + if (likely(!is_fixed_type(type))) { + /* special case */ + it->flags |= CborIteratorFlag_UnknownLength; + it->type = type; + return CborNoError; + } + return type == CborSimpleType ? CborErrorUnexpectedBreak : CborErrorIllegalNumber; + } + + size_t bytesNeeded = descriptor < Value8Bit ? 0 : (1 << (descriptor - Value8Bit)); + + if (bytesNeeded) { + if (!can_read_bytes(it, bytesNeeded + 1)) + return CborErrorUnexpectedEOF; + + it->extra = 0; + + /* read up to 16 bits into it->extra */ + if (bytesNeeded <= 2) { + read_bytes_unchecked(it, &it->extra, 1, bytesNeeded); + if (bytesNeeded == 2) + it->extra = cbor_ntohs(it->extra); + } else { + cbor_static_assert(CborIteratorFlag_IntegerValueTooLarge == (Value32Bit & 3)); + cbor_static_assert((CborIteratorFlag_IntegerValueIs64Bit | + CborIteratorFlag_IntegerValueTooLarge) == (Value64Bit & 3)); + it->flags |= (descriptor & 3); + } + } + + uint8_t majortype = type >> MajorTypeShift; + if (majortype == NegativeIntegerType) { + it->flags |= CborIteratorFlag_NegativeInteger; + it->type = CborIntegerType; + } else if (majortype == SimpleTypesType) { + switch (descriptor) { + case FalseValue: + it->extra = false; + it->type = CborBooleanType; + break; + + case SinglePrecisionFloat: + case DoublePrecisionFloat: + it->flags |= CborIteratorFlag_IntegerValueTooLarge; + /* fall through */ + case TrueValue: + case NullValue: + case UndefinedValue: + case HalfPrecisionFloat: + read_bytes_unchecked(it, &it->type, 0, 1); + break; + + case SimpleTypeInNextByte: +#ifndef CBOR_PARSER_NO_STRICT_CHECKS + if (unlikely(it->extra < 32)) { + it->type = CborInvalidType; + return CborErrorIllegalSimpleType; + } +#endif + break; + + case 28: + case 29: + case 30: + case Break: + cbor_assert(false); /* these conditions can't be reached */ + return CborErrorUnexpectedBreak; + } + } + + return CborNoError; +} + +static CborError preparse_next_value_nodecrement(CborValue *it) +{ + uint8_t byte; + if (it->remaining == UINT32_MAX && read_bytes(it, &byte, 0, 1) && byte == (uint8_t)BreakByte) { + /* end of map or array */ + if ((it->flags & CborIteratorFlag_ContainerIsMap && it->flags & CborIteratorFlag_NextIsMapKey) + || it->type == CborTagType) { + /* but we weren't expecting it! */ + return CborErrorUnexpectedBreak; + } + it->type = CborInvalidType; + it->remaining = 0; + it->flags |= CborIteratorFlag_UnknownLength; /* leave_container must consume the Break */ + return CborNoError; + } + + return preparse_value(it); +} + +static CborError preparse_next_value(CborValue *it) +{ + /* tags don't count towards item totals or whether we've successfully + * read a map's key or value */ + bool itemCounts = it->type != CborTagType; + + if (it->remaining != UINT32_MAX) { + if (itemCounts && --it->remaining == 0) { + it->type = CborInvalidType; + it->flags &= ~CborIteratorFlag_UnknownLength; /* no Break to consume */ + return CborNoError; + } + } + if (itemCounts) { + /* toggle the flag indicating whether this was a map key */ + it->flags ^= CborIteratorFlag_NextIsMapKey; + } + return preparse_next_value_nodecrement(it); +} + +static CborError advance_internal(CborValue *it) +{ + uint64_t length = extract_number_and_advance(it); + + if (it->type == CborByteStringType || it->type == CborTextStringType) { + cbor_assert(length == (size_t)length); + cbor_assert((it->flags & CborIteratorFlag_UnknownLength) == 0); + advance_bytes(it, length); + } + + return preparse_next_value(it); +} + +/** \internal + * + * Decodes the CBOR integer value when it is larger than the 16 bits available + * in value->extra. This function requires that value->flags have the + * CborIteratorFlag_IntegerValueTooLarge flag set. + * + * This function is also used to extract single- and double-precision floating + * point values (SinglePrecisionFloat == Value32Bit and DoublePrecisionFloat == + * Value64Bit). + */ +uint64_t _cbor_value_decode_int64_internal(const CborValue *value) +{ + cbor_assert(value->flags & CborIteratorFlag_IntegerValueTooLarge || + value->type == CborFloatType || value->type == CborDoubleType); + if (value->flags & CborIteratorFlag_IntegerValueIs64Bit) + return read_uint64(value, 1); + + return read_uint32(value, 1); +} + +/** + * Initializes the CBOR parser for parsing \a size bytes beginning at \a + * buffer. Parsing will use flags set in \a flags. The iterator to the first + * element is returned in \a it. + * + * The \a parser structure needs to remain valid throughout the decoding + * process. It is not thread-safe to share one CborParser among multiple + * threads iterating at the same time, but the object can be copied so multiple + * threads can iterate. + */ +CborError cbor_parser_init(const uint8_t *buffer, size_t size, uint32_t flags, CborParser *parser, CborValue *it) +{ + memset(parser, 0, sizeof(*parser)); + parser->source.end = buffer + size; + parser->flags = (enum CborParserGlobalFlags)flags; + it->parser = parser; + it->source.ptr = buffer; + it->remaining = 1; /* there's one type altogether, usually an array or map */ + it->flags = 0; + return preparse_value(it); +} + +CborError cbor_parser_init_reader(const struct CborParserOperations *ops, CborParser *parser, CborValue *it, void *token) +{ + memset(parser, 0, sizeof(*parser)); + parser->source.ops = ops; + parser->flags = CborParserFlag_ExternalSource; + it->parser = parser; + it->source.token = token; + it->remaining = 1; + return preparse_value(it); +} + +/** + * \fn bool cbor_value_at_end(const CborValue *it) + * + * Returns true if \a it has reached the end of the iteration, usually when + * advancing after the last item in an array or map. + * + * In the case of the outermost CborValue object, this function returns true + * after decoding a single element. A pointer to the first byte of the + * remaining data (if any) can be obtained with cbor_value_get_next_byte(). + * + * \sa cbor_value_advance(), cbor_value_is_valid(), cbor_value_get_next_byte() + */ + +/** + * \fn const uint8_t *cbor_value_get_next_byte(const CborValue *it) + * + * Returns a pointer to the next byte that would be decoded if this CborValue + * object were advanced. + * + * This function is useful if cbor_value_at_end() returns true for the + * outermost CborValue: the pointer returned is the first byte of the data + * remaining in the buffer, if any. Code can decide whether to begin decoding a + * new CBOR data stream from this point, or parse some other data appended to + * the same buffer. + * + * This function may be used even after a parsing error. If that occurred, + * then this function returns a pointer to where the parsing error occurred. + * Note that the error recovery is not precise and the pointer may not indicate + * the exact byte containing bad data. + * + * This function makes sense only when using a linear buffer (that is, when the + * parser is initialize by cbor_parser_init()). If using an external source, + * this function may return garbage; instead, consult the external source itself + * to find out more details about the presence of more data. + * + * \sa cbor_value_at_end() + */ + +CborError cbor_value_reparse(CborValue *it) +{ + if (it->flags & CborIteratorFlag_IteratingStringChunks) + return CborNoError; + return preparse_next_value_nodecrement(it); +} + +/** + * \fn bool cbor_value_is_valid(const CborValue *it) + * + * Returns true if the iterator \a it contains a valid value. Invalid iterators + * happen when iteration reaches the end of a container (see \ref + * cbor_value_at_end()) or when a search function resulted in no matches. + * + * \sa cbor_value_advance(), cbor_value_at_end(), cbor_value_get_type() + */ + +/** + * Performs a basic validation of the CBOR stream pointed by \a it and returns + * the error it found. If no error was found, it returns CborNoError and the + * application can iterate over the items with certainty that no other errors + * will appear during parsing. + * + * A basic validation checks for: + * \list + * \li absence of undefined additional information bytes; + * \li well-formedness of all numbers, lengths, and simple values; + * \li string contents match reported sizes; + * \li arrays and maps contain the number of elements they are reported to have; + * \endlist + * + * For further checks, see cbor_value_validate(). + * + * This function has the same timing and memory requirements as + * cbor_value_advance(). + * + * \sa cbor_value_validate(), cbor_value_advance() + */ +CborError cbor_value_validate_basic(const CborValue *it) +{ + CborValue value = *it; + return cbor_value_advance(&value); +} + +/** + * Advances the CBOR value \a it by one fixed-size position. Fixed-size types + * are: integers, tags, simple types (including boolean, null and undefined + * values) and floating point types. + * + * If the type is not of fixed size, this function has undefined behavior. Code + * must be sure that the current type is one of the fixed-size types before + * calling this function. This function is provided because it can guarantee + * that it runs in constant time (O(1)). + * + * If the caller is not able to determine whether the type is fixed or not, code + * can use the cbor_value_advance() function instead. + * + * \sa cbor_value_at_end(), cbor_value_advance(), cbor_value_enter_container(), cbor_value_leave_container() + */ +CborError cbor_value_advance_fixed(CborValue *it) +{ + cbor_assert(it->type != CborInvalidType); + cbor_assert(is_fixed_type(it->type)); + if (!it->remaining) + return CborErrorAdvancePastEOF; + return advance_internal(it); +} + +static CborError advance_recursive(CborValue *it, int nestingLevel) +{ + CborError err; + CborValue recursed; + + if (is_fixed_type(it->type)) + return advance_internal(it); + + if (!cbor_value_is_container(it)) { + size_t len = SIZE_MAX; + return _cbor_value_copy_string(it, NULL, &len, it); + } + + /* map or array */ + if (nestingLevel == 0) + return CborErrorNestingTooDeep; + + err = cbor_value_enter_container(it, &recursed); + if (err) + return err; + while (!cbor_value_at_end(&recursed)) { + err = advance_recursive(&recursed, nestingLevel - 1); + if (err) + return err; + } + return cbor_value_leave_container(it, &recursed); +} + + +/** + * Advances the CBOR value \a it by one element, skipping over containers. + * Unlike cbor_value_advance_fixed(), this function can be called on a CBOR + * value of any type. However, if the type is a container (map or array) or a + * string with a chunked payload, this function will not run in constant time + * and will recurse into itself (it will run on O(n) time for the number of + * elements or chunks and will use O(n) memory for the number of nested + * containers). + * + * The number of recursions can be limited at compile time to avoid stack + * exhaustion in constrained systems. + * + * \sa cbor_value_at_end(), cbor_value_advance_fixed(), cbor_value_enter_container(), cbor_value_leave_container() + */ +CborError cbor_value_advance(CborValue *it) +{ + cbor_assert(it->type != CborInvalidType); + if (!it->remaining) + return CborErrorAdvancePastEOF; + return advance_recursive(it, CBOR_PARSER_MAX_RECURSIONS); +} + +/** + * \fn bool cbor_value_is_tag(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR tag. + * + * \sa cbor_value_get_tag(), cbor_value_skip_tag() + */ + +/** + * \fn CborError cbor_value_get_tag(const CborValue *value, CborTag *result) + * + * Retrieves the CBOR tag value that \a value points to and stores it in \a + * result. If the iterator \a value does not point to a CBOR tag value, the + * behavior is undefined, so checking with \ref cbor_value_get_type or with + * \ref cbor_value_is_tag is recommended. + * + * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_tag() + */ + +/** + * Advances the CBOR value \a it until it no longer points to a tag. If \a it is + * already not pointing to a tag, then this function returns it unchanged. + * + * This function does not run in constant time: it will run on O(n) for n being + * the number of tags. It does use constant memory (O(1) memory requirements). + * + * \sa cbor_value_advance_fixed(), cbor_value_advance() + */ +CborError cbor_value_skip_tag(CborValue *it) +{ + while (cbor_value_is_tag(it)) { + CborError err = cbor_value_advance_fixed(it); + if (err) + return err; + } + return CborNoError; +} + +/** + * \fn bool cbor_value_is_container(const CborValue *it) + * + * Returns true if the \a it value is a container and requires recursion in + * order to decode (maps and arrays), false otherwise. + */ + +/** + * Creates a CborValue iterator pointing to the first element of the container + * represented by \a it and saves it in \a recursed. The \a it container object + * needs to be kept and passed again to cbor_value_leave_container() in order + * to continue iterating past this container. + * + * The \a it CborValue iterator must point to a container. + * + * \sa cbor_value_is_container(), cbor_value_leave_container(), cbor_value_advance() + */ +CborError cbor_value_enter_container(const CborValue *it, CborValue *recursed) +{ + cbor_static_assert(CborIteratorFlag_ContainerIsMap == (CborMapType & ~CborArrayType)); + cbor_assert(cbor_value_is_container(it)); + *recursed = *it; + + if (it->flags & CborIteratorFlag_UnknownLength) { + recursed->remaining = UINT32_MAX; + advance_bytes(recursed, 1); + } else { + uint64_t len = extract_number_and_advance(recursed); + + recursed->remaining = (uint32_t)len; + if (recursed->remaining != len || len == UINT32_MAX) { + /* back track the pointer to indicate where the error occurred */ + copy_current_position(recursed, it); + return CborErrorDataTooLarge; + } + if (recursed->type == CborMapType) { + /* maps have keys and values, so we need to multiply by 2 */ + if (recursed->remaining > UINT32_MAX / 2) { + /* back track the pointer to indicate where the error occurred */ + copy_current_position(recursed, it); + return CborErrorDataTooLarge; + } + recursed->remaining *= 2; + } + if (len == 0) { + /* the case of the empty container */ + recursed->type = CborInvalidType; + return CborNoError; + } + } + recursed->flags = (recursed->type & CborIteratorFlag_ContainerIsMap); + return preparse_next_value_nodecrement(recursed); +} + +/** + * Updates \a it to point to the next element after the container. The \a + * recursed object needs to point to the element obtained either by advancing + * the last element of the container (via cbor_value_advance(), + * cbor_value_advance_fixed(), a nested cbor_value_leave_container(), or the \c + * next pointer from cbor_value_copy_string() or cbor_value_dup_string()). + * + * The \a it and \a recursed parameters must be the exact same as passed to + * cbor_value_enter_container(). + * + * \sa cbor_value_enter_container(), cbor_value_at_end() + */ +CborError cbor_value_leave_container(CborValue *it, const CborValue *recursed) +{ + cbor_assert(cbor_value_is_container(it)); + cbor_assert(recursed->type == CborInvalidType); + + copy_current_position(it, recursed); + if (recursed->flags & CborIteratorFlag_UnknownLength) + advance_bytes(it, 1); + return preparse_next_value(it); +} + + +/** + * \fn CborType cbor_value_get_type(const CborValue *value) + * + * Returns the type of the CBOR value that the iterator \a value points to. If + * \a value does not point to a valid value, this function returns \ref + * CborInvalidType. + * + * TinyCBOR also provides functions to test directly if a given CborValue object + * is of a given type, like cbor_value_is_text_string() and cbor_value_is_null(). + * + * \sa cbor_value_is_valid() + */ + +/** + * \fn bool cbor_value_is_null(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR null type. + * + * \sa cbor_value_is_valid(), cbor_value_is_undefined() + */ + +/** + * \fn bool cbor_value_is_undefined(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR undefined type. + * + * \sa cbor_value_is_valid(), cbor_value_is_null() + */ + +/** + * \fn bool cbor_value_is_boolean(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR boolean + * type (true or false). + * + * \sa cbor_value_is_valid(), cbor_value_get_boolean() + */ + +/** + * \fn CborError cbor_value_get_boolean(const CborValue *value, bool *result) + * + * Retrieves the boolean value that \a value points to and stores it in \a + * result. If the iterator \a value does not point to a boolean value, the + * behavior is undefined, so checking with \ref cbor_value_get_type or with + * \ref cbor_value_is_boolean is recommended. + * + * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_boolean() + */ + +/** + * \fn bool cbor_value_is_simple_type(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR Simple Type + * type (other than true, false, null and undefined). + * + * \sa cbor_value_is_valid(), cbor_value_get_simple_type() + */ + +/** + * \fn CborError cbor_value_get_simple_type(const CborValue *value, uint8_t *result) + * + * Retrieves the CBOR Simple Type value that \a value points to and stores it + * in \a result. If the iterator \a value does not point to a simple_type + * value, the behavior is undefined, so checking with \ref cbor_value_get_type + * or with \ref cbor_value_is_simple_type is recommended. + * + * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_simple_type() + */ + +/** + * \fn bool cbor_value_is_integer(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR integer + * type. + * + * \sa cbor_value_is_valid(), cbor_value_get_int, cbor_value_get_int64, cbor_value_get_uint64, cbor_value_get_raw_integer + */ + +/** + * \fn bool cbor_value_is_unsigned_integer(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR unsigned + * integer type (positive values or zero). + * + * \sa cbor_value_is_valid(), cbor_value_get_uint64() + */ + +/** + * \fn bool cbor_value_is_negative_integer(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR negative + * integer type. + * + * \sa cbor_value_is_valid(), cbor_value_get_int, cbor_value_get_int64, cbor_value_get_raw_integer + */ + +/** + * \fn CborError cbor_value_get_int(const CborValue *value, int *result) + * + * Retrieves the CBOR integer value that \a value points to and stores it in \a + * result. If the iterator \a value does not point to an integer value, the + * behavior is undefined, so checking with \ref cbor_value_get_type or with + * \ref cbor_value_is_integer is recommended. + * + * Note that this function does not do range-checking: integral values that do + * not fit in a variable of type \c{int} are silently truncated to fit. Use + * cbor_value_get_int_checked() if that is not acceptable. + * + * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_integer() + */ + +/** + * \fn CborError cbor_value_get_int64(const CborValue *value, int64_t *result) + * + * Retrieves the CBOR integer value that \a value points to and stores it in \a + * result. If the iterator \a value does not point to an integer value, the + * behavior is undefined, so checking with \ref cbor_value_get_type or with + * \ref cbor_value_is_integer is recommended. + * + * Note that this function does not do range-checking: integral values that do + * not fit in a variable of type \c{int64_t} are silently truncated to fit. Use + * cbor_value_get_int64_checked() that is not acceptable. + * + * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_integer() + */ + +/** + * \fn CborError cbor_value_get_uint64(const CborValue *value, uint64_t *result) + * + * Retrieves the CBOR integer value that \a value points to and stores it in \a + * result. If the iterator \a value does not point to an unsigned integer + * value, the behavior is undefined, so checking with \ref cbor_value_get_type + * or with \ref cbor_value_is_unsigned_integer is recommended. + * + * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_unsigned_integer() + */ + +/** + * \fn CborError cbor_value_get_raw_integer(const CborValue *value, uint64_t *result) + * + * Retrieves the CBOR integer value that \a value points to and stores it in \a + * result. If the iterator \a value does not point to an integer value, the + * behavior is undefined, so checking with \ref cbor_value_get_type or with + * \ref cbor_value_is_integer is recommended. + * + * This function is provided because CBOR negative integers can assume values + * that cannot be represented with normal 64-bit integer variables. + * + * If the integer is unsigned (that is, if cbor_value_is_unsigned_integer() + * returns true), then \a result will contain the actual value. If the integer + * is negative, then \a result will contain the absolute value of that integer, + * minus one. That is, \c {actual = -result - 1}. On architectures using two's + * complement for representation of negative integers, it is equivalent to say + * that \a result will contain the bitwise negation of the actual value. + * + * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_integer() + */ + +/** + * Retrieves the CBOR integer value that \a value points to and stores it in \a + * result. If the iterator \a value does not point to an integer value, the + * behavior is undefined, so checking with \ref cbor_value_get_type or with + * \ref cbor_value_is_integer is recommended. + * + * Unlike \ref cbor_value_get_int64(), this function performs a check to see if the + * stored integer fits in \a result without data loss. If the number is outside + * the valid range for the data type, this function returns the recoverable + * error CborErrorDataTooLarge. In that case, use either + * cbor_value_get_uint64() (if the number is positive) or + * cbor_value_get_raw_integer(). + * + * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_integer(), cbor_value_get_int64() + */ +CborError cbor_value_get_int64_checked(const CborValue *value, int64_t *result) +{ + uint64_t v; + cbor_assert(cbor_value_is_integer(value)); + v = _cbor_value_extract_int64_helper(value); + + /* Check before converting, as the standard says (C11 6.3.1.3 paragraph 3): + * "[if] the new type is signed and the value cannot be represented in it; either the + * result is implementation-defined or an implementation-defined signal is raised." + * + * The range for int64_t is -2^63 to 2^63-1 (int64_t is required to be + * two's complement, C11 7.20.1.1 paragraph 3), which in CBOR is + * represented the same way, differing only on the "sign bit" (the major + * type). + */ + + if (unlikely(v > (uint64_t)INT64_MAX)) + return CborErrorDataTooLarge; + + *result = v; + if (value->flags & CborIteratorFlag_NegativeInteger) + *result = -*result - 1; + return CborNoError; +} + +/** + * Retrieves the CBOR integer value that \a value points to and stores it in \a + * result. If the iterator \a value does not point to an integer value, the + * behavior is undefined, so checking with \ref cbor_value_get_type or with + * \ref cbor_value_is_integer is recommended. + * + * Unlike \ref cbor_value_get_int(), this function performs a check to see if the + * stored integer fits in \a result without data loss. If the number is outside + * the valid range for the data type, this function returns the recoverable + * error CborErrorDataTooLarge. In that case, use one of the other integer + * functions to obtain the value. + * + * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_integer(), cbor_value_get_int64(), + * cbor_value_get_uint64(), cbor_value_get_int64_checked(), cbor_value_get_raw_integer() + */ +CborError cbor_value_get_int_checked(const CborValue *value, int *result) +{ + uint64_t v; + cbor_assert(cbor_value_is_integer(value)); + v = _cbor_value_extract_int64_helper(value); + + /* Check before converting, as the standard says (C11 6.3.1.3 paragraph 3): + * "[if] the new type is signed and the value cannot be represented in it; either the + * result is implementation-defined or an implementation-defined signal is raised." + * + * But we can convert from signed to unsigned without fault (paragraph 2). + * + * The range for int is implementation-defined and int is not guaranteed to use + * two's complement representation (although int32_t is). + */ + + if (value->flags & CborIteratorFlag_NegativeInteger) { + if (unlikely(v > (unsigned) -(INT_MIN + 1))) + return CborErrorDataTooLarge; + + *result = (int)v; + *result = -*result - 1; + } else { + if (unlikely(v > (uint64_t)INT_MAX)) + return CborErrorDataTooLarge; + + *result = (int)v; + } + return CborNoError; + +} + +/** + * \fn bool cbor_value_is_length_known(const CborValue *value) + * + * Returns true if the length of this type is known without calculation. That + * is, if the length of this CBOR string, map or array is encoded in the data + * stream, this function returns true. If the length is not encoded, it returns + * false. + * + * If the length is known, code can call cbor_value_get_string_length(), + * cbor_value_get_array_length() or cbor_value_get_map_length() to obtain the + * length. If the length is not known but is necessary, code can use the + * cbor_value_calculate_string_length() function (no equivalent function is + * provided for maps and arrays). + */ + +/** + * \fn bool cbor_value_is_text_string(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR text + * string. CBOR text strings are UTF-8 encoded and usually contain + * human-readable text. + * + * \sa cbor_value_is_valid(), cbor_value_get_string_length(), cbor_value_calculate_string_length(), + * cbor_value_copy_text_string(), cbor_value_dup_text_string() + */ + +/** + * \fn bool cbor_value_is_byte_string(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR text + * string. CBOR byte strings are binary data with no specified encoding or + * format. + * + * \sa cbor_value_is_valid(), cbor_value_get_string_length(), cbor_value_calculate_string_length(), + * cbor_value_copy_byte_string(), cbor_value_dup_byte_string() + */ + +/** + * \fn CborError cbor_value_get_string_length(const CborValue *value, size_t *length) + * + * Extracts the length of the byte or text string that \a value points to and + * stores it in \a result. If the iterator \a value does not point to a text + * string or a byte string, the behaviour is undefined, so checking with \ref + * cbor_value_get_type, with \ref cbor_value_is_text_string or \ref + * cbor_value_is_byte_string is recommended. + * + * If the length of this string is not encoded in the CBOR data stream, this + * function will return the recoverable error CborErrorUnknownLength. You may + * also check whether that is the case by using cbor_value_is_length_known(). + * + * If the length of the string is required but the length was not encoded, use + * cbor_value_calculate_string_length(), but note that that function does not + * run in constant time. + * + * \note On 32-bit platforms, this function will return error condition of \ref + * CborErrorDataTooLarge if the stream indicates a length that is too big to + * fit in 32-bit. + * + * \sa cbor_value_is_valid(), cbor_value_is_length_known(), cbor_value_calculate_string_length() + */ + +/** + * Calculates the length of the byte or text string that \a value points to and + * stores it in \a len. If the iterator \a value does not point to a text + * string or a byte string, the behaviour is undefined, so checking with \ref + * cbor_value_get_type, with \ref cbor_value_is_text_string or \ref + * cbor_value_is_byte_string is recommended. + * + * This function is different from cbor_value_get_string_length() in that it + * calculates the length even for strings sent in chunks. For that reason, this + * function may not run in constant time (it will run in O(n) time on the + * number of chunks). It does use constant memory (O(1)). + * + * \note On 32-bit platforms, this function will return error condition of \ref + * CborErrorDataTooLarge if the stream indicates a length that is too big to + * fit in 32-bit. + * + * \sa cbor_value_get_string_length(), cbor_value_copy_text_string(), cbor_value_copy_byte_string(), cbor_value_is_length_known() + */ +CborError cbor_value_calculate_string_length(const CborValue *value, size_t *len) +{ + *len = SIZE_MAX; + return _cbor_value_copy_string(value, NULL, len, NULL); +} + +CborError _cbor_value_begin_string_iteration(CborValue *it) +{ + it->flags |= CborIteratorFlag_IteratingStringChunks | + CborIteratorFlag_BeforeFirstStringChunk; + if (!cbor_value_is_length_known(it)) { + /* chunked string: we're before the first chunk; + * advance to the first chunk */ + advance_bytes(it, 1); + } + + return CborNoError; +} + +CborError _cbor_value_finish_string_iteration(CborValue *it) +{ + if (!cbor_value_is_length_known(it)) + advance_bytes(it, 1); /* skip the Break */ + + return preparse_next_value(it); +} + +static CborError get_string_chunk_size(const CborValue *it, size_t *offset, size_t *len) +{ + uint8_t descriptor; + size_t bytesNeeded = 1; + + if (cbor_value_is_length_known(it) && (it->flags & CborIteratorFlag_BeforeFirstStringChunk) == 0) + return CborErrorNoMoreStringChunks; + + /* are we at the end? */ + if (!read_bytes(it, &descriptor, 0, 1)) + return CborErrorUnexpectedEOF; + + if (descriptor == BreakByte) + return CborErrorNoMoreStringChunks; + if ((descriptor & MajorTypeMask) != it->type) + return CborErrorIllegalType; + + /* find the string length */ + descriptor &= SmallValueMask; + if (descriptor < Value8Bit) { + *len = descriptor; + } else if (unlikely(descriptor > Value64Bit)) { + return CborErrorIllegalNumber; + } else { + uint64_t val; + bytesNeeded = (size_t)(1 << (descriptor - Value8Bit)); + if (!can_read_bytes(it, 1 + bytesNeeded)) + return CborErrorUnexpectedEOF; + + if (descriptor <= Value16Bit) { + if (descriptor == Value16Bit) + val = read_uint16(it, 1); + else + val = read_uint8(it, 1); + } else { + if (descriptor == Value32Bit) + val = read_uint32(it, 1); + else + val = read_uint64(it, 1); + } + + *len = val; + if (*len != val) + return CborErrorDataTooLarge; + + ++bytesNeeded; + } + + *offset = bytesNeeded; + return CborNoError; +} + +CborError _cbor_value_get_string_chunk_size(const CborValue *value, size_t *len) +{ + size_t offset; + return get_string_chunk_size(value, &offset, len); +} + +static CborError get_string_chunk(CborValue *it, const void **bufferptr, size_t *len) +{ + size_t offset; + CborError err = get_string_chunk_size(it, &offset, len); + if (err) + return err; + + /* we're good, transfer the string now */ + err = transfer_string(it, bufferptr, offset, *len); + if (err) + return err; + + /* we've iterated at least once */ + it->flags &= ~CborIteratorFlag_BeforeFirstStringChunk; + return CborNoError; +} + +/** + * \fn CborError cbor_value_get_text_string_chunk(const CborValue *value, const char **bufferptr, size_t *len, CborValue *next) + * + * Extracts one text string chunk pointed to by \a value and stores a pointer + * to the data in \a buffer and the size in \a len, which must not be null. If + * no more chunks are available, then \a bufferptr will be set to null. This + * function may be used to iterate over any string without causing its contents + * to be copied to a separate buffer, like the convenience function + * cbor_value_copy_text_string() does. + * + * It is designed to be used in code like: + * + * \code + * if (cbor_value_is_text_string(value)) { + * char *ptr; + * size_t len; + * while (1) { + * err = cbor_value_get_text_string_chunk(value, &ptr, &len, &value)); + * if (err) return err; + * if (ptr == NULL) return CborNoError; + * consume(ptr, len); + * } + * } + * \endcode + * + * If the iterator \a value does not point to a text string, the behaviour is + * undefined, so checking with \ref cbor_value_get_type or \ref + * cbor_value_is_text_string is recommended. + * + * The \a next pointer, if not null, will be updated to point to the next item + * after this string. During iteration, the pointer must only be passed back + * again to this function; passing it to any other function in this library + * results in undefined behavior. If there are no more chunks to be read from + * \a value, then \a next will be set to the next item after this string; if \a + * value points to the last item, then \a next will be invalid. + * + * \note This function does not perform UTF-8 validation on the incoming text + * string. + * + * \sa cbor_value_dup_text_string(), cbor_value_copy_text_string(), cbor_value_caculate_string_length(), cbor_value_get_byte_string_chunk() + */ + +/** + * \fn CborError cbor_value_get_byte_string_chunk(const CborValue *value, const char **bufferptr, size_t *len, CborValue *next) + * + * Extracts one byte string chunk pointed to by \a value and stores a pointer + * to the data in \a buffer and the size in \a len, which must not be null. If + * no more chunks are available, then \a bufferptr will be set to null. This + * function may be used to iterate over any string without causing its contents + * to be copied to a separate buffer, like the convenience function + * cbor_value_copy_byte_string() does. + * + * It is designed to be used in code like: + * + * \code + * if (cbor_value_is_byte_string(value)) { + * char *ptr; + * size_t len; + * while (1) { + * err = cbor_value_get_byte_string_chunk(value, &ptr, &len, &value)); + * if (err) return err; + * if (ptr == NULL) return CborNoError; + * consume(ptr, len); + * } + * } + * \endcode + * + * If the iterator \a value does not point to a byte string, the behaviour is + * undefined, so checking with \ref cbor_value_get_type or \ref + * cbor_value_is_byte_string is recommended. + * + * The \a next pointer, if not null, will be updated to point to the next item + * after this string. During iteration, the pointer must only be passed back + * again to this function; passing it to any other function in this library + * results in undefined behavior. If there are no more chunks to be read from + * \a value, then \a next will be set to the next item after this string; if \a + * value points to the last item, then \a next will be invalid. + * + * \sa cbor_value_dup_byte_string(), cbor_value_copy_byte_string(), cbor_value_caculate_string_length(), cbor_value_get_text_string_chunk() + */ + +CborError _cbor_value_get_string_chunk(const CborValue *value, const void **bufferptr, + size_t *len, CborValue *next) +{ + CborValue tmp; + if (!next) + next = &tmp; + *next = *value; + return get_string_chunk(next, bufferptr, len); +} + +/* We return uintptr_t so that we can pass memcpy directly as the iteration + * function. The choice is to optimize for memcpy, which is used in the base + * parser API (cbor_value_copy_string), while memcmp is used in convenience API + * only. */ +typedef uintptr_t (*IterateFunction)(char *, const uint8_t *, size_t); + +static uintptr_t iterate_noop(char *dest, const uint8_t *src, size_t len) +{ + (void)dest; + (void)src; + (void)len; + return true; +} + +static uintptr_t iterate_memcmp(char *s1, const uint8_t *s2, size_t len) +{ + return memcmp(s1, (const char *)s2, len) == 0; +} + +static uintptr_t iterate_memcpy(char *dest, const uint8_t *src, size_t len) +{ + return (uintptr_t)memcpy(dest, src, len); +} + +static CborError iterate_string_chunks(const CborValue *value, char *buffer, size_t *buflen, + bool *result, CborValue *next, IterateFunction func) +{ + CborError err; + CborValue tmp; + size_t total = 0; + const void *ptr; + + cbor_assert(cbor_value_is_byte_string(value) || cbor_value_is_text_string(value)); + if (!next) + next = &tmp; + *next = *value; + *result = true; + + err = _cbor_value_begin_string_iteration(next); + if (err) + return err; + + while (1) { + size_t newTotal; + size_t chunkLen; + err = get_string_chunk(next, &ptr, &chunkLen); + if (err == CborErrorNoMoreStringChunks) + break; + if (err) + return err; + + if (unlikely(add_check_overflow(total, chunkLen, &newTotal))) + return CborErrorDataTooLarge; + + if (*result && *buflen >= newTotal) + *result = !!func(buffer + total, (const uint8_t *)ptr, chunkLen); + else + *result = false; + + total = newTotal; + } + + /* is there enough room for the ending NUL byte? */ + if (*result && *buflen > total) { + uint8_t nul[] = { 0 }; + *result = !!func(buffer + total, nul, 1); + } + *buflen = total; + return _cbor_value_finish_string_iteration(next); +} + +/** + * \fn CborError cbor_value_copy_text_string(const CborValue *value, char *buffer, size_t *buflen, CborValue *next) + * + * Copies the string pointed to by \a value into the buffer provided at \a buffer + * of \a buflen bytes. If \a buffer is a NULL pointer, this function will not + * copy anything and will only update the \a next value. + * + * If the iterator \a value does not point to a text string, the behaviour is + * undefined, so checking with \ref cbor_value_get_type or \ref + * cbor_value_is_text_string is recommended. + * + * If the provided buffer length was too small, this function returns an error + * condition of \ref CborErrorOutOfMemory. If you need to calculate the length + * of the string in order to preallocate a buffer, use + * cbor_value_calculate_string_length(). + * + * On success, this function sets the number of bytes copied to \c{*buflen}. If + * the buffer is large enough, this function will insert a null byte after the + * last copied byte, to facilitate manipulation of text strings. That byte is + * not included in the returned value of \c{*buflen}. If there was no space for + * the terminating null, no error is returned, so callers must check the value + * of *buflen after the call, before relying on the '\0'; if it has not been + * changed by the call, there is no '\0'-termination on the buffer's contents. + * + * The \a next pointer, if not null, will be updated to point to the next item + * after this string. If \a value points to the last item, then \a next will be + * invalid. + * + * This function may not run in constant time (it will run in O(n) time on the + * number of chunks). It requires constant memory (O(1)). + * + * \note This function does not perform UTF-8 validation on the incoming text + * string. + * + * \sa cbor_value_get_text_string_chunk() cbor_value_dup_text_string(), cbor_value_copy_byte_string(), cbor_value_get_string_length(), cbor_value_calculate_string_length() + */ + +/** + * \fn CborError cbor_value_copy_byte_string(const CborValue *value, uint8_t *buffer, size_t *buflen, CborValue *next) + * + * Copies the string pointed by \a value into the buffer provided at \a buffer + * of \a buflen bytes. If \a buffer is a NULL pointer, this function will not + * copy anything and will only update the \a next value. + * + * If the iterator \a value does not point to a byte string, the behaviour is + * undefined, so checking with \ref cbor_value_get_type or \ref + * cbor_value_is_byte_string is recommended. + * + * If the provided buffer length was too small, this function returns an error + * condition of \ref CborErrorOutOfMemory. If you need to calculate the length + * of the string in order to preallocate a buffer, use + * cbor_value_calculate_string_length(). + * + * On success, this function sets the number of bytes copied to \c{*buflen}. If + * the buffer is large enough, this function will insert a null byte after the + * last copied byte, to facilitate manipulation of null-terminated strings. + * That byte is not included in the returned value of \c{*buflen}. + * + * The \a next pointer, if not null, will be updated to point to the next item + * after this string. If \a value points to the last item, then \a next will be + * invalid. + * + * This function may not run in constant time (it will run in O(n) time on the + * number of chunks). It requires constant memory (O(1)). + * + * \sa cbor_value_get_byte_string_chunk(), cbor_value_dup_text_string(), cbor_value_copy_text_string(), cbor_value_get_string_length(), cbor_value_calculate_string_length() + */ + +CborError _cbor_value_copy_string(const CborValue *value, void *buffer, + size_t *buflen, CborValue *next) +{ + bool copied_all; + CborError err = iterate_string_chunks(value, (char*)buffer, buflen, &copied_all, next, + buffer ? iterate_memcpy : iterate_noop); + return err ? err : + copied_all ? CborNoError : CborErrorOutOfMemory; +} + +/** + * Compares the entry \a value with the string \a string and stores the result + * in \a result. If the value is different from \a string \a result will + * contain \c false. + * + * The entry at \a value may be a tagged string. If \a value is not a string or + * a tagged string, the comparison result will be false. + * + * CBOR requires text strings to be encoded in UTF-8, but this function does + * not validate either the strings in the stream or the string \a string to be + * matched. Moreover, comparison is done on strict codepoint comparison, + * without any Unicode normalization. + * + * This function may not run in constant time (it will run in O(n) time on the + * number of chunks). It requires constant memory (O(1)). + * + * \sa cbor_value_skip_tag(), cbor_value_copy_text_string() + */ +CborError cbor_value_text_string_equals(const CborValue *value, const char *string, bool *result) +{ + size_t len; + CborValue copy = *value; + CborError err = cbor_value_skip_tag(©); + if (err) + return err; + if (!cbor_value_is_text_string(©)) { + *result = false; + return CborNoError; + } + + len = strlen(string); + return iterate_string_chunks(©, CONST_CAST(char *, string), &len, result, NULL, iterate_memcmp); +} + +/** + * \fn bool cbor_value_is_array(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR array. + * + * \sa cbor_value_is_valid(), cbor_value_is_map() + */ + +/** + * \fn CborError cbor_value_get_array_length(const CborValue *value, size_t *length) + * + * Extracts the length of the CBOR array that \a value points to and stores it + * in \a result. If the iterator \a value does not point to a CBOR array, the + * behaviour is undefined, so checking with \ref cbor_value_get_type or \ref + * cbor_value_is_array is recommended. + * + * If the length of this array is not encoded in the CBOR data stream, this + * function will return the recoverable error CborErrorUnknownLength. You may + * also check whether that is the case by using cbor_value_is_length_known(). + * + * \note On 32-bit platforms, this function will return error condition of \ref + * CborErrorDataTooLarge if the stream indicates a length that is too big to + * fit in 32-bit. + * + * \sa cbor_value_is_valid(), cbor_value_is_length_known() + */ + +/** + * \fn bool cbor_value_is_map(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR map. + * + * \sa cbor_value_is_valid(), cbor_value_is_array() + */ + +/** + * \fn CborError cbor_value_get_map_length(const CborValue *value, size_t *length) + * + * Extracts the length of the CBOR map that \a value points to and stores it in + * \a result. If the iterator \a value does not point to a CBOR map, the + * behaviour is undefined, so checking with \ref cbor_value_get_type or \ref + * cbor_value_is_map is recommended. + * + * If the length of this map is not encoded in the CBOR data stream, this + * function will return the recoverable error CborErrorUnknownLength. You may + * also check whether that is the case by using cbor_value_is_length_known(). + * + * \note On 32-bit platforms, this function will return error condition of \ref + * CborErrorDataTooLarge if the stream indicates a length that is too big to + * fit in 32-bit. + * + * \sa cbor_value_is_valid(), cbor_value_is_length_known() + */ + +/** + * Attempts to find the value in map \a map that corresponds to the text string + * entry \a string. If the iterator \a value does not point to a CBOR map, the + * behaviour is undefined, so checking with \ref cbor_value_get_type or \ref + * cbor_value_is_map is recommended. + * + * If the item is found, it is stored in \a result. If no item is found + * matching the key, then \a result will contain an element of type \ref + * CborInvalidType. Matching is performed using + * cbor_value_text_string_equals(), so tagged strings will also match. + * + * This function has a time complexity of O(n) where n is the number of + * elements in the map to be searched. In addition, this function is has O(n) + * memory requirement based on the number of nested containers (maps or arrays) + * found as elements of this map. + * + * \sa cbor_value_is_valid(), cbor_value_text_string_equals(), cbor_value_advance() + */ +CborError cbor_value_map_find_value(const CborValue *map, const char *string, CborValue *element) +{ + CborError err; + size_t len = strlen(string); + cbor_assert(cbor_value_is_map(map)); + err = cbor_value_enter_container(map, element); + if (err) + goto error; + + while (!cbor_value_at_end(element)) { + /* find the non-tag so we can compare */ + err = cbor_value_skip_tag(element); + if (err) + goto error; + if (cbor_value_is_text_string(element)) { + bool equals; + size_t dummyLen = len; + err = iterate_string_chunks(element, CONST_CAST(char *, string), &dummyLen, + &equals, element, iterate_memcmp); + if (err) + goto error; + if (equals) + return preparse_value(element); + } else { + /* skip this key */ + err = cbor_value_advance(element); + if (err) + goto error; + } + + /* skip this value */ + err = cbor_value_skip_tag(element); + if (err) + goto error; + err = cbor_value_advance(element); + if (err) + goto error; + } + + /* not found */ + element->type = CborInvalidType; + return CborNoError; + +error: + element->type = CborInvalidType; + return err; +} + +/** + * \fn bool cbor_value_is_float(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR + * single-precision floating point (32-bit). + * + * \sa cbor_value_is_valid(), cbor_value_is_double(), cbor_value_is_half_float() + */ + +/** + * \fn CborError cbor_value_get_float(const CborValue *value, float *result) + * + * Retrieves the CBOR single-precision floating point (32-bit) value that \a + * value points to and stores it in \a result. If the iterator \a value does + * not point to a single-precision floating point value, the behavior is + * undefined, so checking with \ref cbor_value_get_type or with \ref + * cbor_value_is_float is recommended. + * + * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_float(), cbor_value_get_double() + */ + +/** + * \fn bool cbor_value_is_double(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR + * double-precision floating point (64-bit). + * + * \sa cbor_value_is_valid(), cbor_value_is_float(), cbor_value_is_half_float() + */ + +/** + * \fn CborError cbor_value_get_double(const CborValue *value, float *result) + * + * Retrieves the CBOR double-precision floating point (64-bit) value that \a + * value points to and stores it in \a result. If the iterator \a value does + * not point to a double-precision floating point value, the behavior is + * undefined, so checking with \ref cbor_value_get_type or with \ref + * cbor_value_is_double is recommended. + * + * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_double(), cbor_value_get_float() + */ + +/** + * \fn bool cbor_value_is_half_float(const CborValue *value) + * + * Returns true if the iterator \a value is valid and points to a CBOR + * single-precision floating point (16-bit). + * + * \sa cbor_value_is_valid(), cbor_value_is_double(), cbor_value_is_float() + */ + +/** + * \fn CborError cbor_value_get_half_float(const CborValue *value, void *result) + * + * Retrieves the CBOR half-precision floating point (16-bit) value that \a + * value points to and stores it in \a result. If the iterator \a value does + * not point to a half-precision floating point value, the behavior is + * undefined, so checking with \ref cbor_value_get_type or with \ref + * cbor_value_is_half_float is recommended. + * + * Note: since the C language does not have a standard type for half-precision + * floating point, this function takes a \c{void *} as a parameter for the + * storage area, which must be at least 16 bits wide. + * + * \sa cbor_value_get_type(), cbor_value_is_valid(), cbor_value_is_half_float(), cbor_value_get_float() + */ + +/** @} */ diff --git a/src/3rdparty/tinycbor/src/compilersupport_p.h b/src/3rdparty/tinycbor/src/compilersupport_p.h new file mode 100644 index 0000000000..dc4c4cfd8a --- /dev/null +++ b/src/3rdparty/tinycbor/src/compilersupport_p.h @@ -0,0 +1,264 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Intel Corporation +** +** 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 +** AUTHORS OR COPYRIGHT HOLDERS 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. +** +****************************************************************************/ + +#ifndef COMPILERSUPPORT_H +#define COMPILERSUPPORT_H + +#include "cbor.h" + +#ifndef _BSD_SOURCE +# define _BSD_SOURCE +#endif +#ifndef _DEFAULT_SOURCE +# define _DEFAULT_SOURCE +#endif +#ifndef assert +# include <assert.h> +#endif +#include <float.h> +#include <math.h> +#include <stddef.h> +#include <stdint.h> +#include <string.h> + +#ifndef __cplusplus +# include <stdbool.h> +#endif + +#ifdef __F16C__ +# include <immintrin.h> +#endif + +#if __STDC_VERSION__ >= 201112L || __cplusplus >= 201103L || __cpp_static_assert >= 200410 +# define cbor_static_assert(x) static_assert(x, #x) +#elif !defined(__cplusplus) && defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 406) && (__STDC_VERSION__ > 199901L) +# define cbor_static_assert(x) _Static_assert(x, #x) +#else +# define cbor_static_assert(x) ((void)sizeof(char[2*!!(x) - 1])) +#endif +#if __STDC_VERSION__ >= 199901L || defined(__cplusplus) +/* inline is a keyword */ +#else +/* use the definition from cbor.h */ +# define inline CBOR_INLINE +#endif + +#ifdef NDEBUG +# define cbor_assert(cond) do { if (!(cond)) unreachable(); } while (0) +#else +# define cbor_assert(cond) assert(cond) +#endif + +#ifndef STRINGIFY +#define STRINGIFY(x) STRINGIFY2(x) +#endif +#define STRINGIFY2(x) #x + +#if !defined(UINT32_MAX) || !defined(INT64_MAX) +/* C89? We can define UINT32_MAX portably, but not INT64_MAX */ +# error "Your system has stdint.h but that doesn't define UINT32_MAX or INT64_MAX" +#endif + +#ifndef DBL_DECIMAL_DIG +/* DBL_DECIMAL_DIG is C11 */ +# define DBL_DECIMAL_DIG 17 +#endif +#define DBL_DECIMAL_DIG_STR STRINGIFY(DBL_DECIMAL_DIG) + +#if defined(__GNUC__) && defined(__i386__) && !defined(__iamcu__) +# define CBOR_INTERNAL_API_CC __attribute__((regparm(3))) +#elif defined(_MSC_VER) && defined(_M_IX86) +# define CBOR_INTERNAL_API_CC __fastcall +#else +# define CBOR_INTERNAL_API_CC +#endif + +#ifndef __has_builtin +# define __has_builtin(x) 0 +#endif + +#if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) || \ + (__has_builtin(__builtin_bswap64) && __has_builtin(__builtin_bswap32)) +# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +# define cbor_ntohll __builtin_bswap64 +# define cbor_htonll __builtin_bswap64 +# define cbor_ntohl __builtin_bswap32 +# define cbor_htonl __builtin_bswap32 +# ifdef __INTEL_COMPILER +# define cbor_ntohs _bswap16 +# define cbor_htons _bswap16 +# elif (__GNUC__ * 100 + __GNUC_MINOR__ >= 608) || __has_builtin(__builtin_bswap16) +# define cbor_ntohs __builtin_bswap16 +# define cbor_htons __builtin_bswap16 +# else +# define cbor_ntohs(x) (((uint16_t)x >> 8) | ((uint16_t)x << 8)) +# define cbor_htons cbor_ntohs +# endif +# else +# define cbor_ntohll +# define cbor_htonll +# define cbor_ntohl +# define cbor_htonl +# define cbor_ntohs +# define cbor_htons +# endif +#elif defined(__sun) +# include <sys/byteorder.h> +#elif defined(_MSC_VER) +/* MSVC, which implies Windows, which implies little-endian and sizeof(long) == 4 */ +# include <stdlib.h> +# define cbor_ntohll _byteswap_uint64 +# define cbor_htonll _byteswap_uint64 +# define cbor_ntohl _byteswap_ulong +# define cbor_htonl _byteswap_ulong +# define cbor_ntohs _byteswap_ushort +# define cbor_htons _byteswap_ushort +#endif +#ifndef cbor_ntohs +# include <arpa/inet.h> +# define cbor_ntohs ntohs +# define cbor_htons htons +#endif +#ifndef cbor_ntohl +# include <arpa/inet.h> +# define cbor_ntohl ntohl +# define cbor_htonl htonl +#endif +#ifndef cbor_ntohll +# define cbor_ntohll ntohll +# define cbor_htonll htonll +/* ntohll isn't usually defined */ +# ifndef ntohll +# if (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) || \ + (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && __BYTE_ORDER == __BIG_ENDIAN) || \ + (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN) || \ + (defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)) || (defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)) || \ + defined(__ARMEB__) || defined(__MIPSEB__) || defined(__s390__) || defined(__sparc__) +# define ntohll +# define htonll +# elif (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || \ + (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN) || \ + (defined(BYTE_ORDER) && defined(LITTLE_ENDIAN) && BYTE_ORDER == LITTLE_ENDIAN) || \ + defined(_LITTLE_ENDIAN) || defined(__LITTLE_ENDIAN__) || defined(__ARMEL__) || defined(__MIPSEL__) || \ + defined(__i386) || defined(__i386__) || defined(__x86_64) || defined(__x86_64__) || defined(__amd64) +# define ntohll(x) ((ntohl((uint32_t)(x)) * UINT64_C(0x100000000)) + (ntohl((x) >> 32))) +# define htonll ntohll +# else +# error "Unable to determine byte order!" +# endif +# endif +#endif + + +#ifdef __cplusplus +# define CONST_CAST(t, v) const_cast<t>(v) +#else +/* C-style const_cast without triggering a warning with -Wcast-qual */ +# define CONST_CAST(t, v) (t)(uintptr_t)(v) +#endif + +#ifdef __GNUC__ +#ifndef likely +# define likely(x) __builtin_expect(!!(x), 1) +#endif +#ifndef unlikely +# define unlikely(x) __builtin_expect(!!(x), 0) +#endif +# define unreachable() __builtin_unreachable() +#elif defined(_MSC_VER) +# define likely(x) (x) +# define unlikely(x) (x) +# define unreachable() __assume(0) +#else +# define likely(x) (x) +# define unlikely(x) (x) +# define unreachable() do {} while (0) +#endif + +static inline bool add_check_overflow(size_t v1, size_t v2, size_t *r) +{ +#if ((defined(__GNUC__) && (__GNUC__ >= 5)) && !defined(__INTEL_COMPILER)) || __has_builtin(__builtin_add_overflow) + return __builtin_add_overflow(v1, v2, r); +#else + /* unsigned additions are well-defined */ + *r = v1 + v2; + return v1 > v1 + v2; +#endif +} + +static inline unsigned short encode_half(double val) +{ +#ifdef __F16C__ + return _cvtss_sh((float)val, 3); +#else + uint64_t v; + int sign, exp, mant; + memcpy(&v, &val, sizeof(v)); + sign = v >> 63 << 15; + exp = (v >> 52) & 0x7ff; + mant = v << 12 >> 12 >> (53-11); /* keep only the 11 most significant bits of the mantissa */ + exp -= 1023; + if (exp == 1024) { + /* infinity or NaN */ + exp = 16; + mant >>= 1; + } else if (exp >= 16) { + /* overflow, as largest number */ + exp = 15; + mant = 1023; + } else if (exp >= -14) { + /* regular normal */ + } else if (exp >= -24) { + /* subnormal */ + mant |= 1024; + mant >>= -(exp + 14); + exp = -15; + } else { + /* underflow, make zero */ + return 0; + } + + /* safe cast here as bit operations above guarantee not to overflow */ + return (unsigned short)(sign | ((exp + 15) << 10) | mant); +#endif +} + +/* this function was copied & adapted from RFC 7049 Appendix D */ +static inline double decode_half(unsigned short half) +{ +#ifdef __F16C__ + return _cvtsh_ss(half); +#else + int exp = (half >> 10) & 0x1f; + int mant = half & 0x3ff; + double val; + if (exp == 0) val = ldexp(mant, -24); + else if (exp != 31) val = ldexp(mant + 1024, exp - 25); + else val = mant == 0 ? INFINITY : NAN; + return half & 0x8000 ? -val : val; +#endif +} + +#endif /* COMPILERSUPPORT_H */ + diff --git a/src/3rdparty/tinycbor/src/tinycbor-version.h b/src/3rdparty/tinycbor/src/tinycbor-version.h new file mode 100644 index 0000000000..c26560cce8 --- /dev/null +++ b/src/3rdparty/tinycbor/src/tinycbor-version.h @@ -0,0 +1,3 @@ +#define TINYCBOR_VERSION_MAJOR 0 +#define TINYCBOR_VERSION_MINOR 6 +#define TINYCBOR_VERSION_PATCH 0 diff --git a/src/3rdparty/tinycbor/tests/.gitignore b/src/3rdparty/tinycbor/tests/.gitignore new file mode 100644 index 0000000000..e65577d287 --- /dev/null +++ b/src/3rdparty/tinycbor/tests/.gitignore @@ -0,0 +1,15 @@ +Makefile +debug +moc_predefs.h +release +target_wrapper.* + +# The executables +cpp/cpp +cpp/cpp.exe +encoder/encoder +encoder/encoder.exe +parser/parser +parser/parser.exe +tojson/tojson +tojson/tojson.exe diff --git a/src/3rdparty/tinycbor/tests/encoder/data.cpp b/src/3rdparty/tinycbor/tests/encoder/data.cpp new file mode 100644 index 0000000000..c33fb605aa --- /dev/null +++ b/src/3rdparty/tinycbor/tests/encoder/data.cpp @@ -0,0 +1,310 @@ +/**************************************************************************** +** +** Copyright (C) 2018 Intel Corporation +** +** 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 +** AUTHORS OR COPYRIGHT HOLDERS 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. +** +****************************************************************************/ + +#include <QtTest> + +static float myNaNf() +{ + uint32_t v = 0x7fc00000; + float f; + memcpy(&f, &v, sizeof(f)); + Q_ASSERT(qIsNaN(f)); + return f; +} + +static float myInff() +{ + uint32_t v = 0x7f800000; + float f; + memcpy(&f, &v, sizeof(f)); + Q_ASSERT(qIsInf(f)); + return f; +} + +static float myNInff() +{ + uint32_t v = 0xff800000; + float f; + memcpy(&f, &v, sizeof(f)); + Q_ASSERT(qIsInf(f)); + return f; +} + +static double myNaN() +{ + uint64_t v = UINT64_C(0x7ff8000000000000); + double f; + memcpy(&f, &v, sizeof(f)); + Q_ASSERT(qIsNaN(f)); + return f; +} + +static double myInf() +{ + uint64_t v = UINT64_C(0x7ff0000000000000); + double f; + memcpy(&f, &v, sizeof(f)); + Q_ASSERT(qIsInf(f)); + return f; +} + +static double myNInf() +{ + uint64_t v = UINT64_C(0xfff0000000000000); + double f; + memcpy(&f, &v, sizeof(f)); + Q_ASSERT(qIsInf(f)); + return f; +} + +template <size_t N> QByteArray raw(const char (&data)[N]) +{ + return QByteArray::fromRawData(data, N - 1); +} + +struct NegativeInteger { quint64 abs; }; +Q_DECLARE_METATYPE(NegativeInteger) + +struct SimpleType { uint8_t type; }; +Q_DECLARE_METATYPE(SimpleType) + +struct Float16Standin { uint16_t val; }; +Q_DECLARE_METATYPE(Float16Standin) + +struct Tag { CborTag tag; QVariant tagged; }; +Q_DECLARE_METATYPE(Tag) + +template <typename... Args> +QVariant make_list(const Args &... args) +{ + return QVariantList{args...}; +} + +typedef QVector<QPair<QVariant, QVariant>> Map; +Q_DECLARE_METATYPE(Map) +QVariant make_map(const std::initializer_list<QPair<QVariant, QVariant>> &list) +{ + return QVariant::fromValue(Map(list)); +} + +struct IndeterminateLengthArray : QVariantList { using QVariantList::QVariantList; }; +struct IndeterminateLengthMap : Map { using Map::Map; }; +Q_DECLARE_METATYPE(IndeterminateLengthArray) +Q_DECLARE_METATYPE(IndeterminateLengthMap) + +QVariant make_ilarray(const std::initializer_list<QVariant> &list) +{ + return QVariant::fromValue(IndeterminateLengthArray(list)); +} + +QVariant make_ilmap(const std::initializer_list<QPair<QVariant, QVariant>> &list) +{ + return QVariant::fromValue(IndeterminateLengthMap(list)); +} + +void addColumns() +{ + QTest::addColumn<QByteArray>("output"); + QTest::addColumn<QVariant>("input"); +} + +void addFixedData() +{ + // unsigned integers + QTest::newRow("0U") << raw("\x00") << QVariant(0U); + QTest::newRow("1U") << raw("\x01") << QVariant(1U); + QTest::newRow("10U") << raw("\x0a") << QVariant(10U); + QTest::newRow("23U") << raw("\x17") << QVariant(23U); + QTest::newRow("24U") << raw("\x18\x18") << QVariant(24U); + QTest::newRow("255U") << raw("\x18\xff") << QVariant(255U); + QTest::newRow("256U") << raw("\x19\x01\x00") << QVariant(256U); + QTest::newRow("65535U") << raw("\x19\xff\xff") << QVariant(65535U); + QTest::newRow("65536U") << raw("\x1a\0\1\x00\x00") << QVariant(65536U); + QTest::newRow("4294967295U") << raw("\x1a\xff\xff\xff\xff") << QVariant(4294967295U); + QTest::newRow("4294967296U") << raw("\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_UINT64_C(4294967296)); + QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff") + << QVariant(std::numeric_limits<quint64>::max()); + + // signed integers containing non-negative numbers + QTest::newRow("0") << raw("\x00") << QVariant(0); + QTest::newRow("1") << raw("\x01") << QVariant(1); + QTest::newRow("10") << raw("\x0a") << QVariant(10); + QTest::newRow("23") << raw("\x17") << QVariant(23); + QTest::newRow("24") << raw("\x18\x18") << QVariant(24); + QTest::newRow("255") << raw("\x18\xff") << QVariant(255); + QTest::newRow("256") << raw("\x19\x01\x00") << QVariant(256); + QTest::newRow("65535") << raw("\x19\xff\xff") << QVariant(65535); + QTest::newRow("65536") << raw("\x1a\0\1\x00\x00") << QVariant(65536); + QTest::newRow("4294967295") << raw("\x1a\xff\xff\xff\xff") << QVariant(Q_INT64_C(4294967295)); + QTest::newRow("4294967296") << raw("\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(4294967296)); + + // signed integers containing negative numbers + QTest::newRow("-1") << raw("\x20") << QVariant(-1); + QTest::newRow("-2") << raw("\x21") << QVariant(-2); + QTest::newRow("-24") << raw("\x37") << QVariant(-24); + QTest::newRow("-25") << raw("\x38\x18") << QVariant(-25); + QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << QVariant(-256); + QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << QVariant(-257); + QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << QVariant(-65536); + QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << QVariant(-65537); + QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << QVariant(Q_INT64_C(-4294967296)); + QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(-4294967297)); + + // negative integers + auto neg = [](quint64 v) { return QVariant::fromValue<NegativeInteger>({v}); }; + QTest::newRow("negative1") << raw("\x20") << neg(1); + QTest::newRow("negative2") << raw("\x21") << neg(2); + QTest::newRow("negative24") << raw("\x37") << neg(24); + QTest::newRow("negative25") << raw("\x38\x18") << neg(25); + QTest::newRow("negativeUINT8_MAX") << raw("\x38\xff") << neg(256); + QTest::newRow("negativeUINT8_MAX-1") << raw("\x39\x01\x00") << neg(257); + QTest::newRow("negativeUINT16_MAX") << raw("\x39\xff\xff") << neg(65536); + QTest::newRow("negativeUINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << neg(65537); + QTest::newRow("negativeUINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << neg(Q_UINT64_C(4294967296)); + QTest::newRow("negativeUINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << neg(Q_UINT64_C(4294967297)); + QTest::newRow("negativeUINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe") + << neg(std::numeric_limits<quint64>::max()); + QTest::newRow("negativeUINT64_MAX+1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff") << neg(0); + + QTest::newRow("simple0") << raw("\xe0") << QVariant::fromValue(SimpleType{0}); + QTest::newRow("simple19") << raw("\xf3") << QVariant::fromValue(SimpleType{19}); + QTest::newRow("false") << raw("\xf4") << QVariant(false); + QTest::newRow("true") << raw("\xf5") << QVariant(true); + QTest::newRow("null") << raw("\xf6") << QVariant::fromValue<void *>(nullptr); + QTest::newRow("undefined") << raw("\xf7") << QVariant(); + QTest::newRow("simple32") << raw("\xf8\x20") << QVariant::fromValue(SimpleType{32}); + QTest::newRow("simple255") << raw("\xf8\xff") << QVariant::fromValue(SimpleType{255}); + + // floating point +#if QT_VERSION < QT_VERSION_CHECK(5, 9, 0) + QTest::newRow("0.f16") << raw("\xf9\0\0") << QVariant::fromValue(Float16Standin{0x0000}); +#else + QTest::newRow("0.f16") << raw("\xf9\0\0") << QVariant::fromValue(qfloat16(0)); + QTest::newRow("-1.f16") << raw("\xf9\xbc\0") << QVariant::fromValue(qfloat16(-1)); + QTest::newRow("1.5f16") << raw("\xf9\x3e\0") << QVariant::fromValue(qfloat16(1.5)); + QTest::newRow("nan_f16") << raw("\xf9\x7e\0") << QVariant::fromValue<qfloat16>(myNaNf()); + QTest::newRow("-inf_f16") << raw("\xf9\xfc\0") << QVariant::fromValue<qfloat16>(myNInff()); + QTest::newRow("+inf_f16") << raw("\xf9\x7c\0") << QVariant::fromValue<qfloat16>(myInff()); +#endif + + QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << QVariant::fromValue(0.f); + QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << QVariant(0.); + QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << QVariant::fromValue(-1.f); + QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << QVariant(-1.); + QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << QVariant::fromValue(16777215.f); + QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << QVariant::fromValue(16777215.); + QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << QVariant(-16777215.f); + QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << QVariant::fromValue(-16777215.); + + QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << QVariant::fromValue<float>(myNaNf()); + QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << QVariant(myNaN()); + QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << QVariant::fromValue<float>(myNInff()); + QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << QVariant(myNInf()); + QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << QVariant::fromValue<float>(myInff()); + QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << QVariant(myInf()); +} + +void addStringsData() +{ + // byte strings + QTest::newRow("emptybytestring") << raw("\x40") << QVariant(QByteArray("")); + QTest::newRow("bytestring1") << raw("\x41 ") << QVariant(QByteArray(" ")); + QTest::newRow("bytestring1-nul") << raw("\x41\0") << QVariant(QByteArray("", 1)); + QTest::newRow("bytestring5") << raw("\x45Hello") << QVariant(QByteArray("Hello")); + QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234") + << QVariant(QByteArray("123456789012345678901234")); + QTest::newRow("bytestring256") << raw("\x59\1\0") + QByteArray(256, '3') + << QVariant(QByteArray(256, '3')); + + // text strings + QTest::newRow("emptytextstring") << raw("\x60") << QVariant(""); + QTest::newRow("textstring1") << raw("\x61 ") << QVariant(" "); + QTest::newRow("textstring1-nul") << raw("\x61\0") << QVariant(QString::fromLatin1("", 1)); + QTest::newRow("textstring5") << raw("\x65Hello") << QVariant("Hello"); + QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234") + << QVariant("123456789012345678901234"); + QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3') + << QVariant(QString(256, '3')); +} + +void addArraysAndMaps() +{ + QTest::newRow("emptyarray") << raw("\x80") << make_list(); + QTest::newRow("emptymap") << raw("\xa0") << make_map({}); + + QTest::newRow("array-0") << raw("\x81\0") << make_list(0); + QTest::newRow("array-{0-0}") << raw("\x82\0\0") << make_list(0, 0); + QTest::newRow("array-Hello") << raw("\x81\x65Hello") << make_list("Hello"); + QTest::newRow("array-array-0") << raw("\x81\x81\0") << make_list(make_list(0)); + QTest::newRow("array-array-{0-0}") << raw("\x81\x82\0\0") << make_list(make_list(0, 0)); + QTest::newRow("array-array-0-0") << raw("\x82\x81\0\0") << make_list(make_list(0),0); + QTest::newRow("array-array-Hello") << raw("\x81\x81\x65Hello") << make_list(make_list("Hello")); + + QTest::newRow("map-0:0") << raw("\xa1\0\0") << make_map({{0,0}}); + QTest::newRow("map-0:0-1:1") << raw("\xa2\0\0\1\1") << make_map({{0,0}, {1,1}}); + QTest::newRow("map-0:{map-0:0-1:1}") << raw("\xa1\0\xa2\0\0\1\1") << make_map({{0, make_map({{0,0}, {1,1}})}}); + + QTest::newRow("array-map1") << raw("\x81\xa1\0\0") << make_list(make_map({{0,0}})); + QTest::newRow("array-map2") << raw("\x82\xa1\0\0\xa1\1\1") << make_list(make_map({{0,0}}), make_map({{1,1}})); + + QTest::newRow("map-array1") << raw("\xa1\x62oc\x81\0") << make_map({{"oc", make_list(0)}}); + QTest::newRow("map-array2") << raw("\xa1\x62oc\x84\0\1\2\3") << make_map({{"oc", make_list(0, 1, 2, 3)}}); + QTest::newRow("map-array3") << raw("\xa2\x62oc\x82\0\1\2\3") << make_map({{"oc", make_list(0, 1)}, {2, 3}}); + + // indeterminate length + QTest::newRow("_emptyarray") << raw("\x9f\xff") << QVariant::fromValue(IndeterminateLengthArray{}); + QTest::newRow("_emptymap") << raw("\xbf\xff") << make_ilmap({}); + + QTest::newRow("_array-0") << raw("\x9f\0\xff") << make_ilarray({0}); + QTest::newRow("_array-{0-0}") << raw("\x9f\0\0\xff") << make_ilarray({0, 0}); + QTest::newRow("_array-Hello") << raw("\x9f\x65Hello\xff") << make_ilarray({"Hello"}); + QTest::newRow("_array-array-0") << raw("\x9f\x81\0\xff") << make_ilarray({make_list(0)}); + QTest::newRow("_array-_array-0") << raw("\x9f\x9f\0\xff\xff") << make_ilarray({make_ilarray({0})}); + QTest::newRow("_array-_array-{0-0}") << raw("\x9f\x9f\0\0\xff\xff") << make_ilarray({make_ilarray({0, 0})}); + QTest::newRow("_array-_array-0-0") << raw("\x9f\x9f\0\xff\0\xff") << make_ilarray({make_ilarray({0}),0}); + QTest::newRow("_array-_array-Hello") << raw("\x9f\x9f\x65Hello\xff\xff") << make_ilarray({make_ilarray({"Hello"})}); + + QTest::newRow("_map-0:0") << raw("\xbf\0\0\xff") << make_ilmap({{0,0}}); + QTest::newRow("_map-0:0-1:1") << raw("\xbf\0\0\1\1\xff") << make_ilmap({{0,0}, {1,1}}); + QTest::newRow("_map-0:{map-0:0-1:1}") << raw("\xbf\0\xa2\0\0\1\1\xff") << make_ilmap({{0, make_map({{0,0}, {1,1}})}}); + QTest::newRow("_map-0:{_map-0:0-1:1}") << raw("\xbf\0\xbf\0\0\1\1\xff\xff") << make_ilmap({{0, make_ilmap({{0,0}, {1,1}})}}); + + QTest::newRow("_array-map1") << raw("\x9f\xa1\0\0\xff") << make_ilarray({make_map({{0,0}})}); + QTest::newRow("_array-_map1") << raw("\x9f\xbf\0\0\xff\xff") << make_ilarray({make_ilmap({{0,0}})}); + QTest::newRow("_array-map2") << raw("\x9f\xa1\0\0\xa1\1\1\xff") << make_ilarray({make_map({{0,0}}), make_map({{1,1}})}); + QTest::newRow("_array-_map2") << raw("\x9f\xbf\0\0\xff\xbf\1\1\xff\xff") << make_ilarray({make_ilmap({{0,0}}), make_ilmap({{1,1}})}); + + QTest::newRow("_map-array1") << raw("\xbf\x62oc\x81\0\xff") << make_ilmap({{"oc", make_list(0)}}); + QTest::newRow("_map-_array1") << raw("\xbf\x62oc\x9f\0\xff\xff") << make_ilmap({{"oc", make_ilarray({0})}}); + QTest::newRow("_map-array2") << raw("\xbf\x62oc\x84\0\1\2\3\xff") << make_ilmap({{"oc", make_list(0, 1, 2, 3)}}); + QTest::newRow("_map-_array2") << raw("\xbf\x62oc\x9f\0\1\2\3\xff\xff") << make_ilmap({{"oc", make_ilarray({0, 1, 2, 3})}}); + QTest::newRow("_map-array3") << raw("\xbf\x62oc\x82\0\1\2\3\xff") << make_ilmap({{"oc", make_list(0, 1)}, {2, 3}}); + QTest::newRow("_map-_array3") << raw("\xbf\x62oc\x9f\0\1\xff\2\3\xff") << make_ilmap({{"oc", make_ilarray({0, 1})}, {2, 3}}); + + // tagged + QTest::newRow("array-1(0)") << raw("\x81\xc1\0") << make_list(QVariant::fromValue(Tag{1, 0})); + QTest::newRow("array-1(map)") << raw("\x81\xc1\xa0") << make_list(QVariant::fromValue(Tag{1, make_map({})})); + QTest::newRow("map-1(2):3(4)") << raw("\xa1\xc1\2\xc3\4") << make_map({{QVariant::fromValue(Tag{1, 2}), QVariant::fromValue(Tag{3, 4})}}); +} + diff --git a/src/3rdparty/tinycbor/tests/encoder/encoder.pro b/src/3rdparty/tinycbor/tests/encoder/encoder.pro new file mode 100644 index 0000000000..62d9b7e409 --- /dev/null +++ b/src/3rdparty/tinycbor/tests/encoder/encoder.pro @@ -0,0 +1,9 @@ +SOURCES += tst_encoder.cpp + +CONFIG += testcase parallel_test c++11 +QT = core testlib + +INCLUDEPATH += ../../src +msvc: POST_TARGETDEPS = ../../lib/tinycbor.lib +else: POST_TARGETDEPS += ../../lib/libtinycbor.a +LIBS += $$POST_TARGETDEPS diff --git a/src/3rdparty/tinycbor/tests/encoder/tst_encoder.cpp b/src/3rdparty/tinycbor/tests/encoder/tst_encoder.cpp new file mode 100644 index 0000000000..f30c522601 --- /dev/null +++ b/src/3rdparty/tinycbor/tests/encoder/tst_encoder.cpp @@ -0,0 +1,496 @@ +/**************************************************************************** +** +** Copyright (C) 2016 Intel Corporation +** +** 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 +** AUTHORS OR COPYRIGHT HOLDERS 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. +** +****************************************************************************/ + +#include <QtTest> +#include "cbor.h" + +#if QT_VERSION >= QT_VERSION_CHECK(5, 9, 0) +#include <qfloat16.h> +#endif + +Q_DECLARE_METATYPE(CborError) +namespace QTest { +template<> char *toString<CborError>(const CborError &err) +{ + return qstrdup(cbor_error_string(err)); +} +} + +class tst_Encoder : public QObject +{ + Q_OBJECT +private slots: + void fixed_data(); + void fixed(); + void strings_data(); + void strings() { fixed(); } + void arraysAndMaps_data(); + void arraysAndMaps() { fixed(); } + void tags_data(); + void tags(); + void arrays_data() { tags_data(); } + void arrays(); + void maps_data() { tags_data(); } + void maps(); + + void writerApi_data() { tags_data(); } + void writerApi(); + void writerApiFail_data() { tags_data(); } + void writerApiFail(); + void shortBuffer_data() { tags_data(); } + void shortBuffer(); + void tooShortArrays_data() { tags_data(); } + void tooShortArrays(); + void tooShortMaps_data() { tags_data(); } + void tooShortMaps(); + void tooBigArrays_data() { tags_data(); } + void tooBigArrays(); + void tooBigMaps_data() { tags_data(); } + void tooBigMaps(); + void illegalSimpleType_data(); + void illegalSimpleType(); +}; + +#include "tst_encoder.moc" +#include "data.cpp" + +static inline bool isOomError(CborError err) +{ + return err == CborErrorOutOfMemory; +} + +CborError encodeVariant(CborEncoder *encoder, const QVariant &v) +{ + int type = v.userType(); + switch (type) { + case QVariant::Int: + case QVariant::LongLong: + return cbor_encode_int(encoder, v.toLongLong()); + + case QVariant::UInt: + case QVariant::ULongLong: + return cbor_encode_uint(encoder, v.toULongLong()); + + case QVariant::Bool: + return cbor_encode_boolean(encoder, v.toBool()); + + case QVariant::Invalid: + return cbor_encode_undefined(encoder); + + case QMetaType::VoidStar: + return cbor_encode_null(encoder); + + case QVariant::Double: + return cbor_encode_double(encoder, v.toDouble()); + + case QMetaType::Float: + return cbor_encode_float(encoder, v.toFloat()); + + case QVariant::String: { + QByteArray string = v.toString().toUtf8(); + return cbor_encode_text_string(encoder, string.constData(), string.length()); + } + + case QVariant::ByteArray: { + QByteArray string = v.toByteArray(); + return cbor_encode_byte_string(encoder, reinterpret_cast<const quint8 *>(string.constData()), string.length()); + } + + default: + if (type == qMetaTypeId<NegativeInteger>()) + return cbor_encode_negative_int(encoder, v.value<NegativeInteger>().abs); + if (type == qMetaTypeId<SimpleType>()) + return cbor_encode_simple_value(encoder, v.value<SimpleType>().type); +#if QT_VERSION < QT_VERSION_CHECK(5, 9, 0) + if (type == qMetaTypeId<Float16Standin>()) + return cbor_encode_half_float(encoder, v.constData()); +#else + if (type == qMetaTypeId<qfloat16>()) + return cbor_encode_half_float(encoder, v.constData()); +#endif + if (type == qMetaTypeId<Tag>()) { + CborError err = cbor_encode_tag(encoder, v.value<Tag>().tag); + if (err && !isOomError(err)) + return err; + return static_cast<CborError>(err | encodeVariant(encoder, v.value<Tag>().tagged)); + } + if (type == QVariant::List || type == qMetaTypeId<IndeterminateLengthArray>()) { + CborEncoder sub; + QVariantList list = v.toList(); + size_t len = list.length(); + if (type == qMetaTypeId<IndeterminateLengthArray>()) { + len = CborIndefiniteLength; + list = v.value<IndeterminateLengthArray>(); + } + CborError err = cbor_encoder_create_array(encoder, &sub, len); + if (err && !isOomError(err)) + return err; + foreach (const QVariant &v2, list) { + err = static_cast<CborError>(err | encodeVariant(&sub, v2)); + if (err && !isOomError(err)) + return err; + } + return cbor_encoder_close_container_checked(encoder, &sub); + } + if (type == qMetaTypeId<Map>() || type == qMetaTypeId<IndeterminateLengthMap>()) { + CborEncoder sub; + Map map = v.value<Map>(); + size_t len = map.length(); + if (type == qMetaTypeId<IndeterminateLengthMap>()) { + len = CborIndefiniteLength; + map = v.value<IndeterminateLengthMap>(); + } + CborError err = cbor_encoder_create_map(encoder, &sub, len); + if (err && !isOomError(err)) + return err; + for (auto pair : map) { + err = static_cast<CborError>(err | encodeVariant(&sub, pair.first)); + if (err && !isOomError(err)) + return err; + err = static_cast<CborError>(err | encodeVariant(&sub, pair.second)); + if (err && !isOomError(err)) + return err; + } + return cbor_encoder_close_container_checked(encoder, &sub); + } + } + return CborErrorUnknownType; +} + +void compare(const QVariant &input, const QByteArray &output) +{ + QByteArray buffer(output.length(), Qt::Uninitialized); + uint8_t *bufptr = reinterpret_cast<quint8 *>(buffer.data()); + CborEncoder encoder; + cbor_encoder_init(&encoder, bufptr, buffer.length(), 0); + + QCOMPARE(encodeVariant(&encoder, input), CborNoError); + QCOMPARE(encoder.remaining, size_t(1)); + QCOMPARE(cbor_encoder_get_extra_bytes_needed(&encoder), size_t(0)); + + buffer.resize(int(cbor_encoder_get_buffer_size(&encoder, bufptr))); + QCOMPARE(buffer, output); +} + +void tst_Encoder::fixed_data() +{ + addColumns(); + addFixedData(); +} + +void tst_Encoder::fixed() +{ + QFETCH(QVariant, input); + QFETCH(QByteArray, output); + compare(input, output); +} + +void tst_Encoder::strings_data() +{ + addColumns(); + addStringsData(); +} + +void tst_Encoder::arraysAndMaps_data() +{ + addColumns(); + addArraysAndMaps(); +} + +void tst_Encoder::tags_data() +{ + addColumns(); + addFixedData(); + addStringsData(); + addArraysAndMaps(); +} + +void tst_Encoder::tags() +{ + QFETCH(QVariant, input); + QFETCH(QByteArray, output); + + compare(QVariant::fromValue(Tag{1, input}), "\xc1" + output); + if (QTest::currentTestFailed()) return; + + compare(QVariant::fromValue(Tag{24, input}), "\xd8\x18" + output); + if (QTest::currentTestFailed()) return; + + compare(QVariant::fromValue(Tag{255, input}), "\xd8\xff" + output); + if (QTest::currentTestFailed()) return; + + compare(QVariant::fromValue(Tag{256, input}), raw("\xd9\1\0") + output); + if (QTest::currentTestFailed()) return; + + compare(QVariant::fromValue(Tag{CborSignatureTag, input}), raw("\xd9\xd9\xf7") + output); + if (QTest::currentTestFailed()) return; + + compare(QVariant::fromValue(Tag{65535, input}), raw("\xd9\xff\xff") + output); + if (QTest::currentTestFailed()) return; + + compare(QVariant::fromValue(Tag{65536, input}), raw("\xda\0\1\0\0") + output); + if (QTest::currentTestFailed()) return; + + compare(QVariant::fromValue(Tag{UINT32_MAX, input}), raw("\xda\xff\xff\xff\xff") + output); + if (QTest::currentTestFailed()) return; + + compare(QVariant::fromValue(Tag{UINT32_MAX + Q_UINT64_C(1), input}), raw("\xdb\0\0\0\1\0\0\0\0") + output); + if (QTest::currentTestFailed()) return; + + compare(QVariant::fromValue(Tag{UINT64_MAX, input}), raw("\xdb\xff\xff\xff\xff\xff\xff\xff\xff") + output); + if (QTest::currentTestFailed()) return; + + // nested tags + compare(QVariant::fromValue(Tag{1, QVariant::fromValue(Tag{1, input})}), "\xc1\xc1" + output); +} + +void tst_Encoder::arrays() +{ + QFETCH(QVariant, input); + QFETCH(QByteArray, output); + + compare(make_list(input), "\x81" + output); + if (QTest::currentTestFailed()) return; + + compare(make_list(input, input), "\x82" + output + output); + if (QTest::currentTestFailed()) return; + + { + QVariantList list{input}; + QByteArray longoutput = output; + + // make a list with 32 elements (1 << 5) + for (int i = 0; i < 5; ++i) { + list += list; + longoutput += longoutput; + } + compare(list, "\x98\x20" + longoutput); + if (QTest::currentTestFailed()) return; + + // now 256 elements (32 << 3) + for (int i = 0; i < 3; ++i) { + list += list; + longoutput += longoutput; + } + compare(list, raw("\x99\1\0") + longoutput); + if (QTest::currentTestFailed()) return; + } + + // nested lists + compare(make_list(make_list(input)), "\x81\x81" + output); + if (QTest::currentTestFailed()) return; + + compare(make_list(make_list(input, input)), "\x81\x82" + output + output); + if (QTest::currentTestFailed()) return; + + compare(make_list(make_list(input), input), "\x82\x81" + output + output); + if (QTest::currentTestFailed()) return; + + compare(make_list(make_list(input), make_list(input)), "\x82\x81" + output + "\x81" + output); +} + +void tst_Encoder::maps() +{ + QFETCH(QVariant, input); + QFETCH(QByteArray, output); + + compare(make_map({{1, input}}), "\xa1\1" + output); + if (QTest::currentTestFailed()) return; + + compare(make_map({{1, input}, {input, 24}}), "\xa2\1" + output + output + "\x18\x18"); + if (QTest::currentTestFailed()) return; + + compare(make_map({{input, input}}), "\xa1" + output + output); + if (QTest::currentTestFailed()) return; + + { + Map map{{1, input}}; + QByteArray longoutput = "\1" + output; + + // make a map with 32 elements (1 << 5) + for (int i = 0; i < 5; ++i) { + map += map; + longoutput += longoutput; + } + compare(QVariant::fromValue(map), "\xb8\x20" + longoutput); + if (QTest::currentTestFailed()) return; + + // now 256 elements (32 << 3) + for (int i = 0; i < 3; ++i) { + map += map; + longoutput += longoutput; + } + compare(QVariant::fromValue(map), raw("\xb9\1\0") + longoutput); + if (QTest::currentTestFailed()) return; + } + + // nested maps + compare(make_map({{1, make_map({{2, input}})}}), "\xa1\1\xa1\2" + output); + if (QTest::currentTestFailed()) return; + + compare(make_map({{1, make_map({{2, input}, {input, false}})}}), "\xa1\1\xa2\2" + output + output + "\xf4"); + if (QTest::currentTestFailed()) return; + + compare(make_map({{1, make_map({{2, input}})}, {input, false}}), "\xa2\1\xa1\2" + output + output + "\xf4"); + if (QTest::currentTestFailed()) return; +} + +void tst_Encoder::writerApi() +{ + QFETCH(QVariant, input); + QFETCH(QByteArray, output); + + // instead of writing to a QByteArray like all other tests, write to a QBuffer + QBuffer buffer; + buffer.open(QIODevice::ReadWrite); + auto callback = [](void *token, const void *data, size_t len, CborEncoderAppendType) { + auto buffer = static_cast<QBuffer *>(token); + buffer->write(static_cast<const char *>(data), len); + return CborNoError; + }; + + CborEncoder encoder; + cbor_encoder_init_writer(&encoder, callback, &buffer); + QCOMPARE(encodeVariant(&encoder, input), CborNoError); + + buffer.reset(); + QCOMPARE(buffer.readAll(), output); +} + +void tst_Encoder::writerApiFail() +{ + QFETCH(QVariant, input); + QFETCH(QByteArray, output); + + // same as above, but we'll produce an error during writing and we expect + // it to be returned + int callCount = 0; + auto callback = [](void *token, const void *, size_t, CborEncoderAppendType) { + ++*static_cast<int *>(token); + return CborErrorIO; + }; + + CborEncoder encoder; + cbor_encoder_init_writer(&encoder, callback, &callCount); + QCOMPARE(encodeVariant(&encoder, input), CborErrorIO); + QCOMPARE(callCount, 1); +} + +void tst_Encoder::shortBuffer() +{ + QFETCH(QVariant, input); + QFETCH(QByteArray, output); + QByteArray buffer(output.length(), Qt::Uninitialized); + + for (int len = 0; len < output.length(); ++len) { + CborEncoder encoder; + cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), len, 0); + QCOMPARE(encodeVariant(&encoder, input), CborErrorOutOfMemory); + QVERIFY(cbor_encoder_get_extra_bytes_needed(&encoder) != 0); + QCOMPARE(len + cbor_encoder_get_extra_bytes_needed(&encoder), size_t(output.length())); + } +} + +void tst_Encoder::tooShortArrays() +{ + QFETCH(QVariant, input); + QFETCH(QByteArray, output); + QByteArray buffer(output.length() + 1, Qt::Uninitialized); + + CborEncoder encoder, container; + cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0); + QCOMPARE(cbor_encoder_create_array(&encoder, &container, 2), CborNoError); + QCOMPARE(encodeVariant(&container, input), CborNoError); + QCOMPARE(container.remaining, size_t(2)); + QCOMPARE(cbor_encoder_close_container_checked(&encoder, &container), CborErrorTooFewItems); +} + +void tst_Encoder::tooShortMaps() +{ + QFETCH(QVariant, input); + QFETCH(QByteArray, output); + QByteArray buffer(output.length() + 1, Qt::Uninitialized); + + CborEncoder encoder, container; + cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0); + QCOMPARE(cbor_encoder_create_map(&encoder, &container, 2), CborNoError); + QCOMPARE(encodeVariant(&container, input), CborNoError); + QCOMPARE(container.remaining, size_t(4)); + QCOMPARE(cbor_encoder_close_container_checked(&encoder, &container), CborErrorTooFewItems); +} + +void tst_Encoder::tooBigArrays() +{ + QFETCH(QVariant, input); + QFETCH(QByteArray, output); + QByteArray buffer(output.length() * 2 + 1, Qt::Uninitialized); + + CborEncoder encoder, container; + cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0); + QCOMPARE(cbor_encoder_create_array(&encoder, &container, 1), CborNoError); + QCOMPARE(encodeVariant(&container, input), CborNoError); + QCOMPARE(encodeVariant(&container, input), CborNoError); + QCOMPARE(container.remaining, size_t(0)); + QCOMPARE(cbor_encoder_close_container_checked(&encoder, &container), CborErrorTooManyItems); +} + +void tst_Encoder::tooBigMaps() +{ + QFETCH(QVariant, input); + QFETCH(QByteArray, output); + QByteArray buffer(output.length() * 3 + 1, Qt::Uninitialized); + + CborEncoder encoder, container; + cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0); + QCOMPARE(cbor_encoder_create_map(&encoder, &container, 1), CborNoError); + QCOMPARE(encodeVariant(&container, input), CborNoError); + QCOMPARE(encodeVariant(&container, input), CborNoError); + QCOMPARE(encodeVariant(&container, input), CborNoError); + QCOMPARE(container.remaining, size_t(0)); + QCOMPARE(cbor_encoder_close_container_checked(&encoder, &container), CborErrorTooManyItems); +} + +void tst_Encoder::illegalSimpleType_data() +{ + QTest::addColumn<int>("type"); + QTest::newRow("half-float") << 25; + QTest::newRow("float") << 26; + QTest::newRow("double") << 27; + QTest::newRow("28") << 28; + QTest::newRow("29") << 29; + QTest::newRow("30") << 30; + QTest::newRow("31") << 31; +} + +void tst_Encoder::illegalSimpleType() +{ + QFETCH(int, type); + + quint8 buf[2]; + CborEncoder encoder; + cbor_encoder_init(&encoder, buf, sizeof(buf), 0); + QCOMPARE(cbor_encode_simple_value(&encoder, type), CborErrorIllegalSimpleType); +} + +QTEST_MAIN(tst_Encoder) diff --git a/src/3rdparty/tinycbor/tests/parser/data.cpp b/src/3rdparty/tinycbor/tests/parser/data.cpp new file mode 100644 index 0000000000..0ab0e47be4 --- /dev/null +++ b/src/3rdparty/tinycbor/tests/parser/data.cpp @@ -0,0 +1,573 @@ +#include <QtTest> +#include <limits> +#include <cbor.h> + +Q_DECLARE_METATYPE(CborError) + +template <size_t N> QByteArray raw(const char (&data)[N]) +{ + return QByteArray::fromRawData(data, N - 1); +} + +void addIntegers() +{ + QTest::addColumn<QByteArray>("data"); + QTest::addColumn<quint64>("expectedRaw"); + QTest::addColumn<qint64>("expectedValue"); + QTest::addColumn<bool>("isNegative"); + QTest::addColumn<bool>("inInt64Range"); + + // unsigned integers + QTest::newRow("0") << raw("\x00") << Q_UINT64_C(0) << Q_INT64_C(0) << false << true; + QTest::newRow("1") << raw("\x01") << Q_UINT64_C(1) << Q_INT64_C(1) << false << true; + QTest::newRow("10") << raw("\x0a") << Q_UINT64_C(10) << Q_INT64_C(10) << false << true; + QTest::newRow("23") << raw("\x17") << Q_UINT64_C(23) << Q_INT64_C(23) << false << true; + QTest::newRow("24") << raw("\x18\x18") << Q_UINT64_C(24) << Q_INT64_C(24) << false << true; + QTest::newRow("UINT8_MAX") << raw("\x18\xff") << Q_UINT64_C(255) << Q_INT64_C(255) << false << true; + QTest::newRow("UINT8_MAX+1") << raw("\x19\x01\x00") << Q_UINT64_C(256) << Q_INT64_C(256) << false << true; + QTest::newRow("UINT16_MAX") << raw("\x19\xff\xff") << Q_UINT64_C(65535) << Q_INT64_C(65535) << false << true; + QTest::newRow("UINT16_MAX+1") << raw("\x1a\0\1\x00\x00") << Q_UINT64_C(65536) << Q_INT64_C(65536) << false << true; + QTest::newRow("UINT32_MAX") << raw("\x1a\xff\xff\xff\xff") << Q_UINT64_C(4294967295) << Q_INT64_C(4294967295) << false << true; + QTest::newRow("UINT32_MAX+1") << raw("\x1b\0\0\0\1\0\0\0\0") << Q_UINT64_C(4294967296) << Q_INT64_C(4294967296) << false << true; + QTest::newRow("INT64_MAX") << raw("\x1b" "\x7f\xff\xff\xff" "\xff\xff\xff\xff") + << quint64(std::numeric_limits<qint64>::max()) + << std::numeric_limits<qint64>::max() << false << true; + QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff") + << std::numeric_limits<quint64>::max() << qint64(-123456) << false << false; + + // negative integers + QTest::newRow("-1") << raw("\x20") << Q_UINT64_C(0) << Q_INT64_C(-1) << true << true; + QTest::newRow("-2") << raw("\x21") << Q_UINT64_C(1) << Q_INT64_C(-2) << true << true; + QTest::newRow("-24") << raw("\x37") << Q_UINT64_C(23) << Q_INT64_C(-24) << true << true; + QTest::newRow("-25") << raw("\x38\x18") << Q_UINT64_C(24) << Q_INT64_C(-25) << true << true; + QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << Q_UINT64_C(255) << Q_INT64_C(-256) << true << true; + QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << Q_UINT64_C(256) << Q_INT64_C(-257) << true << true; + QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << Q_UINT64_C(65535) << Q_INT64_C(-65536) << true << true; + QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << Q_UINT64_C(65536) << Q_INT64_C(-65537) << true << true; + QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << Q_UINT64_C(4294967295) << Q_INT64_C(-4294967296) << true << true; + QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << Q_UINT64_C(4294967296) << Q_INT64_C(-4294967297) << true << true; + QTest::newRow("INT64_MIN+1") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xfe") + << quint64(std::numeric_limits<qint64>::max() - 1) + << (std::numeric_limits<qint64>::min() + 1) + << true << true; + QTest::newRow("INT64_MIN") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xff") + << quint64(std::numeric_limits<qint64>::max()) + << std::numeric_limits<qint64>::min() + << true << true; + QTest::newRow("INT64_MIN-1") << raw("\x3b\x80\0\0\0""\0\0\0\0") << Q_UINT64_C(9223372036854775808) << qint64(-123456) << true << false; + QTest::newRow("-UINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe") + << (std::numeric_limits<quint64>::max() - 1) << qint64(-123456) << true << false; + QTest::newRow("-UINT64_MAX+1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff") + << std::numeric_limits<quint64>::max() << qint64(-123456) << true << false; +} + +void addColumns() +{ + QTest::addColumn<QByteArray>("data"); + QTest::addColumn<QString>("expected"); + QTest::addColumn<int>("n"); // some aux integer, not added in all columns +} + +void addFixedData() +{ + // unsigned integers + QTest::newRow("0") << raw("\x00") << "0"; + QTest::newRow("1") << raw("\x01") << "1"; + QTest::newRow("10") << raw("\x0a") << "10"; + QTest::newRow("23") << raw("\x17") << "23"; + QTest::newRow("24") << raw("\x18\x18") << "24"; + QTest::newRow("UINT8_MAX") << raw("\x18\xff") << "255"; + QTest::newRow("UINT8_MAX+1") << raw("\x19\x01\x00") << "256"; + QTest::newRow("UINT16_MAX") << raw("\x19\xff\xff") << "65535"; + QTest::newRow("UINT16_MAX+1") << raw("\x1a\0\1\x00\x00") << "65536"; + QTest::newRow("UINT32_MAX") << raw("\x1a\xff\xff\xff\xff") << "4294967295"; + QTest::newRow("UINT32_MAX+1") << raw("\x1b\0\0\0\1\0\0\0\0") << "4294967296"; + QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff") + << QString::number(std::numeric_limits<uint64_t>::max()); + + // negative integers + QTest::newRow("-1") << raw("\x20") << "-1"; + QTest::newRow("-2") << raw("\x21") << "-2"; + QTest::newRow("-24") << raw("\x37") << "-24"; + QTest::newRow("-25") << raw("\x38\x18") << "-25"; + QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << "-256"; + QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << "-257"; + QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << "-65536"; + QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << "-65537"; + QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << "-4294967296"; + QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << "-4294967297"; + QTest::newRow("INT64_MIN+1") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xfe") + << QString::number(std::numeric_limits<int64_t>::min() + 1); + QTest::newRow("INT64_MIN") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xff") + << QString::number(std::numeric_limits<int64_t>::min()); + QTest::newRow("INT64_MIN-1") << raw("\x3b\x80\0\0\0""\0\0\0\0") << "-9223372036854775809"; + QTest::newRow("-UINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe") + << '-' + QString::number(std::numeric_limits<uint64_t>::max()); + QTest::newRow("-UINT64_MAX+1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff") + << "-18446744073709551616"; + + // overlongs + QTest::newRow("0*1") << raw("\x18\x00") << "0_0"; + QTest::newRow("0*2") << raw("\x19\x00\x00") << "0_1"; + QTest::newRow("0*4") << raw("\x1a\0\0\0\0") << "0_2"; + QTest::newRow("0*8") << raw("\x1b\0\0\0\0\0\0\0\0") << "0_3"; + QTest::newRow("-1*1") << raw("\x38\x00") << "-1_0"; + QTest::newRow("-1*2") << raw("\x39\x00\x00") << "-1_1"; + QTest::newRow("-1*4") << raw("\x3a\0\0\0\0") << "-1_2"; + QTest::newRow("-1*8") << raw("\x3b\0\0\0\0\0\0\0\0") << "-1_3"; + + QTest::newRow("simple0") << raw("\xe0") << "simple(0)"; + QTest::newRow("simple19") << raw("\xf3") << "simple(19)"; + QTest::newRow("false") << raw("\xf4") << "false"; + QTest::newRow("true") << raw("\xf5") << "true"; + QTest::newRow("null") << raw("\xf6") << "null"; + QTest::newRow("undefined") << raw("\xf7") << "undefined"; + QTest::newRow("simple32") << raw("\xf8\x20") << "simple(32)"; + QTest::newRow("simple255") << raw("\xf8\xff") << "simple(255)"; + + // floating point + + QTest::newRow("0.f16") << raw("\xf9\0\0") << "0.f16"; + QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << "0.f"; + QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << "0."; + QTest::newRow("-1.f16") << raw("\xf9\xbc\x00") << "-1.f16"; + QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << "-1.f"; + QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << "-1."; + QTest::newRow("65504.f16") << raw("\xf9\x7b\xff") << "65504.f16"; + QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << "16777215.f"; + QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << "16777215."; + QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << "-16777215.f"; + QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << "-16777215."; + + QTest::newRow("0.5f16") << raw("\xf9\x38\0") << "0.5f16"; + QTest::newRow("0.5f") << raw("\xfa\x3f\0\0\0") << "0.5f"; + QTest::newRow("0.5") << raw("\xfb\x3f\xe0\0\0\0\0\0\0") << "0.5"; + QTest::newRow("2.f16^11-1") << raw("\xf9\x67\xff") << "2047.f16"; + QTest::newRow("2.f^24-1") << raw("\xfa\x4b\x7f\xff\xff") << "16777215.f"; + QTest::newRow("2.^53-1") << raw("\xfb\x43\x3f\xff\xff""\xff\xff\xff\xff") << "9007199254740991."; + QTest::newRow("2.f^64-epsilon") << raw("\xfa\x5f\x7f\xff\xff") << "18446742974197923840.f"; + QTest::newRow("2.^64-epsilon") << raw("\xfb\x43\xef\xff\xff""\xff\xff\xff\xff") << "18446744073709549568."; + QTest::newRow("2.f^64") << raw("\xfa\x5f\x80\0\0") << "1.8446744073709552e+19f"; + QTest::newRow("2.^64") << raw("\xfb\x43\xf0\0\0\0\0\0\0") << "1.8446744073709552e+19"; + + QTest::newRow("nan_f16") << raw("\xf9\x7e\x00") << "nan"; + QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << "nan"; + QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << "nan"; + QTest::newRow("-inf_f16") << raw("\xf9\xfc\x00") << "-inf"; + QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << "-inf"; + QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << "-inf"; + QTest::newRow("+inf_f16") << raw("\xf9\x7c\x00") << "inf"; + QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << "inf"; + QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << "inf"; + +} + +void addNonChunkedStringsData() +{ + // byte strings + QTest::newRow("emptybytestring") << raw("\x40") << "h''"; + QTest::newRow("bytestring1") << raw("\x41 ") << "h'20'"; + QTest::newRow("bytestring1-nul") << raw("\x41\0") << "h'00'"; + QTest::newRow("bytestring5") << raw("\x45Hello") << "h'48656c6c6f'"; + QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234") + << "h'313233343536373839303132333435363738393031323334'"; + QTest::newRow("bytestring256") << raw("\x59\1\0") + QByteArray(256, '3') + << "h'" + QString(256 * 2, '3') + '\''; + + // text strings + QTest::newRow("emptytextstring") << raw("\x60") << "\"\""; + QTest::newRow("textstring1") << raw("\x61 ") << "\" \""; + QTest::newRow("textstring1-nul") << raw("\x61\0") << "\"\\u0000\""; + QTest::newRow("textstring5") << raw("\x65Hello") << "\"Hello\""; + QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234") + << "\"123456789012345678901234\""; + QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3') + << '"' + QString(256, '3') + '"'; + + // some strings with UTF-8 content + // we had a bug in the pretty dumper - see issue #54 + QTest::newRow("textstringutf8-2char") << raw("\x62\xc2\xa0") << "\"\\u00A0\""; + QTest::newRow("textstringutf8-2char2") << raw("\x64\xc2\xa0\xc2\xa9") << "\"\\u00A0\\u00A9\""; + QTest::newRow("textstringutf8-3char") << raw("\x63\xe2\x88\x80") << "\"\\u2200\""; + QTest::newRow("textstringutf8-4char") << raw("\x64\xf0\x90\x88\x83") << "\"\\uD800\\uDE03\""; + + // strings with overlong length + QTest::newRow("emptybytestring*1") << raw("\x58\x00") << "h''_0"; + QTest::newRow("emptytextstring*1") << raw("\x78\x00") << "\"\"_0"; + QTest::newRow("emptybytestring*2") << raw("\x59\x00\x00") << "h''_1"; + QTest::newRow("emptytextstring*2") << raw("\x79\x00\x00") << "\"\"_1"; + QTest::newRow("emptybytestring*4") << raw("\x5a\0\0\0\0") << "h''_2"; + QTest::newRow("emptytextstring*4") << raw("\x7a\0\0\0\0") << "\"\"_2"; + QTest::newRow("emptybytestring*8") << raw("\x5b\0\0\0\0\0\0\0\0") << "h''_3"; + QTest::newRow("emptytextstring*8") << raw("\x7b\0\0\0\0\0\0\0\0") << "\"\"_3"; + QTest::newRow("bytestring5*1") << raw("\x58\x05Hello") << "h'48656c6c6f'_0"; + QTest::newRow("textstring5*1") << raw("\x78\x05Hello") << "\"Hello\"_0"; + QTest::newRow("bytestring5*2") << raw("\x59\0\5Hello") << "h'48656c6c6f'_1"; + QTest::newRow("textstring5*2") << raw("\x79\0\x05Hello") << "\"Hello\"_1"; + QTest::newRow("bytestring5*4") << raw("\x5a\0\0\0\5Hello") << "h'48656c6c6f'_2"; + QTest::newRow("textstring5*4") << raw("\x7a\0\0\0\x05Hello") << "\"Hello\"_2"; + QTest::newRow("bytestring5*8") << raw("\x5b\0\0\0\0\0\0\0\5Hello") << "h'48656c6c6f'_3"; + QTest::newRow("textstring5*8") << raw("\x7b\0\0\0\0\0\0\0\x05Hello") << "\"Hello\"_3"; + +} + +void addStringsData() +{ + addNonChunkedStringsData(); + + // strings with undefined length + QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "(_ )"; + QTest::newRow("_emptytextstring") << raw("\x7f\xff") << "(_ )"; + QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << "(_ h'')"; + QTest::newRow("_emptytextstring2") << raw("\x7f\x60\xff") << "(_ \"\")"; + QTest::newRow("_emptybytestring2*1") << raw("\x5f\x58\x00\xff") << "(_ h''_0)"; + QTest::newRow("_emptytextstring2*1") << raw("\x7f\x78\x00\xff") << "(_ \"\"_0)"; + QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << "(_ h'', h'')"; + QTest::newRow("_emptytextstring3") << raw("\x7f\x60\x60\xff") << "(_ \"\", \"\")"; + QTest::newRow("_emptybytestring3*2") << raw("\x5f\x59\x00\x00\x40\xff") << "(_ h''_1, h'')"; + QTest::newRow("_emptytextstring3*2") << raw("\x7f\x79\x00\x00\x60\xff") << "(_ \"\"_1, \"\")"; + QTest::newRow("_bytestring5x2") << raw("\x5f\x43Hel\x42lo\xff") << "(_ h'48656c', h'6c6f')"; + QTest::newRow("_textstring5x2") << raw("\x7f\x63Hel\x62lo\xff") << "(_ \"Hel\", \"lo\")"; + QTest::newRow("_bytestring5x2*8*4") << raw("\x5f\x5b\0\0\0\0\0\0\0\3Hel\x5a\0\0\0\2lo\xff") << "(_ h'48656c'_3, h'6c6f'_2)"; + QTest::newRow("_textstring5x2*8*4") << raw("\x7f\x7b\0\0\0\0\0\0\0\3Hel\x7a\0\0\0\2lo\xff") << "(_ \"Hel\"_3, \"lo\"_2)"; + QTest::newRow("_bytestring5x5") << raw("\x5f\x41H\x41""e\x41l\x41l\x41o\xff") << "(_ h'48', h'65', h'6c', h'6c', h'6f')"; + QTest::newRow("_textstring5x5") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "(_ \"H\", \"e\", \"l\", \"l\", \"o\")"; + QTest::newRow("_bytestring5x6") << raw("\x5f\x41H\x41""e\x40\x41l\x41l\x41o\xff") << "(_ h'48', h'65', h'', h'6c', h'6c', h'6f')"; + QTest::newRow("_textstring5x6") << raw("\x7f\x61H\x61""e\x61l\x60\x61l\x61o\xff") << "(_ \"H\", \"e\", \"l\", \"\", \"l\", \"o\")"; +} + +void addTagsData() +{ + // since parseOne() works recursively for tags, we can't test lone tags + QTest::newRow("tag0") << raw("\xc0\x00") << "0(0)"; + QTest::newRow("tag1") << raw("\xc1\x00") << "1(0)"; + QTest::newRow("tag24") << raw("\xd8\x18\x00") << "24(0)"; + QTest::newRow("tag255") << raw("\xd8\xff\x00") << "255(0)"; + QTest::newRow("tag256") << raw("\xd9\1\0\x00") << "256(0)"; + QTest::newRow("tag65535") << raw("\xd9\xff\xff\x00") << "65535(0)"; + QTest::newRow("tag65536") << raw("\xda\0\1\0\0\x00") << "65536(0)"; + QTest::newRow("tagUINT32_MAX-1") << raw("\xda\xff\xff\xff\xff\x00") << "4294967295(0)"; + QTest::newRow("tagUINT32_MAX") << raw("\xdb\0\0\0\1\0\0\0\0\x00") << "4294967296(0)"; + QTest::newRow("tagUINT64_MAX") << raw("\xdb" "\xff\xff\xff\xff" "\xff\xff\xff\xff" "\x00") + << QString::number(std::numeric_limits<uint64_t>::max()) + "(0)"; + + // overlong tags + QTest::newRow("tag0*1") << raw("\xd8\0\x00") << "0_0(0)"; + QTest::newRow("tag0*2") << raw("\xd9\0\0\x00") << "0_1(0)"; + QTest::newRow("tag0*4") << raw("\xda\0\0\0\0\x00") << "0_2(0)"; + QTest::newRow("tag0*8") << raw("\xdb\0\0\0\0\0\0\0\0\x00") << "0_3(0)"; + + // tag other things + QTest::newRow("unixtime") << raw("\xc1\x1a\x55\x4b\xbf\xd3") << "1(1431027667)"; + QTest::newRow("rfc3339date") << raw("\xc0\x78\x19" "2015-05-07 12:41:07-07:00") + << "0(\"2015-05-07 12:41:07-07:00\")"; + QTest::newRow("tag6+false") << raw("\xc6\xf4") << "6(false)"; + QTest::newRow("tag25+true") << raw("\xd8\x19\xf5") << "25(true)"; + QTest::newRow("tag256+null") << raw("\xd9\1\0\xf6") << "256(null)"; + QTest::newRow("tag65536+simple32") << raw("\xda\0\1\0\0\xf8\x20") << "65536(simple(32))"; + QTest::newRow("float+unixtime") << raw("\xc1\xfa\x4e\xaa\x97\x80") << "1(1431027712.f)"; + QTest::newRow("double+unixtime") << raw("\xc1\xfb" "\x41\xd5\x52\xef" "\xf4\xc7\xce\xfe") + << "1(1431027667.1220088)"; +} + +void addEmptyContainersData() +{ + QTest::newRow("emptyarray") << raw("\x80") << "[]" << 0; + QTest::newRow("emptymap") << raw("\xa0") << "{}" << 0; + QTest::newRow("_emptyarray") << raw("\x9f\xff") << "[_ ]" << -1; + QTest::newRow("_emptymap") << raw("\xbf\xff") << "{_ }" << -1; +} + +void addMapMixedData() +{ + QTest::newRow("map-0-24") << raw("\xa1\0\x18\x18") << "{0: 24}" << 1; + QTest::newRow("map-0*1-24") << raw("\xa1\x18\0\x18\x18") << "{0_0: 24}" << 1; + QTest::newRow("map-0*1-24*2") << raw("\xa1\x18\0\x19\0\x18") << "{0_0: 24_1}" << 1; + QTest::newRow("map-0*4-24*2") << raw("\xa1\x1a\0\0\0\0\x19\0\x18") << "{0_2: 24_1}" << 1; + QTest::newRow("map-24-0") << raw("\xa1\x18\x18\0") << "{24: 0}" << 1; + QTest::newRow("map-24-0*1") << raw("\xa1\x18\x18\x18\0") << "{24: 0_0}" << 1; + QTest::newRow("map-255-65535") << raw("\xa1\x18\xff\x19\xff\xff") << "{255: 65535}" << 1; + + QTest::newRow("_map-0-24") << raw("\xbf\0\x18\x18\xff") << "{_ 0: 24}" << 1; + QTest::newRow("_map-0*1-24") << raw("\xbf\x18\0\x18\x18\xff") << "{_ 0_0: 24}" << 1; + QTest::newRow("_map-0*1-24*2") << raw("\xbf\x18\0\x19\0\x18\xff") << "{_ 0_0: 24_1}" << 1; + QTest::newRow("_map-0*4-24*2") << raw("\xbf\x1a\0\0\0\0\x19\0\x18\xff") << "{_ 0_2: 24_1}" << 1; + QTest::newRow("_map-24-0") << raw("\xbf\x18\x18\0\xff") << "{_ 24: 0}" << 1; + QTest::newRow("_map-24-0*1") << raw("\xbf\x18\x18\x18\0\xff") << "{_ 24: 0_0}" << 1; + QTest::newRow("_map-255-65535") << raw("\xbf\x18\xff\x19\xff\xff\xff") << "{_ 255: 65535}" << 1; +} + +void addChunkedStringData() +{ + QTest::addColumn<QByteArray>("data"); + QTest::addColumn<QString>("concatenated"); + QTest::addColumn<QStringList>("chunks"); + + // non-chunked: + QTest::newRow("emptybytestring") << raw("\x40") << "h''" << QStringList{"h''"}; + QTest::newRow("bytestring1") << raw("\x41 ") << "h'20'" << QStringList{"h'20'"}; + QTest::newRow("emptytextstring") << raw("\x60") << "\"\"" << QStringList{"\"\""}; + QTest::newRow("textstring1") << raw("\x61 ") << "\" \"" << QStringList{"\" \""}; + + // empty chunked: + QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "h''" << QStringList{}; + QTest::newRow("_emptytextstring") << raw("\x7f\xff") << "\"\"" << QStringList{}; + QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << "h''" << QStringList{"h''"}; + QTest::newRow("_emptytextstring2") << raw("\x7f\x60\xff") << "\"\"" << QStringList{"\"\""}; + QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << "h''" << QStringList{"h''", "h''"}; + QTest::newRow("_emptytextstring3") << raw("\x7f\x60\x60\xff") << "\"\"" << QStringList{"\"\"", "\"\""}; + + // regular chunks + QTest::newRow("_bytestring1") << raw("\x5f\x41 \xff") << "h'20'" << QStringList{"h'20'"}; + QTest::newRow("_bytestring2") << raw("\x5f\x41 \x41z\xff") << "h'207a'" << QStringList{"h'20'", "h'7a'"}; + QTest::newRow("_bytestring3") << raw("\x5f\x41 \x58\x18""123456789012345678901234\x41z\xff") + << "h'203132333435363738393031323334353637383930313233347a'" + << QStringList{"h'20'", "h'313233343536373839303132333435363738393031323334'", "h'7a'"}; + + QTest::newRow("_textstring1") << raw("\x7f\x61 \xff") << "\" \"" << QStringList{"\" \""}; + QTest::newRow("_textstring2") << raw("\x7f\x61 \x61z\xff") << "\" z\"" << QStringList{"\" \"", "\"z\""}; + QTest::newRow("_textstring3") << raw("\x7f\x61 \x78\x18""123456789012345678901234\x61z\xff") + << "\" 123456789012345678901234z\"" + << QStringList{"\" \"", "\"123456789012345678901234\"", "\"z\""}; +} + +void addValidationColumns() +{ + QTest::addColumn<QByteArray>("data"); + QTest::addColumn<int>("flags"); // future + QTest::addColumn<CborError>("expectedError"); +} + +void addValidationData() +{ + // illegal numbers are future extension points + QTest::newRow("illegal-number-in-unsigned-1") << raw("\x81\x1c") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-unsigned-2") << raw("\x81\x1d") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-unsigned-3") << raw("\x81\x1e") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-unsigned-4") << raw("\x81\x1f") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-negative-1") << raw("\x81\x3c") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-negative-2") << raw("\x81\x3d") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-negative-3") << raw("\x81\x3e") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-negative-4") << raw("\x81\x3f") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-bytearray-length-1") << raw("\x81\x5c") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-bytearray-length-2") << raw("\x81\x5d") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-bytearray-length-3") << raw("\x81\x5e") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-string-length-1") << raw("\x81\x7c") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-string-length-2") << raw("\x81\x7d") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-string-length-3") << raw("\x81\x7e") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-array-length-1") << raw("\x81\x9c") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-array-length-2") << raw("\x81\x9d") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-array-length-3") << raw("\x81\x9e") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-map-length-1") << raw("\x81\xbc") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-map-length-2") << raw("\x81\xbd") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-map-length-3") << raw("\x81\xbe") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-tag-1") << raw("\x81\xdc") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-tag-2") << raw("\x81\xdd") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-tag-3") << raw("\x81\xde") << 0 << CborErrorIllegalNumber; + QTest::newRow("illegal-number-in-tag-4") << raw("\x81\xdf") << 0 << CborErrorIllegalNumber; + + QTest::newRow("unsigned-too-short-1-0") << raw("\x81\x18") << 0 << CborErrorUnexpectedEOF; // requires 1 byte, 0 given + QTest::newRow("unsigned-too-short-2-0") << raw("\x81\x19") << 0 << CborErrorUnexpectedEOF; // requires 2 bytes, 0 given + QTest::newRow("unsigned-too-short-2-1") << raw("\x81\x19\x01") << 0 << CborErrorUnexpectedEOF; // etc + QTest::newRow("unsigned-too-short-4-0") << raw("\x81\x1a") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("unsigned-too-short-4-3") << raw("\x81\x1a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("unsigned-too-short-8-0") << raw("\x81\x1b") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("unsigned-too-short-8-7") << raw("\x81\x1b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("negative-length-too-short-1-0") << raw("\x81\x38") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("negative-length-too-short-2-0") << raw("\x81\x39") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("negative-length-too-short-2-1") << raw("\x81\x39\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("negative-length-too-short-4-0") << raw("\x81\x3a") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("negative-length-too-short-4-3") << raw("\x81\x3a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("negative-length-too-short-8-0") << raw("\x81\x3b") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("negative-length-too-short-8-7") << raw("\x81\x3b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-length-too-short-1-0") << raw("\x81\x58") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-length-too-short-2-0") << raw("\x81\x59") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-length-too-short-2-1") << raw("\x81\x59\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-length-too-short-4-0") << raw("\x81\x5a") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-length-too-short-4-3") << raw("\x81\x5a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-length-too-short-8-0") << raw("\x81\x5b") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-length-too-short-8-7") << raw("\x81\x5b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-length-too-short-1-0") << raw("\x81\x78") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-length-too-short-2-0") << raw("\x81\x79") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-length-too-short-2-1") << raw("\x81\x79\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-length-too-short-4-0") << raw("\x81\x7a") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-length-too-short-4-3") << raw("\x81\x7a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-length-too-short-8-0") << raw("\x81\x7b") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-length-too-short-8-7") << raw("\x81\x7b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-length-too-short-1-0") << raw("\x81\x5f\x58") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-length-too-short-2-0") << raw("\x81\x5f\x59") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-length-too-short-2-1") << raw("\x81\x5f\x59\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-length-too-short-4-0") << raw("\x81\x5f\x5a") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-length-too-short-4-3") << raw("\x81\x5f\x5a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-length-too-short-8-0") << raw("\x81\x5f\x5b") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-length-too-short-8-7") << raw("\x81\x5f\x5b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-length-too-short-1-0") << raw("\x81\x7f\x78") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-length-too-short-2-0") << raw("\x81\x7f\x79") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-length-too-short-2-1") << raw("\x81\x7f\x79\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-length-too-short-4-0") << raw("\x81\x7f\x7a") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-length-too-short-4-3") << raw("\x81\x7f\x7a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-length-too-short-8-0") << raw("\x81\x7f\x7b") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-length-too-short-8-7") << raw("\x81\x7f\x7b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-2-length-too-short-1-0") << raw("\x81\x5f\x40\x58") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-2-length-too-short-2-0") << raw("\x81\x5f\x40\x59") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-2-length-too-short-2-1") << raw("\x81\x5f\x40\x59\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-2-length-too-short-4-0") << raw("\x81\x5f\x40\x5a") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-2-length-too-short-4-3") << raw("\x81\x5f\x40\x5a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-2-length-too-short-8-0") << raw("\x81\x5f\x40\x5b") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-2-length-too-short-8-7") << raw("\x81\x5f\x40\x5b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-2-length-too-short-1-0") << raw("\x81\x7f\x60\x78") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-2-length-too-short-2-0") << raw("\x81\x7f\x60\x79") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-2-length-too-short-2-1") << raw("\x81\x7f\x60\x79\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-2-length-too-short-4-0") << raw("\x81\x7f\x60\x7a") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-2-length-too-short-4-3") << raw("\x81\x7f\x60\x7a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-2-length-too-short-8-0") << raw("\x81\x7f\x60\x7b") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-2-length-too-short-8-7") << raw("\x81\x7f\x60\x7b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("array-length-too-short-1-0") << raw("\x81\x98") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("array-length-too-short-2-0") << raw("\x81\x99") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("array-length-too-short-2-1") << raw("\x81\x99\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("array-length-too-short-4-0") << raw("\x81\x9a") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("array-length-too-short-4-3") << raw("\x81\x9a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("array-length-too-short-8-0") << raw("\x81\x9b") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("array-length-too-short-8-7") << raw("\x81\x9b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("map-length-too-short-1-0") << raw("\x81\xb8") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("map-length-too-short-2-0") << raw("\x81\xb9") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("map-length-too-short-2-1") << raw("\x81\xb9\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("map-length-too-short-4-0") << raw("\x81\xba") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("map-length-too-short-4-3") << raw("\x81\xba\x01\x02\x03") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("map-length-too-short-8-0") << raw("\x81\xbb") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("map-length-too-short-8-7") << raw("\x81\xbb\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("tag-too-short-1-0") << raw("\x81\xd8") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("tag-too-short-2-0") << raw("\x81\xd9") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("tag-too-short-2-1") << raw("\x81\xd9\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("tag-too-short-4-0") << raw("\x81\xda") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("tag-too-short-4-3") << raw("\x81\xda\x01\x02\x03") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("tag-too-short-8-0") << raw("\x81\xdb") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("tag-too-short-8-7") << raw("\x81\xdb\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("fp16-too-short1") << raw("\x81\xf9") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("fp16-too-short2") << raw("\x81\xf9\x00") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("float-too-short1") << raw("\x81\xfa") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("float-too-short2") << raw("\x81\xfa\0\0\0") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("double-too-short1") << raw("\x81\xfb") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("double-too-short2") << raw("\x81\xfb\0\0\0\0\0\0\0") << 0 << CborErrorUnexpectedEOF; + + QTest::newRow("bytearray-too-short1") << raw("\x81\x42z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-too-short2") << raw("\x81\x58\x02z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-too-short3") << raw("\x81\x5a\0\0\0\2z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-too-short4") << raw("\x81\x5b\0\0\0\0\0\0\0\2z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-too-short1") << raw("\x81\x62z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-too-short2") << raw("\x81\x78\x02z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-too-short3") << raw("\x81\x7a\0\0\0\2z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-too-short4") << raw("\x81\x7b\0\0\0\0\0\0\0\2z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-too-short1") << raw("\x81\x5f\x42z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-too-short2") << raw("\x81\x5f\x58\x02z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-too-short3") << raw("\x81\x5f\x5a\0\0\0\2z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-too-short4") << raw("\x81\x5f\x5b\0\0\0\0\0\0\0\2z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-too-short1") << raw("\x81\x7f\x62z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-too-short2") << raw("\x81\x7f\x78\x02z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-too-short3") << raw("\x81\x7f\x7a\0\0\0\2z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-too-short4") << raw("\x81\x7f\x7b\0\0\0\0\0\0\0\2z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-too-short1x2") << raw("\x81\x5f\x40\x42z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-too-short2x2") << raw("\x81\x5f\x40\x58\x02z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-too-short3x2") << raw("\x81\x5f\x40\x5a\0\0\0\2z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-chunked-too-short4x2") << raw("\x81\x5f\x40\x5b\0\0\0\0\0\0\0\2z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-too-short1x2") << raw("\x81\x7f\x60\x62z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-too-short2x2") << raw("\x81\x7f\x60\x78\x02z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-too-short3x2") << raw("\x81\x7f\x60\x7a\0\0\0\2z") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunked-too-short4x2") << raw("\x81\x7f\x60\x7b\0\0\0\0\0\0\0\2z") << 0 << CborErrorUnexpectedEOF; + + QTest::newRow("bytearray-no-break1") << raw("\x81\x5f") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("bytearray-no-break2") << raw("\x81\x5f\x40") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-no-break1") << raw("\x81\x7f") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-no-break2") << raw("\x81\x7f\x60") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("array-no-break1") << raw("\x81\x9f") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("array-no-break2") << raw("\x81\x9f\0") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("map-no-break1") << raw("\x81\xbf") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("map-no-break2") << raw("\x81\xbf\0\0") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("map-break-after-key") << raw("\x81\xbf\0\xff") << 0 << CborErrorUnexpectedBreak; + QTest::newRow("map-break-after-value-tag") << raw("\x81\xbf\0\xc0\xff") << 0 << CborErrorUnexpectedBreak; + QTest::newRow("map-break-after-value-tag2") << raw("\x81\xbf\0\xd8\x20\xff") << 0 << CborErrorUnexpectedBreak; + + // check for pointer additions wrapping over the limit of the address space + CborError tooLargeOn32bit = (sizeof(void *) == 4) ? CborErrorDataTooLarge : CborErrorUnexpectedEOF; + // on 32-bit systems, this is a -1 + QTest::newRow("bytearray-wraparound1") << raw("\x81\x5a\xff\xff\xff\xff") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-wraparound1") << raw("\x81\x7a\xff\xff\xff\xff") << 0 << CborErrorUnexpectedEOF; + // on 32-bit systems, a 4GB addition could be dropped + QTest::newRow("bytearray-wraparound2") << raw("\x81\x5b\0\0\0\1\0\0\0\0") << 0 << tooLargeOn32bit; + QTest::newRow("string-wraparound2") << raw("\x81\x7b\0\0\0\1\0\0\0\0") << 0 << tooLargeOn32bit; + // on 64-bit systems, this could be a -1 + QTest::newRow("bytearray-wraparound3") << raw("\x81\x5b\xff\xff\xff\xff\xff\xff\xff\xff") << 0 << tooLargeOn32bit; + QTest::newRow("string-wraparound3") << raw("\x81\x7b\xff\xff\xff\xff\xff\xff\xff\xff") << 0 << tooLargeOn32bit; + + // ditto on chunks + QTest::newRow("bytearray-chunk-wraparound1") << raw("\x81\x5f\x5a\xff\xff\xff\xff") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("string-chunk-wraparound1") << raw("\x81\x7f\x7a\xff\xff\xff\xff") << 0 << CborErrorUnexpectedEOF; + // on 32-bit systems, a 4GB addition could be dropped + QTest::newRow("bytearray-chunk-wraparound2") << raw("\x81\x5f\x5b\0\0\0\1\0\0\0\0") << 0 << tooLargeOn32bit; + QTest::newRow("string-chunk-wraparound2") << raw("\x81\x7f\x7b\0\0\0\1\0\0\0\0") << 0 << tooLargeOn32bit; + // on 64-bit systems, this could be a -1 + QTest::newRow("bytearray-chunk-wraparound3") << raw("\x81\x5f\x5b\xff\xff\xff\xff\xff\xff\xff\xff") << 0 << tooLargeOn32bit; + QTest::newRow("string-chunk-wraparound3") << raw("\x81\x7f\x7b\xff\xff\xff\xff\xff\xff\xff\xff") << 0 << tooLargeOn32bit; + + QTest::newRow("eof-after-array") << raw("\x81") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("eof-after-array2") << raw("\x81\x78\x20") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("eof-after-array-element") << raw("\x81\x82\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("eof-after-object") << raw("\x81\xa1") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("eof-after-object2") << raw("\x81\xb8\x20") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("eof-after-object-key") << raw("\x81\xa1\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("eof-after-object-value") << raw("\x81\xa2\x01\x01") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("eof-after-tag") << raw("\x81\xc0") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("eof-after-tag2") << raw("\x81\xd8\x20") << 0 << CborErrorUnexpectedEOF; + + // major type 7 has future types + QTest::newRow("future-type-28") << raw("\x81\xfc") << 0 << CborErrorUnknownType; + QTest::newRow("future-type-29") << raw("\x81\xfd") << 0 << CborErrorUnknownType; + QTest::newRow("future-type-30") << raw("\x81\xfe") << 0 << CborErrorUnknownType; + QTest::newRow("unexpected-break") << raw("\x81\xff") << 0 << CborErrorUnexpectedBreak; + QTest::newRow("illegal-simple-0") << raw("\x81\xf8\0") << 0 << CborErrorIllegalSimpleType; + QTest::newRow("illegal-simple-31") << raw("\x81\xf8\x1f") << 0 << CborErrorIllegalSimpleType; + + // not only too big (UINT_MAX or UINT_MAX+1 in size), but also incomplete + if (sizeof(size_t) < sizeof(uint64_t)) { + QTest::newRow("bytearray-too-big1") << raw("\x81\x5b\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge; + QTest::newRow("string-too-big1") << raw("\x81\x7b\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge; + } + QTest::newRow("array-too-big1") << raw("\x81\x9a\xff\xff\xff\xff\0\0\0\0") << 0 << CborErrorDataTooLarge; + QTest::newRow("array-too-big2") << raw("\x81\x9b\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge; + QTest::newRow("object-too-big1") << raw("\x81\xba\xff\xff\xff\xff\0\0\0\0") << 0 << CborErrorDataTooLarge; + QTest::newRow("object-too-big2") << raw("\x81\xbb\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge; + + QTest::newRow("no-break-for-array0") << raw("\x81\x9f") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("no-break-for-array1") << raw("\x81\x9f\x01") << 0 << CborErrorUnexpectedEOF; + + QTest::newRow("no-break-string0") << raw("\x81\x7f") << 0 << CborErrorUnexpectedEOF; + QTest::newRow("no-break-string1") << raw("\x81\x7f\x61Z") << 0 << CborErrorUnexpectedEOF; + + QTest::newRow("nested-indefinite-length-bytearrays") << raw("\x81\x5f\x5f\xff\xff") << 0 << CborErrorIllegalNumber; + QTest::newRow("nested-indefinite-length-strings") << raw("\x81\x7f\x7f\xff\xff") << 0 << CborErrorIllegalNumber; + + QTest::newRow("string-chunk-unsigned") << raw("\x81\x7f\0\xff") << 0 << CborErrorIllegalType; + QTest::newRow("string-chunk-negative") << raw("\x81\x7f\x20\xff") << 0 << CborErrorIllegalType; + QTest::newRow("string-chunk-bytearray") << raw("\x81\x7f\x40\xff") << 0 << CborErrorIllegalType; + QTest::newRow("string-chunk-array") << raw("\x81\x7f\x80\xff") << 0 << CborErrorIllegalType; + QTest::newRow("string-chunk-map") << raw("\x81\x7f\xa0\xff") << 0 << CborErrorIllegalType; + QTest::newRow("string-chunk-tag") << raw("\x81\x7f\xc0\xff") << 0 << CborErrorIllegalType; + QTest::newRow("string-chunk-tagged-string") << raw("\x81\x7f\xc0\x60\xff") << 0 << CborErrorIllegalType; + QTest::newRow("string-chunk-simple0") << raw("\x81\x7f\xe0\xff") << 0 << CborErrorIllegalType; + QTest::newRow("string-chunk-false") << raw("\x81\x7f\xf4\xff") << 0 << CborErrorIllegalType; + QTest::newRow("string-chunk-true") << raw("\x81\x7f\xf5\xff") << 0 << CborErrorIllegalType; + QTest::newRow("string-chunk-null") << raw("\x81\x7f\xf6\xff") << 0 << CborErrorIllegalType; + QTest::newRow("string-chunk-undefined") << raw("\x81\x7f\xf7\xff") << 0 << CborErrorIllegalType; + + QTest::newRow("bytearray-chunk-string") << raw("\x81\x5f\x60\xff") << 0 << CborErrorIllegalType; + QTest::newRow("bytearray-chunk-tagged-bytearray") << raw("\x81\x7f\xc0\x40\xff") << 0 << CborErrorIllegalType; + + // RFC 7049 Section 2.2.2 "Indefinite-Length Byte Strings and Text Strings" says + // Text strings with indefinite lengths act the same as byte strings + // with indefinite lengths, except that all their chunks MUST be + // definite-length text strings. Note that this implies that the bytes + // of a single UTF-8 character cannot be spread between chunks: a new + // chunk can only be started at a character boundary. + // This test technically tests the dumper, not the parser. + QTest::newRow("string-utf8-chunk-split") << raw("\x81\x7f\x61\xc2\x61\xa0\xff") << 0 << CborErrorInvalidUtf8TextString; +} diff --git a/src/3rdparty/tinycbor/tests/parser/parser.pro b/src/3rdparty/tinycbor/tests/parser/parser.pro new file mode 100644 index 0000000000..a61291a9e4 --- /dev/null +++ b/src/3rdparty/tinycbor/tests/parser/parser.pro @@ -0,0 +1,10 @@ +SOURCES += tst_parser.cpp ../../src/cborparser.c + +CONFIG += testcase parallel_test c++11 +QT = core testlib +DEFINES += CBOR_PARSER_MAX_RECURSIONS=16 + +INCLUDEPATH += ../../src +msvc: POST_TARGETDEPS = ../../lib/tinycbor.lib +else: POST_TARGETDEPS += ../../lib/libtinycbor.a +LIBS += $$POST_TARGETDEPS diff --git a/src/3rdparty/tinycbor/tests/parser/tst_parser.cpp b/src/3rdparty/tinycbor/tests/parser/tst_parser.cpp new file mode 100644 index 0000000000..74c480bc51 --- /dev/null +++ b/src/3rdparty/tinycbor/tests/parser/tst_parser.cpp @@ -0,0 +1,1667 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Intel Corporation +** +** 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 +** AUTHORS OR COPYRIGHT HOLDERS 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. +** +****************************************************************************/ + +#define _XOPEN_SOURCE 700 +#include <QtTest> +#include "cbor.h" +#include <stdio.h> +#include <stdarg.h> + +namespace QTest { +template<> char *toString<CborError>(const CborError &err) +{ + return qstrdup(cbor_error_string(err)); +} +} + +class tst_Parser : public QObject +{ + Q_OBJECT +private slots: + void initParserEmpty(); + + // parsing API + void integers_data(); + void integers(); + void fixed_data(); + void fixed(); + void strings_data(); + void strings() { fixed(); } + void tags_data(); + void tags() { fixed(); } + void tagTags_data() { tags_data(); } + void tagTags(); + void emptyContainers_data(); + void emptyContainers(); + void arrays_data(); + void arrays(); + void undefLengthArrays_data() { arrays_data(); } + void undefLengthArrays(); + void nestedArrays_data() { arrays_data(); } + void nestedArrays(); + void maps_data(); + void maps(); + void undefLengthMaps_data() { maps_data(); } + void undefLengthMaps(); + void nestedMaps_data() { maps_data(); } + void nestedMaps(); + void mapMixed_data(); + void mapMixed() { arrays(); } + void mapsAndArrays_data() { arrays_data(); } + void mapsAndArrays(); + + void readerApi_data() { arrays_data(); } + void readerApi(); + void reparse_data(); + void reparse(); + + // chunked string API + void chunkedString_data(); + void chunkedString(); + void chunkedStringInUndefArray_data() { chunkedString_data(); } + void chunkedStringInUndefArray(); + + // convenience API + void stringLength_data(); + void stringLength(); + void stringCompare_data(); + void stringCompare(); + void mapFind_data(); + void mapFind(); + + // validation & errors + void checkedIntegers_data(); + void checkedIntegers(); + void validation_data(); + void validation(); + void strictValidation_data(); + void strictValidation(); + void incompleteData_data(); + void incompleteData(); + void endPointer_data(); + void endPointer(); + void recursionLimit_data(); + void recursionLimit(); +}; + +static CborError qstring_printf(void *out, const char *fmt, ...) +{ + auto str = static_cast<QString *>(out); + va_list va; + va_start(va, fmt); + *str += QString::vasprintf(fmt, va); + va_end(va); + return CborNoError; +}; + +CborError parseOne(CborValue *it, QString *parsed) +{ + int flags = CborPrettyShowStringFragments | CborPrettyIndicateIndeterminateLength | + CborPrettyIndicateOverlongNumbers; + + parsed->clear(); + return cbor_value_to_pretty_stream(qstring_printf, parsed, it, flags); +} + +CborError parseOneChunk(CborValue *it, QString *parsed) +{ + CborError err; + CborType ourType = cbor_value_get_type(it); + if (ourType == CborByteStringType) { + const uint8_t *bytes; + size_t len; + err = cbor_value_get_byte_string_chunk(it, &bytes, &len, it); + if (err) + return err; + + if (bytes) + *parsed = QString::fromLatin1("h'" + + QByteArray::fromRawData(reinterpret_cast<const char *>(bytes), len).toHex() + + '\''); + } else if (ourType == CborTextStringType) { + const char *text; + size_t len; + err = cbor_value_get_text_string_chunk(it, &text, &len, it); + if (err) + return err; + + if (text) + *parsed = '"' + QString::fromUtf8(text, len) + '"'; + } else { + Q_ASSERT(false); + } + return err; +} + +void tst_Parser::initParserEmpty() +{ + CborParser parser; + CborValue first; + CborError err = cbor_parser_init((const quint8 *)"", 0, 0, &parser, &first); + QCOMPARE(err, CborErrorUnexpectedEOF); +} + +bool compareFailed = true; +void compareOne_real(const QByteArray &data, const QString &expected, int line, int n = -1) +{ + compareFailed = true; + CborParser parser; + CborValue first; + CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first); + QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\""); + + if (cbor_value_get_type(&first) == CborArrayType) { + size_t len; + if (n >= 0) { + QVERIFY(cbor_value_is_length_known(&first)); + QCOMPARE(cbor_value_get_array_length(&first, &len), CborNoError); + QCOMPARE(len, size_t(len)); + } else { + QVERIFY(!cbor_value_is_length_known(&first)); + QCOMPARE(cbor_value_get_array_length(&first, &len), CborErrorUnknownLength); + } + } else if (cbor_value_get_type(&first) == CborMapType) { + size_t len; + if (n >= 0) { + QVERIFY(cbor_value_is_length_known(&first)); + QCOMPARE(cbor_value_get_map_length(&first, &len), CborNoError); + QCOMPARE(len, size_t(len)); + } else { + QVERIFY(!cbor_value_is_length_known(&first)); + QCOMPARE(cbor_value_get_map_length(&first, &len), CborErrorUnknownLength); + } + } else if (cbor_value_is_text_string(&first) || cbor_value_is_byte_string(&first)) { + size_t len; + QCOMPARE(cbor_value_calculate_string_length(&first, &len), CborNoError); + if (cbor_value_is_length_known(&first)) { + size_t len2; + QCOMPARE(cbor_value_get_string_length(&first, &len2), CborNoError); + QCOMPARE(len2, len); + } else { + QCOMPARE(cbor_value_get_string_length(&first, &len), CborErrorUnknownLength); + } + } + + CborError err2 = cbor_value_validate_basic(&first); + + QString decoded; + err = parseOne(&first, &decoded); + QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + + "\"; decoded stream:\n" + decoded.toLatin1()); + QCOMPARE(decoded, expected); + + // check that the errors are the same + QCOMPARE(err2, err); + + // check that we consumed everything + QCOMPARE((void*)cbor_value_get_next_byte(&first), (void*)data.constEnd()); + + compareFailed = false; +} +#define compareOne(data, expected) compareOne_real(data, expected, __LINE__) +#define compareOneSize(n, data, expected) compareOne_real(data, expected, __LINE__, n) + +#include "data.cpp" + +void tst_Parser::integers_data() +{ + addIntegers(); +} + +void tst_Parser::integers() +{ + QFETCH(QByteArray, data); + QFETCH(bool, isNegative); + QFETCH(quint64, expectedRaw); + QFETCH(qint64, expectedValue); + QFETCH(bool, inInt64Range); + + CborParser parser; + CborValue first; + CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + QVERIFY(cbor_value_is_integer(&first)); + + uint64_t raw; + cbor_value_get_raw_integer(&first, &raw); + QCOMPARE(quint64(raw), expectedRaw); + + if (isNegative) { + QVERIFY(cbor_value_is_negative_integer(&first)); + QVERIFY(!cbor_value_is_unsigned_integer(&first)); + } else { + QVERIFY(!cbor_value_is_negative_integer(&first)); + QVERIFY(cbor_value_is_unsigned_integer(&first)); + } + + int64_t value; + if (inInt64Range) { + cbor_value_get_int64(&first, &value); + QCOMPARE(qint64(value), expectedValue); + } + + err = cbor_value_get_int64_checked(&first, &value); + QCOMPARE(err, inInt64Range ? CborNoError : CborErrorDataTooLarge); + + int ivalue; + bool inIntRange = inInt64Range && (expectedValue == int(expectedValue)); + err = cbor_value_get_int_checked(&first, &ivalue); + QCOMPARE(err, inIntRange ? CborNoError : CborErrorDataTooLarge); +} + +void tst_Parser::fixed_data() +{ + addColumns(); + addFixedData(); +} + +void tst_Parser::fixed() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + + compareOne(data, expected); +} + +void tst_Parser::strings_data() +{ + addColumns(); + addStringsData(); +} + +void tst_Parser::tags_data() +{ + addColumns(); + addTagsData(); +} + +void tst_Parser::tagTags() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + + compareOne("\xd9\xd9\xf7" + data, "55799(" + expected + ')'); + if (!compareFailed) + compareOne("\xd9\xd9\xf7" "\xd9\xd9\xf7" + data, "55799(55799(" + expected + "))"); +} + +void tst_Parser::emptyContainers_data() +{ + addColumns(); + addEmptyContainersData(); +} + +void tst_Parser::emptyContainers() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + QFETCH(int, n); + + compareOneSize(n, data, expected); +} + +void tst_Parser::arrays_data() +{ + addColumns(); + addFixedData(); + addStringsData(); + addTagsData(); +} + +void tst_Parser::arrays() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + + compareOneSize(1, "\x81" + data, '[' + expected + ']'); + if (compareFailed) return; + + compareOneSize(2, "\x82" + data + data, '[' + expected + ", " + expected + ']'); + if (compareFailed) return; + + // overlong length + compareOneSize(1, "\x98\1" + data, "[_0 " + expected + ']'); + if (compareFailed) return; + compareOneSize(1, raw("\x99\0\1") + data, "[_1 " + expected + ']'); + if (compareFailed) return; + compareOneSize(1, raw("\x9a\0\0\0\1") + data, "[_2 " + expected + ']'); + if (compareFailed) return; + compareOneSize(1, raw("\x9b\0\0\0\0\0\0\0\1") + data, "[_3 " + expected + ']'); + if (compareFailed) return; + + // medium-sized array: 32 elements (1 << 5) + expected += ", "; + for (int i = 0; i < 5; ++i) { + data += data; + expected += expected; + } + expected.chop(2); // remove the last ", " + compareOneSize(32, "\x98\x20" + data, '[' + expected + ']'); + if (compareFailed) return; + + // large array: 256 elements (32 << 3) + expected += ", "; + for (int i = 0; i < 3; ++i) { + data += data; + expected += expected; + } + expected.chop(2); // remove the last ", " + compareOneSize(256, raw("\x99\1\0") + data, '[' + expected + ']'); + if (compareFailed) return; +} + +void tst_Parser::undefLengthArrays() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + + compareOne("\x9f" + data + "\xff", "[_ " + expected + ']'); + if (compareFailed) return; + + compareOne("\x9f" + data + data + "\xff", "[_ " + expected + ", " + expected + ']'); +} + +void tst_Parser::nestedArrays() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + + compareOneSize(1, "\x81\x81" + data, "[[" + expected + "]]"); + if (compareFailed) return; + + compareOneSize(1, "\x81\x81\x81" + data, "[[[" + expected + "]]]"); + if (compareFailed) return; + + compareOneSize(1, "\x81\x82" + data + data, "[[" + expected + ", " + expected + "]]"); + if (compareFailed) return; + + compareOneSize(2, "\x82\x81" + data + data, "[[" + expected + "], " + expected + "]"); + if (compareFailed) return; + + compareOneSize(2, "\x82\x81" + data + '\x81' + data, "[[" + expected + "], [" + expected + "]]"); + if (compareFailed) return; + + // undefined length + compareOneSize(-1, "\x9f\x9f" + data + data + "\xff\xff", "[_ [_ " + expected + ", " + expected + "]]"); + if (compareFailed) return; + + compareOneSize(-1, "\x9f\x9f" + data + "\xff\x9f" + data + "\xff\xff", "[_ [_ " + expected + "], [_ " + expected + "]]"); + if (compareFailed) return; + + compareOneSize(-1, "\x9f\x9f" + data + data + "\xff\x9f" + data + "\xff\xff", + "[_ [_ " + expected + ", " + expected + "], [_ " + expected + "]]"); + if (compareFailed) return; + + // mix them + compareOneSize(1, "\x81\x9f" + data + "\xff", "[[_ " + expected + "]]"); + if (compareFailed) return; + + compareOneSize(-1, "\x9f\x81" + data + "\xff", "[_ [" + expected + "]]"); +} + +void tst_Parser::maps_data() +{ + arrays_data(); +} + +void tst_Parser::maps() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + + // integer key + compareOneSize(1, "\xa1\1" + data, "{1: " + expected + '}'); + if (compareFailed) return; + + // string key + compareOneSize(1, "\xa1\x65" "Hello" + data, "{\"Hello\": " + expected + '}'); + if (compareFailed) return; + + // map to self + compareOneSize(1, "\xa1" + data + data, '{' + expected + ": " + expected + '}'); + if (compareFailed) return; + + // two integer keys + compareOneSize(2, "\xa2\1" + data + "\2" + data, "{1: " + expected + ", 2: " + expected + '}'); + if (compareFailed) return; + + // OneSize integer and OneSize string key + compareOneSize(2, "\xa2\1" + data + "\x65" "Hello" + data, "{1: " + expected + ", \"Hello\": " + expected + '}'); + if (compareFailed) return; +} + +void tst_Parser::undefLengthMaps() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + + // integer key + compareOne("\xbf\1" + data + '\xff', "{_ 1: " + expected + '}'); + if (compareFailed) return; + + compareOne("\xbf\1" + data + '\2' + data + '\xff', "{_ 1: " + expected + ", 2: " + expected + '}'); + if (compareFailed) return; + + compareOne("\xbf\1" + data + "\x65Hello" + data + '\xff', "{_ 1: " + expected + ", \"Hello\": " + expected + '}'); + if (compareFailed) return; + + compareOne("\xbf\x65Hello" + data + '\1' + data + '\xff', "{_ \"Hello\": " + expected + ", 1: " + expected + '}'); +} + +void tst_Parser::nestedMaps() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + + // nested maps as values + compareOneSize(1, "\xa1\1\xa1\2" + data, "{1: {2: " + expected + "}}"); + if (compareFailed) return; + + compareOneSize(1, "\xa1\x65Hello\xa1\2" + data, "{\"Hello\": {2: " + expected + "}}"); + if (compareFailed) return; + + compareOneSize(1, "\xa1\1\xa2\2" + data + '\x20' + data, "{1: {2: " + expected + ", -1: " + expected + "}}"); + if (compareFailed) return; + + compareOneSize(2, "\xa2\1\xa1\2" + data + "\2\xa1\x20" + data, "{1: {2: " + expected + "}, 2: {-1: " + expected + "}}"); + if (compareFailed) return; + + // nested maps as keys + compareOneSize(1, "\xa1\xa1\xf4" + data + "\xf5", "{{false: " + expected + "}: true}"); + if (compareFailed) return; + + compareOneSize(1, "\xa1\xa1" + data + data + "\xa1" + data + data, + "{{" + expected + ": " + expected + "}: {" + expected + ": " + expected + "}}"); + if (compareFailed) return; + + // undefined length + compareOneSize(-1, "\xbf\1\xbf\2" + data + "\xff\xff", "{_ 1: {_ 2: " + expected + "}}"); + if (compareFailed) return; + + compareOneSize(-1, "\xbf\1\xbf\2" + data + '\x20' + data + "\xff\xff", "{_ 1: {_ 2: " + expected + ", -1: " + expected + "}}"); + if (compareFailed) return; + + compareOneSize(-1, "\xbf\1\xbf\2" + data + "\xff\2\xbf\x20" + data + "\xff\xff", + "{_ 1: {_ 2: " + expected + "}, 2: {_ -1: " + expected + "}}"); + if (compareFailed) return; + + compareOneSize(-1, "\xbf\xbf" + data + data + "\xff\xbf" + data + data + "\xff\xff", + "{_ {_ " + expected + ": " + expected + "}: {_ " + expected + ": " + expected + "}}"); + if (compareFailed) return; + + // mix them + compareOneSize(1, "\xa1\1\xbf\2" + data + "\xff", "{1: {_ 2: " + expected + "}}"); + if (compareFailed) return; + + compareOneSize(-1, "\xbf\1\xa1\2" + data + "\xff", "{_ 1: {2: " + expected + "}}"); + if (compareFailed) return; +} + +void tst_Parser::mapMixed_data() +{ + addColumns(); + addMapMixedData(); +} + +void tst_Parser::mapsAndArrays() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + + // arrays of maps + compareOneSize(1, "\x81\xa1\1" + data, "[{1: " + expected + "}]"); + if (compareFailed) return; + + compareOneSize(2, "\x82\xa1\1" + data + "\xa1\2" + data, "[{1: " + expected + "}, {2: " + expected + "}]"); + if (compareFailed) return; + + compareOneSize(1, "\x81\xa2\1" + data + "\2" + data, "[{1: " + expected + ", 2: " + expected + "}]"); + if (compareFailed) return; + + compareOneSize(-1, "\x9f\xa1\1" + data + "\xff", "[_ {1: " + expected + "}]"); + if (compareFailed) return; + + compareOneSize(1, "\x81\xbf\1" + data + "\xff", "[{_ 1: " + expected + "}]"); + if (compareFailed) return; + + compareOneSize(-1, "\x9f\xbf\1" + data + "\xff\xff", "[_ {_ 1: " + expected + "}]"); + if (compareFailed) return; + + // maps of arrays + compareOneSize(1, "\xa1\1\x81" + data, "{1: [" + expected + "]}"); + if (compareFailed) return; + + compareOneSize(1, "\xa1\1\x82" + data + data, "{1: [" + expected + ", " + expected + "]}"); + if (compareFailed) return; + + compareOneSize(2, "\xa2\1\x81" + data + "\x65Hello\x81" + data, "{1: [" + expected + "], \"Hello\": [" + expected + "]}"); + if (compareFailed) return; + + compareOneSize(1, "\xa1\1\x9f" + data + "\xff", "{1: [_ " + expected + "]}"); + if (compareFailed) return; + + compareOneSize(1, "\xa1\1\x9f" + data + data + "\xff", "{1: [_ " + expected + ", " + expected + "]}"); + if (compareFailed) return; + + compareOneSize(-1, "\xbf\1\x81" + data + "\xff", "{_ 1: [" + expected + "]}"); + if (compareFailed) return; + + compareOneSize(-1, "\xbf\1\x9f" + data + "\xff\xff", "{_ 1: [_ " + expected + "]}"); + if (compareFailed) return; + + compareOneSize(-1, "\xbf\1\x9f" + data + data + "\xff\xff", "{_ 1: [_ " + expected + ", " + expected + "]}"); + if (compareFailed) return; + + // mixed with indeterminate length strings + compareOneSize(-1, "\xbf\1\x9f" + data + "\xff\x65Hello\xbf" + data + "\x7f\xff\xff\xff", + "{_ 1: [_ " + expected + "], \"Hello\": {_ " + expected + ": (_ )}}"); +} + +struct Input { + QByteArray data; + int consumed; +}; + +static const CborParserOperations byteArrayOps = { + /* can_read_bytes = */ [](void *token, size_t len) { + auto input = static_cast<Input *>(token); + return input->data.size() - input->consumed >= int(len); + }, + /* read_bytes = */ [](void *token, void *dst, size_t offset, size_t len) { + auto input = static_cast<Input *>(token); + return memcpy(dst, input->data.constData() + input->consumed + offset, len); + }, + /* advance_bytes = */ [](void *token, size_t len) { + auto input = static_cast<Input *>(token); + input->consumed += int(len); + }, + /* transfer_string = */ [](void *token, const void **userptr, size_t offset, size_t len) { + // ### + auto input = static_cast<Input *>(token); + if (input->data.size() - input->consumed < int(len + offset)) + return CborErrorUnexpectedEOF; + input->consumed += int(offset); + *userptr = input->data.constData() + input->consumed; + input->consumed += int(len); + return CborNoError; + } +}; + +void tst_Parser::readerApi() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + + Input input = { data, 0 }; + + CborParser parser; + CborValue first; + CborError err = cbor_parser_init_reader(&byteArrayOps, &parser, &first, &input); + QCOMPARE(err, CborNoError); + + QString decoded; + err = parseOne(&first, &decoded); + QCOMPARE(err, CborNoError); + QCOMPARE(decoded, expected); + + // check we consumed everything + QCOMPARE(input.consumed, data.size()); +} + +void tst_Parser::reparse_data() +{ + // only one-item rows + addColumns(); + addFixedData(); +} + +void tst_Parser::reparse() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + + Input input = { QByteArray(), 0 }; + CborParser parser; + CborValue first; + CborError err = cbor_parser_init_reader(&byteArrayOps, &parser, &first, &input); + QCOMPARE(err, CborErrorUnexpectedEOF); + + for (int i = 0; i < data.size(); ++i) { + input.data = data.left(i); + err = cbor_value_reparse(&first); + if (err != CborErrorUnexpectedEOF) + qDebug() << "At" << i; + QCOMPARE(err, CborErrorUnexpectedEOF); + QCOMPARE(input.consumed, 0); + } + + // now it should work + input.data = data; + err = cbor_value_reparse(&first); + QCOMPARE(err, CborNoError); + + QString decoded; + err = parseOne(&first, &decoded); + QCOMPARE(err, CborNoError); + QCOMPARE(decoded, expected); + + // check we consumed everything + QCOMPARE(input.consumed, data.size()); +} + +void tst_Parser::chunkedString_data() +{ + addChunkedStringData(); +} + +static void chunkedStringTest(const QByteArray &data, const QString &concatenated, + QStringList &chunks, CborType ourType) +{ + CborParser parser; + CborValue first; + CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + + CborValue value; + QVERIFY(cbor_value_is_array(&first)); + err = cbor_value_enter_container(&first, &value); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + QVERIFY(cbor_value_is_byte_string(&value) || cbor_value_is_text_string(&value)); + + CborValue copy = value; + + err = cbor_value_begin_string_iteration(&value); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + forever { + QString decoded; + err = parseOneChunk(&value, &decoded); + if (err == CborErrorNoMoreStringChunks) + break; // last chunk + + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + + QVERIFY2(!chunks.isEmpty(), "Too many chunks"); + QString expected = chunks.takeFirst(); + QCOMPARE(decoded, expected); + } + + err = cbor_value_finish_string_iteration(&value); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + QVERIFY2(chunks.isEmpty(), "Too few chunks"); + + // compare to the concatenated data + { + size_t n; + err = cbor_value_calculate_string_length(©, &n); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + + QByteArray buffer(n, Qt::Uninitialized); + QString formatted; + if (cbor_value_is_byte_string(©)) { + err = cbor_value_copy_byte_string(©, (uint8_t *)buffer.data(), &n, nullptr); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + QCOMPARE(int(n), buffer.size()); + + formatted = QString::fromLatin1("h'" + buffer.toHex() + '\''); + } else { + err = cbor_value_copy_text_string(©, buffer.data(), &n, nullptr); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + QCOMPARE(int(n), buffer.size()); + + formatted = '"' + QString::fromUtf8(buffer.data(), n) + '"'; + } + QCOMPARE(formatted, concatenated); + } + + // confirm that the extra string we appended is still here + QVERIFY(!cbor_value_at_end(&value)); + QCOMPARE(cbor_value_get_type(&value), ourType); + size_t len; + err = cbor_value_get_string_length(&value, &len); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + QCOMPARE(len, size_t(0)); + + err = cbor_value_advance(&value); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + + // confirm EOF + QVERIFY(cbor_value_at_end(&value)); + + err = cbor_value_leave_container(&first, &value); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + QCOMPARE((void*)cbor_value_get_next_byte(&first), (void*)data.constEnd()); +} + +void tst_Parser::chunkedString() +{ + QFETCH(QByteArray, data); + QFETCH(QString, concatenated); + QFETCH(QStringList, chunks); + + // Make this an array of two entries, with the second an empty byte or text string + CborType ourType = CborType(data.at(0) & 0xe0); + data.prepend(char(0x82)); + data.append(ourType); + + chunkedStringTest(data, concatenated, chunks, ourType); +} + +void tst_Parser::chunkedStringInUndefArray() +{ + QFETCH(QByteArray, data); + QFETCH(QString, concatenated); + QFETCH(QStringList, chunks); + + // Make this an array of undefined length entries, with the second entry an empty byte or text string + CborType ourType = CborType(data.at(0) & 0xe0); + data.prepend(char(0x9f)); + data.append(ourType); + data.append(char(0xff)); + + chunkedStringTest(data, concatenated, chunks, ourType); +} + +void tst_Parser::stringLength_data() +{ + QTest::addColumn<QByteArray>("data"); + QTest::addColumn<int>("expected"); + + QTest::newRow("emptybytestring") << raw("\x40") << 0; + QTest::newRow("bytestring1") << raw("\x41 ") << 1; + QTest::newRow("bytestring1-nul") << raw("\x41\0") << 1; + QTest::newRow("bytestring5") << raw("\x45Hello") << 5; + QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234") << 24; + QTest::newRow("bytestring256") << raw("\x59\1\0") + QByteArray(256, '3') << 256; + + // text strings + QTest::newRow("emptytextstring") << raw("\x60") << 0; + QTest::newRow("textstring1") << raw("\x61 ") << 1; + QTest::newRow("textstring1-nul") << raw("\x61\0") << 1; + QTest::newRow("textstring5") << raw("\x65Hello") << 5; + QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234") << 24; + QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3') << 256; + + // strings with overlong length + QTest::newRow("emptybytestring*1") << raw("\x58\x00") << 0; + QTest::newRow("emptytextstring*1") << raw("\x78\x00") << 0; + QTest::newRow("emptybytestring*2") << raw("\x59\x00\x00") << 0; + QTest::newRow("emptytextstring*2") << raw("\x79\x00\x00") << 0; + QTest::newRow("emptybytestring*4") << raw("\x5a\0\0\0\0") << 0; + QTest::newRow("emptytextstring*4") << raw("\x7a\0\0\0\0") << 0; + QTest::newRow("emptybytestring*8") << raw("\x5b\0\0\0\0\0\0\0\0") << 0; + QTest::newRow("emptytextstring*8") << raw("\x7b\0\0\0\0\0\0\0\0") << 0; + QTest::newRow("bytestring5*1") << raw("\x58\x05Hello") << 5; + QTest::newRow("textstring5*1") << raw("\x78\x05Hello") << 5; + QTest::newRow("bytestring5*2") << raw("\x59\0\5Hello") << 5; + QTest::newRow("textstring5*2") << raw("\x79\0\x05Hello") << 5; + QTest::newRow("bytestring5*4") << raw("\x5a\0\0\0\5Hello") << 5; + QTest::newRow("textstring5*4") << raw("\x7a\0\0\0\x05Hello") << 5; + QTest::newRow("bytestring5*8") << raw("\x5b\0\0\0\0\0\0\0\5Hello") << 5; + QTest::newRow("textstring5*8") << raw("\x7b\0\0\0\0\0\0\0\x05Hello") << 5; + + // strings with undefined length + QTest::newRow("_emptybytestring") << raw("\x5f\xff") << 0; + QTest::newRow("_emptytextstring") << raw("\x7f\xff") << 0; + QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << 0; + QTest::newRow("_emptytextstring2") << raw("\x7f\x60\xff") << 0; + QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << 0; + QTest::newRow("_emptytextstring3") << raw("\x7f\x60\x60\xff") << 0; + QTest::newRow("_bytestring5*2") << raw("\x5f\x43Hel\x42lo\xff") << 5; + QTest::newRow("_textstring5*2") << raw("\x7f\x63Hel\x62lo\xff") << 5; + QTest::newRow("_bytestring5*5") << raw("\x5f\x41H\x41""e\x41l\x41l\x41o\xff") << 5; + QTest::newRow("_textstring5*5") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << 5; + QTest::newRow("_bytestring5*6") << raw("\x5f\x41H\x41""e\x40\x41l\x41l\x41o\xff") << 5; + QTest::newRow("_textstring5*6") << raw("\x7f\x61H\x61""e\x61l\x60\x61l\x61o\xff") << 5; +} + +void tst_Parser::stringLength() +{ + QFETCH(QByteArray, data); + QFETCH(int, expected); + + CborParser parser; + CborValue value; + CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + + size_t result; + err = cbor_value_calculate_string_length(&value, &result); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + QCOMPARE(result, size_t(expected)); + + if (cbor_value_is_length_known(&value)) { + QCOMPARE(cbor_value_get_string_length(&value, &result), CborNoError); + QCOMPARE(result, size_t(expected)); + } + +} + +void tst_Parser::stringCompare_data() +{ + QTest::addColumn<QByteArray>("data"); + QTest::addColumn<QString>("string"); + QTest::addColumn<bool>("expected"); + + // compare empty to empty + QTest::newRow("empty-empty") << raw("\x60") << QString() << true; + QTest::newRow("_empty-empty") << raw("\x7f\xff") << QString() << true; + QTest::newRow("_empty*1-empty") << raw("\x7f\x60\xff") << QString() << true; + QTest::newRow("_empty*2-empty") << raw("\x7f\x60\x60\xff") << QString() << true; + + // compare empty to non-empty + QTest::newRow("empty-nonempty") << raw("\x60") << "Hello" << false; + QTest::newRow("_empty-nonempty") << raw("\x7f\xff") << "Hello" << false; + QTest::newRow("_empty*1-nonempty") << raw("\x7f\x60\xff") << "Hello" << false; + QTest::newRow("_empty*2-nonempty") << raw("\x7f\x60\x60\xff") << "Hello" << false; + + // compare same strings + QTest::newRow("same-short-short") << raw("\x65Hello") << "Hello" << true; + QTest::newRow("same-_short*1-short") << raw("\x7f\x65Hello\xff") << "Hello" << true; + QTest::newRow("same-_short*2-short") << raw("\x7f\x63Hel\x62lo\xff") << "Hello" << true; + QTest::newRow("same-_short*5-short") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "Hello" << true; + QTest::newRow("same-_short*8-short") << raw("\x7f\x61H\x60\x61""e\x60\x61l\x61l\x60\x61o\xff") << "Hello" << true; + QTest::newRow("same-long-long") << raw("\x78\x2aGood morning, good afternoon and goodnight") + << "Good morning, good afternoon and goodnight" << true; + QTest::newRow("same-_long*1-long") << raw("\x7f\x78\x2aGood morning, good afternoon and goodnight\xff") + << "Good morning, good afternoon and goodnight" << true; + QTest::newRow("same-_long*2-long") << raw("\x7f\x78\x1cGood morning, good afternoon\x6e and goodnight\xff") + << "Good morning, good afternoon and goodnight" << true; + + // compare different strings (same length) + QTest::newRow("diff-same-length-short-short") << raw("\x65Hello") << "World" << false; + QTest::newRow("diff-same-length-_short*1-short") << raw("\x7f\x65Hello\xff") << "World" << false; + QTest::newRow("diff-same-length-_short*2-short") << raw("\x7f\x63Hel\x62lo\xff") << "World" << false; + QTest::newRow("diff-same-length-_short*5-short") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "World" << false; + QTest::newRow("diff-same-length-_short*8-short") << raw("\x7f\x61H\x60\x61""e\x60\x61l\x61l\x60\x61o\xff") << "World" << false; + QTest::newRow("diff-same-length-long-long") << raw("\x78\x2aGood morning, good afternoon and goodnight") + << "Good morning, good afternoon and goodnight, world" << false; + QTest::newRow("diff-same-length-_long*1-long") << raw("\x7f\x78\x2aGood morning, good afternoon and goodnight\xff") + << "Good morning, good afternoon and goodnight, world" << false; + QTest::newRow("diff-same-length-_long*2-long") << raw("\x7f\x78\x1cGood morning, good afternoon\x6e and goodnight\xff") + << "Good morning, good afternoon and goodnight, world" << false; + + // compare different strings (different length) + QTest::newRow("diff-diff-length-short-short") << raw("\x65Hello") << "Hello World" << false; + QTest::newRow("diff-diff-length-_short*1-short") << raw("\x7f\x65Hello\xff") << "Hello World" << false; + QTest::newRow("diff-diff-length-_short*2-short") << raw("\x7f\x63Hel\x62lo\xff") << "Hello World" << false; + QTest::newRow("diff-diff-length-_short*5-short") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "Hello World" << false; + QTest::newRow("diff-diff-length-_short*8-short") << raw("\x7f\x61H\x60\x61""e\x60\x61l\x61l\x60\x61o\xff") << "Hello World" << false; + QTest::newRow("diff-diff-length-long-long") << raw("\x78\x2aGood morning, good afternoon and goodnight") + << "Good morning, good afternoon and goodnight World" << false; + QTest::newRow("diff-diff-length-_long*1-long") << raw("\x7f\x78\x2aGood morning, good afternoon and goodnight\xff") + << "Good morning, good afternoon and goodnight World" << false; + QTest::newRow("diff-diff-length-_long*2-long") << raw("\x7f\x78\x1cGood morning, good afternoon\x6e and goodnight\xff") + << "Good morning, good afternoon and goodnight World" << false; + + // compare against non-strings + QTest::newRow("unsigned") << raw("\0") << "0" << false; + QTest::newRow("negative") << raw("\x20") << "-1" << false; + QTest::newRow("emptybytestring") << raw("\x40") << "" << false; + QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "" << false; + QTest::newRow("shortbytestring") << raw("\x45Hello") << "Hello" << false; + QTest::newRow("longbytestring") << raw("\x58\x2aGood morning, good afternoon and goodnight") + << "Good morning, good afternoon and goodnight" << false; + QTest::newRow("emptyarray") << raw("\x80") << "" << false; + QTest::newRow("emptymap") << raw("\xa0") << "" << false; + QTest::newRow("array") << raw("\x81\x65Hello") << "Hello" << false; + QTest::newRow("map") << raw("\xa1\x65Hello\x65World") << "Hello World" << false; + QTest::newRow("false") << raw("\xf4") << "false" << false; + QTest::newRow("true") << raw("\xf5") << "true" << false; + QTest::newRow("null") << raw("\xf6") << "null" << false; +} + +void compareOneString(const QByteArray &data, const QString &string, bool expected, int line) +{ + compareFailed = true; + + CborParser parser; + CborValue value; + CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value); + QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\""); + + bool result; + QByteArray bastring = string.toUtf8(); + err = cbor_value_text_string_equals(&value, bastring.constData(), &result); + QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\""); + QCOMPARE(result, expected); + + if (expected) { + size_t len; + cbor_value_skip_tag(&value); + if (cbor_value_is_length_known(&value)) { + QCOMPARE(cbor_value_get_string_length(&value, &len), CborNoError); + QCOMPARE(int(len), bastring.size()); + } + QCOMPARE(cbor_value_calculate_string_length(&value, &len), CborNoError); + QCOMPARE(int(len), bastring.size()); + } + + compareFailed = false; +} +#define compareOneString(data, string, expected) compareOneString(data, string, expected, __LINE__) + +void tst_Parser::stringCompare() +{ + QFETCH(QByteArray, data); + QFETCH(QString, string); + QFETCH(bool, expected); + + compareOneString(data, string, expected); + if (compareFailed) return; + + // tag it + compareOneString("\xc1" + data, string, expected); + if (compareFailed) return; + + compareOneString("\xc1\xc2" + data, string, expected); +} + +void tst_Parser::mapFind_data() +{ + // Rules: + // we are searching for string "needle" + // if present, the value should be the string "haystack" (with tag 42) + + QTest::addColumn<QByteArray>("data"); + QTest::addColumn<bool>("expected"); + + QTest::newRow("emptymap") << raw("\xa0") << false; + QTest::newRow("_emptymap") << raw("\xbf\xff") << false; + + // maps not containing our items + QTest::newRow("absent-unsigned-unsigned") << raw("\xa1\0\0") << false; + QTest::newRow("absent-taggedunsigned-unsigned") << raw("\xa1\xc0\0\0") << false; + QTest::newRow("absent-unsigned-taggedunsigned") << raw("\xa1\0\xc0\0") << false; + QTest::newRow("absent-taggedunsigned-taggedunsigned") << raw("\xa1\xc0\0\xc0\0") << false; + QTest::newRow("absent-string-unsigned") << raw("\xa1\x68haystack\0") << false; + QTest::newRow("absent-taggedstring-unsigned") << raw("\xa1\xc0\x68haystack\0") << false; + QTest::newRow("absent-string-taggedunsigned") << raw("\xa1\x68haystack\xc0\0") << false; + QTest::newRow("absent-taggedstring-taggedunsigned") << raw("\xa1\xc0\x68haystack\xc0\0") << false; + QTest::newRow("absent-string-string") << raw("\xa1\x68haystack\x66needle") << false; + QTest::newRow("absent-string-taggedstring") << raw("\xa1\x68haystack\xc0\x66needle") << false; + QTest::newRow("absent-taggedstring-string") << raw("\xa1\xc0\x68haystack\x66needle") << false; + QTest::newRow("absent-string-taggedstring") << raw("\xa1\xc0\x68haystack\xc0\x66needle") << false; + + QTest::newRow("absent-string-emptyarray") << raw("\xa1\x68haystack\x80") << false; + QTest::newRow("absent-string-_emptyarray") << raw("\xa1\x68haystack\x9f\xff") << false; + QTest::newRow("absent-string-array1") << raw("\xa1\x68haystack\x81\0") << false; + QTest::newRow("absent-string-array2") << raw("\xa1\x68haystack\x85\0\1\2\3\4") << false; + QTest::newRow("absent-string-array3") << raw("\xa1\x68haystack\x85\x63one\x63two\x65three\x64""four\x64""five") << false; + + QTest::newRow("absent-string-emptymap") << raw("\xa1\x68haystack\xa0") << false; + QTest::newRow("absent-string-_emptymap") << raw("\xa1\x68haystack\xbf\xff") << false; + QTest::newRow("absent-string-map") << raw("\xa1\x68haystack\xa1\x68haystack\x66needle") << false; + QTest::newRow("absent-string-map2") << raw("\xa1\x68haystack\xa1\x68haystack\x66needle\61z\62yx") << false; + + // maps containing our items + QTest::newRow("alone") << raw("\xa1\x66needle\xd8\x2a\x68haystack") << true; + QTest::newRow("tagged") << raw("\xa1\xc1\x66needle\xd8\x2a\x68haystack") << true; + QTest::newRow("doubletagged") << raw("\xa1\xc1\xc2\x66needle\xd8\x2a\x68haystack") << true; + QTest::newRow("chunked") << raw("\xa1\x7f\x66needle\xff\xd8\x2a\x68haystack") << true; + QTest::newRow("chunked*2") << raw("\xa1\x7f\x60\x66needle\xff\xd8\x2a\x68haystack") << true; + QTest::newRow("chunked*2bis") << raw("\xa1\x7f\x66needle\x60\xff\xd8\x2a\x68haystack") << true; + QTest::newRow("chunked*3") << raw("\xa1\x7f\x62ne\x62""ed\x62le\xff\xd8\x2a\x68haystack") << true; + QTest::newRow("chunked*8") << raw("\xa1\x7f\x61n\x61""e\x60\x61""e\x61""d\x60\x62le\x60\xff\xd8\x2a\x68haystack") << true; + + QTest::newRow("1before") << raw("\xa2\x68haystack\x66needle\x66needle\xd8\x2a\x68haystack") << true; + QTest::newRow("tagged-1before") << raw("\xa2\xc1\x68haystack\x66needle\xc1\x66needle\xd8\x2a\x68haystack") << true; + QTest::newRow("doubletagged-1before2") << raw("\xa2\xc1\xc2\x68haystack\x66needle\xc1\xc2\x66needle\xd8\x2a\x68haystack") << true; + + QTest::newRow("arraybefore") << raw("\xa2\x61z\x80\x66needle\xd8\x2a\x68haystack") << true; + QTest::newRow("nestedarraybefore") << raw("\xa2\x61z\x81\x81\0\x66needle\xd8\x2a\x68haystack") << true; + QTest::newRow("arrayarraybefore") << raw("\xa2\x82\1\2\x80\x66needle\xd8\x2a\x68haystack") << true; + + QTest::newRow("mapbefore") << raw("\xa2\x61z\xa0\x66needle\xd8\x2a\x68haystack") << true; + QTest::newRow("nestedmapbefore") << raw("\xa2\x61z\xa1\0\x81\0\x66needle\xd8\x2a\x68haystack") << true; + QTest::newRow("mapmapbefore") << raw("\xa2\xa1\1\2\xa0\x66needle\xd8\x2a\x68haystack") << true; +} + +void tst_Parser::mapFind() +{ + QFETCH(QByteArray, data); + QFETCH(bool, expected); + + CborParser parser; + CborValue value; + CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + + CborValue element; + err = cbor_value_map_find_value(&value, "needle", &element); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + + if (expected) { + QCOMPARE(int(element.type), int(CborTagType)); + + CborTag tag; + err = cbor_value_get_tag(&element, &tag); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + QCOMPARE(int(tag), 42); + + bool equals; + err = cbor_value_text_string_equals(&element, "haystack", &equals); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + QVERIFY(equals); + } else { + QCOMPARE(int(element.type), int(CborInvalidType)); + } +} + +void tst_Parser::checkedIntegers_data() +{ + QTest::addColumn<QByteArray>("data"); + QTest::addColumn<QVariant>("result"); // QVariant so we can note numbers out of int64_t range + + QTest::newRow("0") << raw("\x00") << QVariant(Q_INT64_C(0)); + QTest::newRow("1") << raw("\x01") << QVariant(Q_INT64_C(1)); + QTest::newRow("10") << raw("\x0a") << QVariant(Q_INT64_C(10)); + QTest::newRow("23") << raw("\x17") << QVariant(Q_INT64_C(23)); + QTest::newRow("24") << raw("\x18\x18") << QVariant(Q_INT64_C(24)); + QTest::newRow("UINT8_MAX") << raw("\x18\xff") << QVariant(Q_INT64_C(255)); + QTest::newRow("UINT8_MAX+1") << raw("\x19\x01\x00") << QVariant(Q_INT64_C(256)); + QTest::newRow("UINT16_MAX") << raw("\x19\xff\xff") << QVariant(Q_INT64_C(65535)); + QTest::newRow("UINT16_MAX+1") << raw("\x1a\0\1\x00\x00") << QVariant(Q_INT64_C(65536)); + QTest::newRow("INT32_MAX") << raw("\x1a\x7f\xff\xff\xff") << QVariant(Q_INT64_C(2147483647)); + QTest::newRow("INT32_MAX+1") << raw("\x1a\x80\x00\x00\x00") << QVariant(Q_INT64_C(2147483648)); + QTest::newRow("UINT32_MAX") << raw("\x1a\xff\xff\xff\xff") << QVariant(Q_INT64_C(4294967295)); + QTest::newRow("UINT32_MAX+1") << raw("\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(4294967296)); + QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff") + << QVariant(); // out of range + + // negative integers + QTest::newRow("-1") << raw("\x20") << QVariant(Q_INT64_C(-1)); + QTest::newRow("-2") << raw("\x21") << QVariant(Q_INT64_C(-2)); + QTest::newRow("-24") << raw("\x37") << QVariant(Q_INT64_C(-24)); + QTest::newRow("-25") << raw("\x38\x18") << QVariant(Q_INT64_C(-25)); + QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << QVariant(Q_INT64_C(-256)); + QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << QVariant(Q_INT64_C(-257)); + QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << QVariant(Q_INT64_C(-65536)); + QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << QVariant(Q_INT64_C(-65537)); + QTest::newRow("INT32_MIN") << raw("\x3a\x7f\xff\xff\xff") << QVariant(Q_INT64_C(-2147483648)); + QTest::newRow("INT32_MIN-1") << raw("\x3a\x80\x00\x00\x00") << QVariant(Q_INT64_C(-2147483649)); + QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << QVariant(Q_INT64_C(-4294967296)); + QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(-4294967297)); + QTest::newRow("INT64_MIN+1") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xfe") + << QVariant(std::numeric_limits<qint64>::min() + 1); + QTest::newRow("INT64_MIN") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xff") + << QVariant(std::numeric_limits<qint64>::min()); + QTest::newRow("INT64_MIN-1") << raw("\x3b\x80\0\0\0""\0\0\0\0") << QVariant(); // out of range + QTest::newRow("-UINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe") + << QVariant(); // out of range + QTest::newRow("-UINT64_MAX+1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff") + << QVariant(); // out of range +} + +void tst_Parser::checkedIntegers() +{ + QFETCH(QByteArray, data); + QFETCH(QVariant, result); + int64_t expected = result.toLongLong(); + + CborParser parser; + CborValue value; + CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + + int64_t v; + err = cbor_value_get_int64_checked(&value, &v); + if (result.isNull()) { + QCOMPARE(err, CborErrorDataTooLarge); + } else { + QCOMPARE(v, expected); + } + + int v2; + err = cbor_value_get_int_checked(&value, &v2); + if (result.isNull() || expected < std::numeric_limits<int>::min() || expected > std::numeric_limits<int>::max()) { + QCOMPARE(err, CborErrorDataTooLarge); + } else { + QCOMPARE(int64_t(v2), expected); + } +} + +void tst_Parser::validation_data() +{ + addValidationColumns(); + addValidationData(); +} + +void tst_Parser::validation() +{ + QFETCH(QByteArray, data); + QFETCH(int, flags); + QFETCH(CborError, expectedError); + + QString decoded; + CborParser parser; + CborValue first; + CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), flags, &parser, &first); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + + CborError err2 = cbor_value_validate_basic(&first); + CborError err3 = cbor_value_validate(&first, CborValidateBasic); + err = parseOne(&first, &decoded); + QCOMPARE(err, expectedError); + if (!QByteArray(QTest::currentDataTag()).contains("utf8")) { + QCOMPARE(err2, expectedError); + QCOMPARE(err3, expectedError); + } +} + +void tst_Parser::strictValidation_data() +{ + addValidationColumns(); + + // Canonical validation - fixed types + QTest::newRow("unsigned-0") << raw("\x00") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("unsigned-24") << raw("\x18\x18") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("unsigned-256") << raw("\x19\1\0") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("unsigned-65536") << raw("\x1a\0\1\0\0") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("unsigned-4294967296") << raw("\x1b\0\0\0\1\0\0\0\0") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("overlong-unsigned-0*1") << raw("\x18\x00") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-unsigned-0*2") << raw("\x19\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-unsigned-0*4") << raw("\x1a\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-unsigned-0*8") << raw("\x1b\0\0\0\0\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-unsigned-24*2") << raw("\x19\0\x18") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-unsigned-24*4") << raw("\x1a\0\0\0\x18") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-unsigned-24*8") << raw("\x1b\0\0\0\0\0\0\0\x18") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-unsigned-256*4") << raw("\x1a\0\0\1\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-unsigned-256*8") << raw("\x1b\0\0\0\0\0\0\1\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-unsigned-65536*8") << raw("\x1b\0\0\0\0\0\1\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("negative-1") << raw("\x20") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("negative-25") << raw("\x38\x38") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("negative-257") << raw("\x39\1\0") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("negative-65537") << raw("\x3a\0\1\0\0") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("negative-4294967297") << raw("\x3b\0\0\0\1\0\0\0\0") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("overlong-negative-1*1") << raw("\x38\x00") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-negative-1*2") << raw("\x39\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-negative-1*4") << raw("\x3a\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-negative-1*8") << raw("\x3b\0\0\0\0\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-negative-25*2") << raw("\x39\0\x18") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-negative-25*4") << raw("\x3a\0\0\0\x18") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-negative-25*8") << raw("\x3b\0\0\0\0\0\0\0\x18") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-negative-257*4") << raw("\x3a\0\0\1\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-negative-257*8") << raw("\x3b\0\0\0\0\0\0\1\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-negative-65537*8") << raw("\x3b\0\0\0\0\0\1\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("simple-0") << raw("\xe0") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("false") << raw("\xf4") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("true") << raw("\xf5") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("null") << raw("\xf6") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("undefined") << raw("\xf7") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("simple-32") << raw("\xf8\x20") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("fp-nan") << raw("\xf9\x7e\00") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("fp--inf") << raw("\xf9\xfc\00") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("fp-+inf") << raw("\xf9\x7c\00") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("overlong-fp-nan_f") << raw("\xfa\x7f\xc0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-fp--inf_f") << raw("\xfa\xff\x80\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-fp-+inf_f") << raw("\xfa\x7f\x80\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-fp-nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-fp--inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-fp-+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + + // canonical - lengths + QByteArray data24(24, 0x20); // also decodes as -1 + QByteArray data256(256, 0x40); // also decodes as h'' + QByteArray data65536(65536, 0x60);// also decodes as "" + QTest::newRow("bytearray-0") << raw("\x40") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("bytearray-24") << (raw("\x58\x18") + data24) << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("bytearray-256") << (raw("\x59\1\0") + data256) << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("bytearray-65536") << (raw("\x5a\0\1\0\0") + data65536) << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("_bytearray-0") << raw("\x5f\xff") << int(CborValidateCanonicalFormat) << CborErrorUnknownLength; + QTest::newRow("overlong-bytearray-0*1") << raw("\x58\x00") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-bytearray-0*2") << raw("\x59\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-bytearray-0*4") << raw("\x5a\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-bytearray-0*8") << raw("\x5b\0\0\0\0\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-bytearray-24*2") << (raw("\x59\0\x18") + data24) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-bytearray-24*4") << (raw("\x5a\0\0\0\x18") + data24) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-bytearray-24*8") << (raw("\x5b\0\0\0\0\0\0\0\x18") + data24) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-bytearray-256*4") << (raw("\x5a\0\0\1\0") + data256) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-bytearray-256*8") << (raw("\x5b\0\0\0\0\0\0\1\0") + data256) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-bytearray-65536*8") << (raw("\x5b\0\0\0\0\0\1\0\0") + data65536) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("string-0") << raw("\x60") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("string-24") << (raw("\x78\x18") + data24) << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("string-256") << (raw("\x79\1\0") + data256) << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("string-65536") << (raw("\x7a\0\1\0\0") + data65536) << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("_string-0") << raw("\x7f\xff") << int(CborValidateCanonicalFormat) << CborErrorUnknownLength; + QTest::newRow("overlong-string-0*1") << raw("\x78\x00") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-string-0*2") << raw("\x79\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-string-0*4") << raw("\x7a\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-string-0*8") << raw("\x7b\0\0\0\0\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-string-24*2") << (raw("\x79\0\x18") + data24) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-string-24*4") << (raw("\x7a\0\0\0\x18") + data24) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-string-24*8") << (raw("\x7b\0\0\0\0\0\0\0\x18") + data24) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-string-256*4") << (raw("\x7a\0\0\1\0") + data256) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-string-256*8") << (raw("\x7b\0\0\0\0\0\0\1\0") + data256) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-string-65536*8") << (raw("\x7b\0\0\0\0\0\1\0\0") + data65536) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("array-0") << raw("\x80") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("array-24") << (raw("\x98\x18") + data24) << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("array-256") << (raw("\x99\1\0") + data256) << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("array-65536") << (raw("\x9a\0\1\0\0") + data65536) << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("_array-0") << raw("\x9f\xff") << int(CborValidateCanonicalFormat) << CborErrorUnknownLength; + QTest::newRow("overlong-array-0*1") << raw("\x98\x00") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-array-0*2") << raw("\x99\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-array-0*4") << raw("\x9a\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-array-0*8") << raw("\x9b\0\0\0\0\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-array-24*2") << (raw("\x99\0\x18") + data24) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-array-24*4") << (raw("\x9a\0\0\0\x18") + data24) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-array-24*8") << (raw("\x9b\0\0\0\0\0\0\0\x18") + data24) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-array-256*4") << (raw("\x9a\0\0\1\0") + data256) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-array-256*8") << (raw("\x9b\0\0\0\0\0\0\1\0") + data256) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-array-65536*8") << (raw("\x9b\0\0\0\0\0\1\0\0") + data65536) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + + // we need unique, sorted, string keys for map + // we'll make all key-value pairs a total of 4 bytes + char mapentry[] = { 0x62, 0, 0, 0x20 }; + QByteArray mapdata24(24 * sizeof(mapentry), Qt::Uninitialized); + QByteArray mapdata256(256 * sizeof(mapentry), Qt::Uninitialized); + char *mapdata24ptr = mapdata24.data(); + char *mapdata256ptr = mapdata256.data(); + for (int i = 0; i < 256; ++i) { + mapentry[1] = 'A' + (i >> 4); + mapentry[2] = 'a' + (i & 0xf); + memcpy(mapdata256ptr + i * sizeof(mapentry), mapentry, sizeof(mapentry)); + if (i < 24) + memcpy(mapdata24ptr + i * sizeof(mapentry), mapentry, sizeof(mapentry)); + } + QTest::newRow("map-0") << raw("\xa0") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("map-24") << (raw("\xb8\x18") + mapdata24) << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("map-256") << (raw("\xb9\1\0") + mapdata256) << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("_map-0") << raw("\xbf\xff") << int(CborValidateCanonicalFormat) << CborErrorUnknownLength; + QTest::newRow("overlong-map-0*1") << raw("\xb8\x00") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-map-0*2") << raw("\xb9\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-map-0*4") << raw("\xba\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-map-0*8") << raw("\xbb\0\0\0\0\0\0\0\0") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-map-24*2") << (raw("\xb9\0\x18") + mapdata24) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-map-24*4") << (raw("\xba\0\0\0\x18") + mapdata24) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-map-24*8") << (raw("\xbb\0\0\0\0\0\0\0\x18") + mapdata24) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-map-256*4") << (raw("\xba\0\0\1\0") + mapdata256) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-map-256*8") << (raw("\xbb\0\0\0\0\0\0\1\0") + mapdata256) << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("unsorted-length-map-UU") << raw("\xa2\1\1\0\0") << int(CborValidateCanonicalFormat) << CborErrorMapNotSorted; + QTest::newRow("unsorted-length-map-UUU") << raw("\xa3\1\1\1\1\0\0") << int(CborValidateCanonicalFormat) << CborErrorMapNotSorted; + QTest::newRow("unsorted-length-map-SS") << raw("\xa2\x61z\1\x60\0") << int(CborValidateCanonicalFormat) << CborErrorMapNotSorted; + QTest::newRow("unsorted-length-map-SSS") << raw("\xa3\x61z\1\x61z\2\x60\0") << int(CborValidateCanonicalFormat) << CborErrorMapNotSorted; + QTest::newRow("unsorted-length-map-SB") << raw("\xa2\x61z\1\x40\0") << int(CborValidateCanonicalFormat) << CborErrorMapNotSorted; + QTest::newRow("unsorted-length-map-AS") << raw("\xa2\x83\0\x20\x45Hello\1\x60\0") << int(CborValidateCanonicalFormat) << CborErrorMapNotSorted; + QTest::newRow("unsorted-content-map-SS") << raw("\xa2\x61z\1\x61y\0") << int(CborValidateCanonicalFormat) << CborErrorMapNotSorted; + QTest::newRow("unsorted-content-map-AS") << raw("\xa2\x81\x21\1\x61\x21\0") << int(CborValidateCanonicalFormat) << CborErrorMapNotSorted; + + QTest::newRow("tag-0") << raw("\xc0\x60") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("tag-24") << raw("\xd8\x18\x40") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("tag-65536") << raw("\xda\0\1\0\0\x60") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("tag-4294967296") << raw("\xdb\0\0\0\1\0\0\0\0\x60") << int(CborValidateCanonicalFormat) << CborNoError; + QTest::newRow("overlong-tag-0*1") << raw("\xd8\x00\x60") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-tag-0*2") << raw("\xd9\0\0\x60") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-tag-0*4") << raw("\xda\0\0\0\0\x60") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-tag-0*8") << raw("\xdb\0\0\0\0\0\0\0\0\x60") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-tag-24*2") << raw("\xd9\0\x18\x60") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-tag-24*4") << raw("\xda\0\0\0\x18\x60") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-tag-24*8") << raw("\xdb\0\0\0\0\0\0\0\x18\x60") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-tag-256*4") << raw("\xda\0\0\1\0\x60") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-tag-256*8") << raw("\xdb\0\0\0\0\0\0\1\0\x60") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + QTest::newRow("overlong-tag-65536*8") << raw("\xdb\0\0\0\0\0\1\0\0\x60") << int(CborValidateCanonicalFormat) << CborErrorOverlongEncoding; + + // non-canonical: string length in chunked transfer + QTest::newRow("overlong-_bytearray-0*1") << raw("\x5f\x58\x00\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearray-0*2") << raw("\x5f\x59\0\0\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearray-0*4") << raw("\x5f\x5a\0\0\0\0\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearray-0*8") << raw("\x5f\x5b\0\0\0\0\0\0\0\0\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearray-24*2") << (raw("\x5f\x59\0\x18") + data24 + '\xff') << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearray-24*4") << (raw("\x5f\x5a\0\0\0\x18") + data24 + '\xff') << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearray-24*8") << (raw("\x5f\x5b\0\0\0\0\0\0\0\x18") + data24 + '\xff') << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearray-256*4") << (raw("\x5f\x5a\0\0\1\0") + data256 + '\xff') << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearray-256*8") << (raw("\x5f\x5b\0\0\0\0\0\0\1\0") + data256 + '\xff') << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearray-65536*8") << (raw("\x5f\x5b\0\0\0\0\0\1\0\0") + data65536 + '\xff') << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearrayx2-0*1") << raw("\x5f\x40\x58\x00\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearrayx2-0*2") << raw("\x5f\x40\x59\0\0\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearrayx2-0*4") << raw("\x5f\x40\x5a\0\0\0\0\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_bytearrayx2-0*8") << raw("\x5f\x40\x5b\0\0\0\0\0\0\0\0\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_string-0*1") << raw("\x7f\x78\x00\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_string-0*2") << raw("\x7f\x79\0\0\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_string-0*4") << raw("\x7f\x7a\0\0\0\0\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_string-0*8") << raw("\x7f\x7b\0\0\0\0\0\0\0\0\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_string-24*2") << (raw("\x7f\x79\0\x18") + data24 + '\xff') << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_string-24*4") << (raw("\x7f\x7a\0\0\0\x18") + data24 + '\xff') << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_string-24*8") << (raw("\x7f\x7b\0\0\0\0\0\0\0\x18") + data24 + '\xff') << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_string-256*4") << (raw("\x7f\x7a\0\0\1\0") + data256 + '\xff') << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_string-256*8") << (raw("\x7f\x7b\0\0\0\0\0\0\1\0") + data256 + '\xff') << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_string-65536*8") << (raw("\x7f\x7b\0\0\0\0\0\1\0\0") + data65536 + '\xff') << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_stringx2-0*1") << raw("\x7f\x60\x78\x00\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_stringx2-0*2") << raw("\x7f\x60\x79\0\0\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_stringx2-0*4") << raw("\x7f\x60\x7a\0\0\0\0\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + QTest::newRow("overlong-_stringx2-0*8") << raw("\x7f\x60\x7b\0\0\0\0\0\0\0\0\xff") << int(CborValidateShortestNumbers) << CborErrorOverlongEncoding; + + // strict mode + QTest::newRow("invalid-utf8-1char") << raw("\x61\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-2chars-1") << raw("\x62\xc2\xc0") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-2chars-2") << raw("\x62\xc3\xdf") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-2chars-3") << raw("\x62\xc7\xf0") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-3chars-1") << raw("\x63\xe0\xa0\xc0") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-3chars-2") << raw("\x63\xe0\xc0\xa0") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-4chars-1") << raw("\x64\xf0\x90\x80\xc0") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-4chars-2") << raw("\x64\xf0\x90\xc0\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-4chars-3") << raw("\x64\xf0\xc0\x80\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-hi-surrogate") << raw("\x63\xed\xa0\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-lo-surrogate") << raw("\x63\xed\xb0\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-surrogate-pair") << raw("\x66\xed\xa0\x80\xed\xb0\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-non-unicode-1") << raw("\x64\xf4\x90\x80\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-non-unicode-2") << raw("\x65\xf8\x88\x80\x80\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-non-unicode-3") << raw("\x66\xfc\x84\x80\x80\x80\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-non-unicode-4") << raw("\x66\xfd\xbf\xbf\xbf\xbf\xbf") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-fe") << raw("\x61\xfe") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-ff") << raw("\x61\xff") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-1-2") << raw("\x62\xc1\x81") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-1-3") << raw("\x63\xe0\x81\x81") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-1-4") << raw("\x64\xf0\x80\x81\x81") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-1-5") << raw("\x65\xf8\x80\x80\x81\x81") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-1-6") << raw("\x66\xfc\x80\x80\x80\x81\x81") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-2-3") << raw("\x63\xe0\x82\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-2-4") << raw("\x64\xf0\x80\x82\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-2-5") << raw("\x65\xf8\x80\x80\x82\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-2-6") << raw("\x66\xfc\x80\x80\x80\x82\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-3-4") << raw("\x64\xf0\x80\xa0\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-3-5") << raw("\x65\xf8\x80\x80\xa0\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-3-6") << raw("\x66\xfc\x80\x80\x80\xa0\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-4-5") << raw("\x65\xf8\x80\x84\x80\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + QTest::newRow("invalid-utf8-overlong-4-6") << raw("\x66\xfc\x80\x80\x84\x80\x80") << int(CborValidateStrictMode) << CborErrorInvalidUtf8TextString; + + QTest::newRow("nonunique-content-map-UU") << raw("\xa2\0\1\0\2") << int(CborValidateStrictMode) << CborErrorMapKeysNotUnique; + QTest::newRow("nonunique-content-map-SS") << raw("\xa2\x61z\1\x61z\2") << int(CborValidateStrictMode) << CborErrorMapKeysNotUnique; + QTest::newRow("nonunique-content-map-AA") << raw("\xa2\x81\x65Hello\1\x81\x65Hello\2") << int(CborValidateStrictMode) << CborErrorMapKeysNotUnique; + + QTest::newRow("tag-0-unsigned") << raw("\xc0\x00") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-0-bytearray") << raw("\xc0\x40") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-0-string") << raw("\xc0\x60") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-0-tag-0-string") << raw("\xc0\xc0\x60") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-1-unsigned") << raw("\xc1\x00") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-1-negative") << raw("\xc1\x20") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-1-bytearray") << raw("\xc1\x40") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-2-bytearray") << raw("\xc2\x40") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-2-string") << raw("\xc2\x60") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-3-bytearray") << raw("\xc3\x40") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-3-string") << raw("\xc3\x60") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-4-string") << raw("\xc4\x60") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-4-array") << raw("\xc4\x82\0\1") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-5-string") << raw("\xc5\x60") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-5-array") << raw("\xc5\x82\0\1") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-21-bytearray") << raw("\xd5\x40") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-21-string") << raw("\xd5\x60") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-21-array") << raw("\xd5\x80") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-21-map") << raw("\xd5\xa0") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-22-bytearray") << raw("\xd6\x40") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-22-string") << raw("\xd6\x60") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-22-array") << raw("\xd6\x80") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-22-map") << raw("\xd6\xa0") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-23-bytearray") << raw("\xd7\x40") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-23-string") << raw("\xd7\x60") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-23-array") << raw("\xd7\x80") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-23-map") << raw("\xd7\xa0") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-24-bytearray") << raw("\xd8\x18\x40") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-24-string") << raw("\xd8\x18\x60") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-32-bytearray") << raw("\xd8\x20\x40") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-32-string") << raw("\xd8\x20\x60") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-33-bytearray") << raw("\xd8\x21\x40") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-33-string") << raw("\xd8\x21\x60") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-34-bytearray") << raw("\xd8\x22\x40") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-34-string") << raw("\xd8\x22\x60") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-35-bytearray") << raw("\xd8\x23\x40") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-35-string") << raw("\xd8\x23\x60") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-36-bytearray") << raw("\xd8\x24\x40") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-36-string") << raw("\xd8\x24\x60") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-unsigned") << raw("\xd9\xd9\xf7\x00") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-negative") << raw("\xd9\xd9\xf7\x20") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-bytearray") << raw("\xd9\xd9\xf7\x40") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-string") << raw("\xd9\xd9\xf7\x60") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-array") << raw("\xd9\xd9\xf7\x80") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-map") << raw("\xd9\xd9\xf7\xa0") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-tag-0-unsigned") << raw("\xd9\xd9\xf7\xc0\x00") << int(CborValidateStrictMode) << CborErrorInappropriateTagForType; + QTest::newRow("tag-55799-tag-0-string") << raw("\xd9\xd9\xf7\xc0\x60") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-simple0") << raw("\xd9\xd9\xf7\xe0") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-false") << raw("\xd9\xd9\xf7\xf4") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-true") << raw("\xd9\xd9\xf7\xf5") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-null") << raw("\xd9\xd9\xf7\xf6") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-undefined") << raw("\xd9\xd9\xf7\xf7") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-simple32") << raw("\xd9\xd9\xf7\xf8\x20") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-half") << raw("\xd9\xd9\xf7\xf9\0\0") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-float") << raw("\xd9\xd9\xf7\xfa\0\0\0\0") << int(CborValidateStrictMode) << CborNoError; + QTest::newRow("tag-55799-double") << raw("\xd9\xd9\xf7\xfb\0\0\0\0\0\0\0\0") << int(CborValidateStrictMode) << CborNoError; + + // excluded non-finite + QTest::newRow("excluded-fp-nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp-nan_f") << raw("\xfa\x7f\xc0\0\0") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp--inf_f") << raw("\xfa\xff\x80\0\0") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp--inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp-+inf_f") << raw("\xfa\x7f\x80\0\0") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp-+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + + // excluded undefined + QTest::newRow("no-undefined") << raw("\xf7") << int(CborValidateNoUndefined) << CborErrorExcludedType; + + // exclude non-finite + QTest::newRow("excluded-fp-nan_f16") << raw("\xf9\x7e\00") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp--inf_f16") << raw("\xf9\xfc\00") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp-+inf_f16") << raw("\xf9\x7c\00") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp-nan_f") << raw("\xfa\x7f\xc0\0\0") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp--inf_f") << raw("\xfa\xff\x80\0\0") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp-+inf_f") << raw("\xfa\x7f\x80\0\0") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp-nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp--inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + QTest::newRow("excluded-fp-+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << int(CborValidateFiniteFloatingPoint) << CborErrorExcludedValue; + + // exclude non-string keys in maps + QTest::newRow("excluded-map-unsigned") << raw("\xa1\x00\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + QTest::newRow("excluded-map-negative") << raw("\xa1\x20\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + QTest::newRow("excluded-map-bytearray") << raw("\xa1\x40\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + QTest::newRow("map-string") << raw("\xa1\x60\1") << int(CborValidateMapKeysAreString) << CborNoError; + QTest::newRow("map-tag-0-string") << raw("\xa1\xc0\x60\1") << int(CborValidateMapKeysAreString) << CborNoError; + QTest::newRow("excluded-map-array") << raw("\xa1\x80\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + QTest::newRow("excluded-map-map") << raw("\xa1\xa0\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + QTest::newRow("excluded-map-simple-0") << raw("\xa1\xe0\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + QTest::newRow("excluded-map-false") << raw("\xa1\xf4\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + QTest::newRow("excluded-map-true") << raw("\xa1\xf5\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + QTest::newRow("excluded-map-null") << raw("\xa1\xf6\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + QTest::newRow("excluded-map-undefined") << raw("\xa1\xf7\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + QTest::newRow("excluded-map-half") << raw("\xa1\xf9\0\0\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + QTest::newRow("excluded-map-float") << raw("\xa1\xfa\0\0\0\0\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + QTest::newRow("excluded-map-double") << raw("\xa1\xfb\0\0\0\0\0\0\0\0\1") << int(CborValidateMapKeysAreString) << CborErrorMapKeyNotString; + + // unknown simple types + QTest::newRow("unknown-simple-type-0") << raw("\xe0") << int(CborValidateNoUnknownSimpleTypes) << CborErrorUnknownSimpleType; + QTest::newRow("unknown-simple-type-32") << raw("\xf8\x20") << int(CborValidateNoUnknownSimpleTypes) << CborErrorUnknownSimpleType; + QTest::newRow("allowed-simple-type-32") << raw("\xf8\x20") << int(CborValidateNoUnknownSimpleTypesSA) << CborNoError; + + // unknown tags + QTest::newRow("unknown-tag-6") << raw("\xc6\x60") << int(CborValidateNoUnknownTags) << CborErrorUnknownTag; + QTest::newRow("unknown-tag-31") << raw("\xd8\x1f\x60") << int(CborValidateNoUnknownTags) << CborErrorUnknownTag; + QTest::newRow("unknown-tag-256") << raw("\xd9\1\0\x60") << int(CborValidateNoUnknownTags) << CborErrorUnknownTag; + QTest::newRow("unknown-tag-65536") << raw("\xda\0\1\0\0\x60") << int(CborValidateNoUnknownTags) << CborErrorUnknownTag; + QTest::newRow("unknown-tag-4294967296") << raw("\xdb\0\0\0\1\0\0\0\0\x60") << int(CborValidateNoUnknownTags) << CborErrorUnknownTag; + QTest::newRow("allowed-tag-31") << raw("\xd8\x1f\x60") << int(CborValidateNoUnknownTagsSA) << CborNoError; + QTest::newRow("allowed-tag-256") << raw("\xd9\1\0\x60") << int(CborValidateNoUnknownTagsSR) << CborNoError; + + // excluded tags + QTest::newRow("excluded-tag-0") << raw("\xc0\x60") << int(CborValidateNoTags) << CborErrorExcludedType; + QTest::newRow("excluded-tag-24") << raw("\xd8\x18\x40") << int(CborValidateNoTags) << CborErrorExcludedType; + QTest::newRow("excluded-tag-55799") << raw("\xd9\xd9\xf7\x60") << int(CborValidateNoTags) << CborErrorExcludedType; + + // complete data + QTest::newRow("garbage-data-0") << raw("\0\1") << int(CborValidateCompleteData) << CborErrorGarbageAtEnd; + QTest::newRow("garbage-data-1") << raw("\x20\1") << int(CborValidateCompleteData) << CborErrorGarbageAtEnd; + QTest::newRow("garbage-data-2") << raw("\x40\1") << int(CborValidateCompleteData) << CborErrorGarbageAtEnd; + QTest::newRow("garbage-data-3") << raw("\x60\1") << int(CborValidateCompleteData) << CborErrorGarbageAtEnd; + QTest::newRow("garbage-data-4") << raw("\x80\1") << int(CborValidateCompleteData) << CborErrorGarbageAtEnd; + QTest::newRow("garbage-data-5") << raw("\xa0\1") << int(CborValidateCompleteData) << CborErrorGarbageAtEnd; + QTest::newRow("garbage-data-6") << raw("\xc0\x60\1") << int(CborValidateCompleteData) << CborErrorGarbageAtEnd; + QTest::newRow("garbage-data-7") << raw("\xf4\1") << int(CborValidateCompleteData) << CborErrorGarbageAtEnd; + QTest::newRow("garbage-data-f16") << raw("\xf9\0\0\1") << int(CborValidateCompleteData) << CborErrorGarbageAtEnd; + QTest::newRow("garbage-data-f32") << raw("\xfa\0\0\0\0\1") << int(CborValidateCompleteData) << CborErrorGarbageAtEnd; + QTest::newRow("garbage-data-f64") << raw("\xfb\0\0\0\0\0\0\0\0\1") << int(CborValidateCompleteData) << CborErrorGarbageAtEnd; +} + +void tst_Parser::strictValidation() +{ + QFETCH(QByteArray, data); + QFETCH(int, flags); + QFETCH(CborError, expectedError); + + QString decoded; + CborParser parser; + CborValue first; + CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + + err = cbor_value_validate(&first, flags); + QCOMPARE(err, expectedError); +} + +void tst_Parser::incompleteData_data() +{ + addColumns(); + addFixedData(); + addStringsData(); + addTagsData(); + addMapMixedData(); +} + +void tst_Parser::incompleteData() +{ + QFETCH(QByteArray, data); + QFETCH(QString, expected); + + for (int len = 0; len < data.length() - 1; ++len) { + CborParser parser; + CborValue first; + CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), len, 0, &parser, &first); + if (!err) { + QString decoded; + err = parseOne(&first, &decoded); + } + if (err != CborErrorUnexpectedEOF) + qDebug() << "Length is" << len; + QCOMPARE(err, CborErrorUnexpectedEOF); + } +} + +void tst_Parser::endPointer_data() +{ + QTest::addColumn<QByteArray>("data"); + QTest::addColumn<int>("offset"); + + QTest::newRow("number1") << raw("\x81\x01\x01") << 2; + QTest::newRow("number24") << raw("\x81\x18\x18\x01") << 3; + QTest::newRow("string") << raw("\x81\x61Z\x01") << 3; + QTest::newRow("indefinite-string") << raw("\x81\x7f\x61Z\xff\x01") << 5; + QTest::newRow("array") << raw("\x81\x02\x01") << 2; + QTest::newRow("indefinite-array") << raw("\x81\x9f\x02\xff\x01") << 4; + QTest::newRow("object") << raw("\x81\xa1\x03\x02\x01") << 4; + QTest::newRow("indefinite-object") << raw("\x81\xbf\x03\x02\xff\x01") << 5; +} + +void tst_Parser::endPointer() +{ + QFETCH(QByteArray, data); + QFETCH(int, offset); + + QString decoded; + CborParser parser; + CborValue first; + CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + + err = parseOne(&first, &decoded); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + QCOMPARE(int(cbor_value_get_next_byte(&first) - reinterpret_cast<const quint8 *>(data.constBegin())), offset); +} + +void tst_Parser::recursionLimit_data() +{ + static const int recursions = CBOR_PARSER_MAX_RECURSIONS + 2; + QTest::addColumn<QByteArray>("data"); + + QTest::newRow("array") << QByteArray(recursions, '\x81') + '\x20'; + QTest::newRow("_array") << QByteArray(recursions, '\x9f') + '\x20' + QByteArray(recursions, '\xff'); + + QByteArray data; + for (int i = 0; i < recursions; ++i) + data += "\xa1\x65Hello"; + data += '\2'; + QTest::newRow("map-recursive-values") << data; + + data.clear(); + for (int i = 0; i < recursions; ++i) + data += "\xbf\x65World"; + data += '\2'; + for (int i = 0; i < recursions; ++i) + data += "\xff"; + QTest::newRow("_map-recursive-values") << data; + + data = QByteArray(recursions, '\xa1'); + data += '\2'; + for (int i = 0; i < recursions; ++i) + data += "\x7f\x64quux\xff"; + QTest::newRow("map-recursive-keys") << data; + + data = QByteArray(recursions, '\xbf'); + data += '\2'; + for (int i = 0; i < recursions; ++i) + data += "\1\xff"; + QTest::newRow("_map-recursive-keys") << data; + + data.clear(); + for (int i = 0; i < recursions / 2; ++i) + data += "\x81\xa1\1"; + data += '\2'; + QTest::newRow("mixed") << data; +} + +void tst_Parser::recursionLimit() +{ + QFETCH(QByteArray, data); + + CborParser parser; + CborValue first; + CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + + // check that it is valid: + CborValue it = first; + { + QString dummy; + err = parseOne(&it, &dummy); + QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\""); + } + + it = first; + err = cbor_value_advance(&it); + QCOMPARE(err, CborErrorNestingTooDeep); + + it = first; + if (cbor_value_is_map(&it)) { + CborValue dummy; + err = cbor_value_map_find_value(&it, "foo", &dummy); + QCOMPARE(err, CborErrorNestingTooDeep); + } +} + +QTEST_MAIN(tst_Parser) +#include "tst_parser.moc" diff --git a/src/3rdparty/xcb/README b/src/3rdparty/xcb/README index d7c8eba294..9e8ea30b51 100644 --- a/src/3rdparty/xcb/README +++ b/src/3rdparty/xcb/README @@ -1,15 +1,19 @@ Contains the header and sources files from selected xcb libraries: - libxcb-1.5 together with xcb-proto-1.6 (sync, xfixes, randr, xinerama sources) + libxcb-1.9.1 together with xcb-proto-1.8 (randr, render, shape, shm, sync, + xfixes, xinerama sources) # libxkbcommon-x11 requires libxcb-xkb >= 1.10 libxcb-1.10 together with xcb-proto-1.10 (xkb sources) + libxcb-1.13 together with xcb-proto-1.13 (xinput sources with removed + Pointer Barriers API and SendExtensionEvent API) libxcb-util-image-0.3.9 libxcb-util-keysyms-0.3.9 libxcb-util-renderutil-0.3.8 libxcb-util-wm-0.3.9 The 'include' directory was obtained by compiling and installing all of the modules. -They have been tested to run also with libxcb 1.5 (the oldest version we support). +When upgrading the bundled xcb headers, they must be tested to run also with the +minimal supported libxcb version, which currently is 1.9.1. Use the -qt-xcb configure option to use the files instead of system xcb libraries. See src/plugins/platforms/xcb/README for details. diff --git a/src/3rdparty/xcb/include/xcb/randr.h b/src/3rdparty/xcb/include/xcb/randr.h index 1035c4043c..4f4f2104cf 100644 --- a/src/3rdparty/xcb/include/xcb/randr.h +++ b/src/3rdparty/xcb/include/xcb/randr.h @@ -1379,6 +1379,9 @@ xcb_randr_screen_size_next (xcb_randr_screen_size_iterator_t *i /**< */); xcb_generic_iterator_t xcb_randr_screen_size_end (xcb_randr_screen_size_iterator_t i /**< */); +int +xcb_randr_refresh_rates_sizeof (const void *_buffer /**< */); + /***************************************************************************** ** @@ -1462,7 +1465,7 @@ xcb_generic_iterator_t xcb_randr_refresh_rates_end (xcb_randr_refresh_rates_iterator_t i /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1487,7 +1490,7 @@ xcb_randr_query_version (xcb_connection_t *c /**< */, uint32_t minor_version /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1546,7 +1549,7 @@ xcb_randr_query_version_reply (xcb_connection_t *c /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1579,7 +1582,7 @@ xcb_randr_set_screen_config (xcb_connection_t *c /**< */, uint16_t rate /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1646,7 +1649,7 @@ xcb_randr_set_screen_config_reply (xcb_connection_t *c /** xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1674,7 +1677,7 @@ xcb_randr_select_input_checked (xcb_connection_t *c /**< */, uint16_t enable /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1698,8 +1701,11 @@ xcb_randr_select_input (xcb_connection_t *c /**< */, xcb_window_t window /**< */, uint16_t enable /**< */); +int +xcb_randr_get_screen_info_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1722,7 +1728,7 @@ xcb_randr_get_screen_info (xcb_connection_t *c /**< */, xcb_window_t window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1844,7 +1850,7 @@ xcb_randr_get_screen_info_reply (xcb_connection_t *c /**< */ xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1867,7 +1873,7 @@ xcb_randr_get_screen_size_range (xcb_connection_t *c /**< */, xcb_window_t window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1924,7 +1930,7 @@ xcb_randr_get_screen_size_range_reply (xcb_connection_t xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1958,7 +1964,7 @@ xcb_randr_set_screen_size_checked (xcb_connection_t *c /**< */, uint32_t mm_height /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2031,8 +2037,11 @@ xcb_randr_mode_info_next (xcb_randr_mode_info_iterator_t *i /**< */); xcb_generic_iterator_t xcb_randr_mode_info_end (xcb_randr_mode_info_iterator_t i /**< */); +int +xcb_randr_get_screen_resources_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2055,7 +2064,7 @@ xcb_randr_get_screen_resources (xcb_connection_t *c /**< */, xcb_window_t window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2267,8 +2276,11 @@ xcb_randr_get_screen_resources_reply (xcb_connection_t * xcb_randr_get_screen_resources_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_randr_get_output_info_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2293,7 +2305,7 @@ xcb_randr_get_output_info (xcb_connection_t *c /**< */, xcb_timestamp_t config_timestamp /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2507,8 +2519,11 @@ xcb_randr_get_output_info_reply (xcb_connection_t *c /**< */ xcb_randr_get_output_info_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_randr_list_output_properties_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2531,7 +2546,7 @@ xcb_randr_list_output_properties (xcb_connection_t *c /**< */, xcb_randr_output_t output /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2626,8 +2641,11 @@ xcb_randr_list_output_properties_reply (xcb_connection_t xcb_randr_list_output_properties_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_randr_query_output_property_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2652,7 +2670,7 @@ xcb_randr_query_output_property (xcb_connection_t *c /**< */, xcb_atom_t property /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2749,8 +2767,12 @@ xcb_randr_query_output_property_reply (xcb_connection_t xcb_randr_query_output_property_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_randr_configure_output_property_sizeof (const void *_buffer /**< */, + uint32_t values_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2786,7 +2808,7 @@ xcb_randr_configure_output_property_checked (xcb_connection_t *c /**< */, const int32_t *values /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2818,8 +2840,11 @@ xcb_randr_configure_output_property (xcb_connection_t *c /**< */, uint32_t values_len /**< */, const int32_t *values /**< */); +int +xcb_randr_change_output_property_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2857,7 +2882,7 @@ xcb_randr_change_output_property_checked (xcb_connection_t *c /**< */, const void *data /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2892,7 +2917,7 @@ xcb_randr_change_output_property (xcb_connection_t *c /**< */, const void *data /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2920,7 +2945,7 @@ xcb_randr_delete_output_property_checked (xcb_connection_t *c /**< */, xcb_atom_t property /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2944,8 +2969,11 @@ xcb_randr_delete_output_property (xcb_connection_t *c /**< */, xcb_randr_output_t output /**< */, xcb_atom_t property /**< */); +int +xcb_randr_get_output_property_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2980,7 +3008,7 @@ xcb_randr_get_output_property (xcb_connection_t *c /**< */, uint8_t pending /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3087,8 +3115,12 @@ xcb_randr_get_output_property_reply (xcb_connection_t *c xcb_randr_get_output_property_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_randr_create_mode_sizeof (const void *_buffer /**< */, + uint32_t name_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3117,7 +3149,7 @@ xcb_randr_create_mode (xcb_connection_t *c /**< */, const char *name /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3180,7 +3212,7 @@ xcb_randr_create_mode_reply (xcb_connection_t *c /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3206,7 +3238,7 @@ xcb_randr_destroy_mode_checked (xcb_connection_t *c /**< */, xcb_randr_mode_t mode /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3229,7 +3261,7 @@ xcb_randr_destroy_mode (xcb_connection_t *c /**< */, xcb_randr_mode_t mode /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3257,7 +3289,7 @@ xcb_randr_add_output_mode_checked (xcb_connection_t *c /**< */, xcb_randr_mode_t mode /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3282,7 +3314,7 @@ xcb_randr_add_output_mode (xcb_connection_t *c /**< */, xcb_randr_mode_t mode /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3310,7 +3342,7 @@ xcb_randr_delete_output_mode_checked (xcb_connection_t *c /**< */, xcb_randr_mode_t mode /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3334,8 +3366,11 @@ xcb_randr_delete_output_mode (xcb_connection_t *c /**< */, xcb_randr_output_t output /**< */, xcb_randr_mode_t mode /**< */); +int +xcb_randr_get_crtc_info_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3360,7 +3395,7 @@ xcb_randr_get_crtc_info (xcb_connection_t *c /**< */, xcb_timestamp_t config_timestamp /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3496,8 +3531,12 @@ xcb_randr_get_crtc_info_reply (xcb_connection_t *c /**< */, xcb_randr_get_crtc_info_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_randr_set_crtc_config_sizeof (const void *_buffer /**< */, + uint32_t outputs_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3536,7 +3575,7 @@ xcb_randr_set_crtc_config (xcb_connection_t *c /**< */, const xcb_randr_output_t *outputs /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3609,7 +3648,7 @@ xcb_randr_set_crtc_config_reply (xcb_connection_t *c /**< */ xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3632,7 +3671,7 @@ xcb_randr_get_crtc_gamma_size (xcb_connection_t *c /**< */, xcb_randr_crtc_t crtc /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3688,8 +3727,11 @@ xcb_randr_get_crtc_gamma_size_reply (xcb_connection_t *c xcb_randr_get_crtc_gamma_size_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_randr_get_crtc_gamma_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3712,7 +3754,7 @@ xcb_randr_get_crtc_gamma (xcb_connection_t *c /**< */, xcb_randr_crtc_t crtc /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3885,8 +3927,11 @@ xcb_randr_get_crtc_gamma_reply (xcb_connection_t *c /**< */, xcb_randr_get_crtc_gamma_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_randr_set_crtc_gamma_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3920,7 +3965,7 @@ xcb_randr_set_crtc_gamma_checked (xcb_connection_t *c /**< */, const uint16_t *blue /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3950,8 +3995,11 @@ xcb_randr_set_crtc_gamma (xcb_connection_t *c /**< */, const uint16_t *green /**< */, const uint16_t *blue /**< */); +int +xcb_randr_get_screen_resources_current_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3974,7 +4022,7 @@ xcb_randr_get_screen_resources_current (xcb_connection_t *c /**< */, xcb_window_t window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4186,8 +4234,12 @@ xcb_randr_get_screen_resources_current_reply (xcb_connection_t xcb_randr_get_screen_resources_current_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_randr_set_crtc_transform_sizeof (const void *_buffer /**< */, + uint32_t filter_params_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4223,7 +4275,7 @@ xcb_randr_set_crtc_transform_checked (xcb_connection_t *c /**< */, const xcb_render_fixed_t *filter_params /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4255,8 +4307,11 @@ xcb_randr_set_crtc_transform (xcb_connection_t *c /**< */, uint32_t filter_params_len /**< */, const xcb_render_fixed_t *filter_params /**< */); +int +xcb_randr_get_crtc_transform_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4279,7 +4334,7 @@ xcb_randr_get_crtc_transform (xcb_connection_t *c /**< */, xcb_randr_crtc_t crtc /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4492,7 +4547,7 @@ xcb_randr_get_crtc_transform_reply (xcb_connection_t *c / xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4515,7 +4570,7 @@ xcb_randr_get_panning (xcb_connection_t *c /**< */, xcb_randr_crtc_t crtc /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4572,7 +4627,7 @@ xcb_randr_get_panning_reply (xcb_connection_t *c /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4621,7 +4676,7 @@ xcb_randr_set_panning (xcb_connection_t *c /**< */, int16_t border_bottom /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4704,7 +4759,7 @@ xcb_randr_set_panning_reply (xcb_connection_t *c /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4732,7 +4787,7 @@ xcb_randr_set_output_primary_checked (xcb_connection_t *c /**< */, xcb_randr_output_t output /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4757,7 +4812,7 @@ xcb_randr_set_output_primary (xcb_connection_t *c /**< */, xcb_randr_output_t output /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4780,7 +4835,7 @@ xcb_randr_get_output_primary (xcb_connection_t *c /**< */, xcb_window_t window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * diff --git a/src/3rdparty/xcb/include/xcb/render.h b/src/3rdparty/xcb/include/xcb/render.h index 0f96ca1fbc..eb7f0424d5 100644 --- a/src/3rdparty/xcb/include/xcb/render.h +++ b/src/3rdparty/xcb/include/xcb/render.h @@ -20,7 +20,7 @@ extern "C" { #endif #define XCB_RENDER_MAJOR_VERSION 0 -#define XCB_RENDER_MINOR_VERSION 10 +#define XCB_RENDER_MINOR_VERSION 11 extern xcb_extension_t xcb_render_id; @@ -71,7 +71,22 @@ typedef enum xcb_render_pict_op_t { XCB_RENDER_PICT_OP_CONJOINT_OUT_REVERSE, XCB_RENDER_PICT_OP_CONJOINT_ATOP, XCB_RENDER_PICT_OP_CONJOINT_ATOP_REVERSE, - XCB_RENDER_PICT_OP_CONJOINT_XOR + XCB_RENDER_PICT_OP_CONJOINT_XOR, + XCB_RENDER_PICT_OP_MULTIPLY = 48, + XCB_RENDER_PICT_OP_SCREEN, + XCB_RENDER_PICT_OP_OVERLAY, + XCB_RENDER_PICT_OP_DARKEN, + XCB_RENDER_PICT_OP_LIGHTEN, + XCB_RENDER_PICT_OP_COLOR_DODGE, + XCB_RENDER_PICT_OP_COLOR_BURN, + XCB_RENDER_PICT_OP_HARD_LIGHT, + XCB_RENDER_PICT_OP_SOFT_LIGHT, + XCB_RENDER_PICT_OP_DIFFERENCE, + XCB_RENDER_PICT_OP_EXCLUSION, + XCB_RENDER_PICT_OP_HSL_HUE, + XCB_RENDER_PICT_OP_HSL_SATURATION, + XCB_RENDER_PICT_OP_HSL_COLOR, + XCB_RENDER_PICT_OP_HSL_LUMINOSITY } xcb_render_pict_op_t; typedef enum xcb_render_poly_edge_t { @@ -1453,6 +1468,9 @@ xcb_render_pictvisual_next (xcb_render_pictvisual_iterator_t *i /**< */); xcb_generic_iterator_t xcb_render_pictvisual_end (xcb_render_pictvisual_iterator_t i /**< */); +int +xcb_render_pictdepth_sizeof (const void *_buffer /**< */); + /***************************************************************************** ** @@ -1535,6 +1553,9 @@ xcb_render_pictdepth_next (xcb_render_pictdepth_iterator_t *i /**< */); xcb_generic_iterator_t xcb_render_pictdepth_end (xcb_render_pictdepth_iterator_t i /**< */); +int +xcb_render_pictscreen_sizeof (const void *_buffer /**< */); + /***************************************************************************** ** @@ -1906,7 +1927,7 @@ xcb_generic_iterator_t xcb_render_glyphinfo_end (xcb_render_glyphinfo_iterator_t i /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1931,7 +1952,7 @@ xcb_render_query_version (xcb_connection_t *c /**< */, uint32_t client_minor_version /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1989,8 +2010,11 @@ xcb_render_query_version_reply (xcb_connection_t *c /**< */, xcb_render_query_version_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_render_query_pict_formats_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2011,7 +2035,7 @@ xcb_render_query_pict_formats_cookie_t xcb_render_query_pict_formats (xcb_connection_t *c /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2169,8 +2193,11 @@ xcb_render_query_pict_formats_reply (xcb_connection_t *c xcb_render_query_pict_formats_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_render_query_pict_index_values_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2193,7 +2220,7 @@ xcb_render_query_pict_index_values (xcb_connection_t *c /**< */, xcb_render_pictformat_t format /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2288,8 +2315,11 @@ xcb_render_query_pict_index_values_reply (xcb_connection_t xcb_render_query_pict_index_values_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_render_create_picture_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2323,7 +2353,7 @@ xcb_render_create_picture_checked (xcb_connection_t *c /**< */, const uint32_t *value_list /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2353,8 +2383,11 @@ xcb_render_create_picture (xcb_connection_t *c /**< */, uint32_t value_mask /**< */, const uint32_t *value_list /**< */); +int +xcb_render_change_picture_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2384,7 +2417,7 @@ xcb_render_change_picture_checked (xcb_connection_t *c /**< */, const uint32_t *value_list /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2410,8 +2443,12 @@ xcb_render_change_picture (xcb_connection_t *c /**< */, uint32_t value_mask /**< */, const uint32_t *value_list /**< */); +int +xcb_render_set_picture_clip_rectangles_sizeof (const void *_buffer /**< */, + uint32_t rectangles_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2445,7 +2482,7 @@ xcb_render_set_picture_clip_rectangles_checked (xcb_connection_t *c /**< * const xcb_rectangle_t *rectangles /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2476,7 +2513,7 @@ xcb_render_set_picture_clip_rectangles (xcb_connection_t *c /**< */, const xcb_rectangle_t *rectangles /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2502,7 +2539,7 @@ xcb_render_free_picture_checked (xcb_connection_t *c /**< */, xcb_render_picture_t picture /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2525,7 +2562,7 @@ xcb_render_free_picture (xcb_connection_t *c /**< */, xcb_render_picture_t picture /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2573,7 +2610,7 @@ xcb_render_composite_checked (xcb_connection_t *c /**< */, uint16_t height /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2617,8 +2654,12 @@ xcb_render_composite (xcb_connection_t *c /**< */, uint16_t width /**< */, uint16_t height /**< */); +int +xcb_render_trapezoids_sizeof (const void *_buffer /**< */, + uint32_t traps_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2658,7 +2699,7 @@ xcb_render_trapezoids_checked (xcb_connection_t *c /**< */, const xcb_render_trapezoid_t *traps /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2694,8 +2735,12 @@ xcb_render_trapezoids (xcb_connection_t *c /**< */, uint32_t traps_len /**< */, const xcb_render_trapezoid_t *traps /**< */); +int +xcb_render_triangles_sizeof (const void *_buffer /**< */, + uint32_t triangles_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2735,7 +2780,7 @@ xcb_render_triangles_checked (xcb_connection_t *c /**< */, const xcb_render_triangle_t *triangles /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2771,8 +2816,12 @@ xcb_render_triangles (xcb_connection_t *c /**< */, uint32_t triangles_len /**< */, const xcb_render_triangle_t *triangles /**< */); +int +xcb_render_tri_strip_sizeof (const void *_buffer /**< */, + uint32_t points_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2812,7 +2861,7 @@ xcb_render_tri_strip_checked (xcb_connection_t *c /**< */, const xcb_render_pointfix_t *points /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2848,8 +2897,12 @@ xcb_render_tri_strip (xcb_connection_t *c /**< */, uint32_t points_len /**< */, const xcb_render_pointfix_t *points /**< */); +int +xcb_render_tri_fan_sizeof (const void *_buffer /**< */, + uint32_t points_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2889,7 +2942,7 @@ xcb_render_tri_fan_checked (xcb_connection_t *c /**< */, const xcb_render_pointfix_t *points /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2926,7 +2979,7 @@ xcb_render_tri_fan (xcb_connection_t *c /**< */, const xcb_render_pointfix_t *points /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2954,7 +3007,7 @@ xcb_render_create_glyph_set_checked (xcb_connection_t *c /**< */, xcb_render_pictformat_t format /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2979,7 +3032,7 @@ xcb_render_create_glyph_set (xcb_connection_t *c /**< */, xcb_render_pictformat_t format /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3007,7 +3060,7 @@ xcb_render_reference_glyph_set_checked (xcb_connection_t *c /**< */, xcb_render_glyphset_t existing /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3032,7 +3085,7 @@ xcb_render_reference_glyph_set (xcb_connection_t *c /**< */, xcb_render_glyphset_t existing /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3058,7 +3111,7 @@ xcb_render_free_glyph_set_checked (xcb_connection_t *c /**< */, xcb_render_glyphset_t glyphset /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3080,8 +3133,12 @@ xcb_void_cookie_t xcb_render_free_glyph_set (xcb_connection_t *c /**< */, xcb_render_glyphset_t glyphset /**< */); +int +xcb_render_add_glyphs_sizeof (const void *_buffer /**< */, + uint32_t data_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3117,7 +3174,7 @@ xcb_render_add_glyphs_checked (xcb_connection_t *c /**< */, const uint8_t *data /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3149,8 +3206,12 @@ xcb_render_add_glyphs (xcb_connection_t *c /**< */, uint32_t data_len /**< */, const uint8_t *data /**< */); +int +xcb_render_free_glyphs_sizeof (const void *_buffer /**< */, + uint32_t glyphs_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3180,7 +3241,7 @@ xcb_render_free_glyphs_checked (xcb_connection_t *c /**< */, const xcb_render_glyph_t *glyphs /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3206,8 +3267,12 @@ xcb_render_free_glyphs (xcb_connection_t *c /**< */, uint32_t glyphs_len /**< */, const xcb_render_glyph_t *glyphs /**< */); +int +xcb_render_composite_glyphs_8_sizeof (const void *_buffer /**< */, + uint32_t glyphcmds_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3249,7 +3314,7 @@ xcb_render_composite_glyphs_8_checked (xcb_connection_t *c /**< */, const uint8_t *glyphcmds /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3287,8 +3352,12 @@ xcb_render_composite_glyphs_8 (xcb_connection_t *c /**< */, uint32_t glyphcmds_len /**< */, const uint8_t *glyphcmds /**< */); +int +xcb_render_composite_glyphs_16_sizeof (const void *_buffer /**< */, + uint32_t glyphcmds_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3330,7 +3399,7 @@ xcb_render_composite_glyphs_16_checked (xcb_connection_t *c /**< */, const uint8_t *glyphcmds /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3368,8 +3437,12 @@ xcb_render_composite_glyphs_16 (xcb_connection_t *c /**< */, uint32_t glyphcmds_len /**< */, const uint8_t *glyphcmds /**< */); +int +xcb_render_composite_glyphs_32_sizeof (const void *_buffer /**< */, + uint32_t glyphcmds_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3411,7 +3484,7 @@ xcb_render_composite_glyphs_32_checked (xcb_connection_t *c /**< */, const uint8_t *glyphcmds /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3449,8 +3522,12 @@ xcb_render_composite_glyphs_32 (xcb_connection_t *c /**< */, uint32_t glyphcmds_len /**< */, const uint8_t *glyphcmds /**< */); +int +xcb_render_fill_rectangles_sizeof (const void *_buffer /**< */, + uint32_t rects_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3484,7 +3561,7 @@ xcb_render_fill_rectangles_checked (xcb_connection_t *c /**< */, const xcb_rectangle_t *rects /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3515,7 +3592,7 @@ xcb_render_fill_rectangles (xcb_connection_t *c /**< */, const xcb_rectangle_t *rects /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3547,7 +3624,7 @@ xcb_render_create_cursor_checked (xcb_connection_t *c /**< */, uint16_t y /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3619,7 +3696,7 @@ xcb_generic_iterator_t xcb_render_transform_end (xcb_render_transform_iterator_t i /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3647,7 +3724,7 @@ xcb_render_set_picture_transform_checked (xcb_connection_t *c /**< */, xcb_render_transform_t transform /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3671,8 +3748,11 @@ xcb_render_set_picture_transform (xcb_connection_t *c /**< */, xcb_render_picture_t picture /**< */, xcb_render_transform_t transform /**< */); +int +xcb_render_query_filters_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3695,7 +3775,7 @@ xcb_render_query_filters (xcb_connection_t *c /**< */, xcb_drawable_t drawable /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3816,8 +3896,12 @@ xcb_render_query_filters_reply (xcb_connection_t *c /**< */, xcb_render_query_filters_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_render_set_picture_filter_sizeof (const void *_buffer /**< */, + uint32_t values_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3851,7 +3935,7 @@ xcb_render_set_picture_filter_checked (xcb_connection_t *c /**< */, const xcb_render_fixed_t *values /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3924,8 +4008,12 @@ xcb_render_animcursorelt_next (xcb_render_animcursorelt_iterator_t *i /**< */); xcb_generic_iterator_t xcb_render_animcursorelt_end (xcb_render_animcursorelt_iterator_t i /**< */); +int +xcb_render_create_anim_cursor_sizeof (const void *_buffer /**< */, + uint32_t cursors_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -3955,7 +4043,7 @@ xcb_render_create_anim_cursor_checked (xcb_connection_t *c /**< const xcb_render_animcursorelt_t *cursors /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4067,8 +4155,12 @@ xcb_render_trap_next (xcb_render_trap_iterator_t *i /**< */); xcb_generic_iterator_t xcb_render_trap_end (xcb_render_trap_iterator_t i /**< */); +int +xcb_render_add_traps_sizeof (const void *_buffer /**< */, + uint32_t traps_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4102,7 +4194,7 @@ xcb_render_add_traps_checked (xcb_connection_t *c /**< */, const xcb_render_trap_t *traps /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4133,7 +4225,7 @@ xcb_render_add_traps (xcb_connection_t *c /**< */, const xcb_render_trap_t *traps /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4161,7 +4253,7 @@ xcb_render_create_solid_fill_checked (xcb_connection_t *c /**< */, xcb_render_color_t color /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4185,8 +4277,11 @@ xcb_render_create_solid_fill (xcb_connection_t *c /**< */, xcb_render_picture_t picture /**< */, xcb_render_color_t color /**< */); +int +xcb_render_create_linear_gradient_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4222,7 +4317,7 @@ xcb_render_create_linear_gradient_checked (xcb_connection_t *c /**< */, const xcb_render_color_t *colors /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4254,8 +4349,11 @@ xcb_render_create_linear_gradient (xcb_connection_t *c /**< */, const xcb_render_fixed_t *stops /**< */, const xcb_render_color_t *colors /**< */); +int +xcb_render_create_radial_gradient_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4295,7 +4393,7 @@ xcb_render_create_radial_gradient_checked (xcb_connection_t *c /**< */, const xcb_render_color_t *colors /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4331,8 +4429,11 @@ xcb_render_create_radial_gradient (xcb_connection_t *c /**< */, const xcb_render_fixed_t *stops /**< */, const xcb_render_color_t *colors /**< */); +int +xcb_render_create_conical_gradient_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -4368,7 +4469,7 @@ xcb_render_create_conical_gradient_checked (xcb_connection_t *c /**< */ const xcb_render_color_t *colors /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * diff --git a/src/3rdparty/xcb/include/xcb/shape.h b/src/3rdparty/xcb/include/xcb/shape.h index 107d2ff748..63919b42c7 100644 --- a/src/3rdparty/xcb/include/xcb/shape.h +++ b/src/3rdparty/xcb/include/xcb/shape.h @@ -393,7 +393,7 @@ xcb_generic_iterator_t xcb_shape_kind_end (xcb_shape_kind_iterator_t i /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -414,7 +414,7 @@ xcb_shape_query_version_cookie_t xcb_shape_query_version (xcb_connection_t *c /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -468,8 +468,12 @@ xcb_shape_query_version_reply (xcb_connection_t *c /**< */, xcb_shape_query_version_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_shape_rectangles_sizeof (const void *_buffer /**< */, + uint32_t rectangles_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -509,7 +513,7 @@ xcb_shape_rectangles_checked (xcb_connection_t *c /**< */, const xcb_rectangle_t *rectangles /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -546,7 +550,7 @@ xcb_shape_rectangles (xcb_connection_t *c /**< */, const xcb_rectangle_t *rectangles /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -582,7 +586,7 @@ xcb_shape_mask_checked (xcb_connection_t *c /**< */, xcb_pixmap_t source_bitmap /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -615,7 +619,7 @@ xcb_shape_mask (xcb_connection_t *c /**< */, xcb_pixmap_t source_bitmap /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -653,7 +657,7 @@ xcb_shape_combine_checked (xcb_connection_t *c /**< */, xcb_window_t source_window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -688,7 +692,7 @@ xcb_shape_combine (xcb_connection_t *c /**< */, xcb_window_t source_window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -720,7 +724,7 @@ xcb_shape_offset_checked (xcb_connection_t *c /**< */, int16_t y_offset /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -749,7 +753,7 @@ xcb_shape_offset (xcb_connection_t *c /**< */, int16_t y_offset /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -772,7 +776,7 @@ xcb_shape_query_extents (xcb_connection_t *c /**< */, xcb_window_t destination_window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -829,7 +833,7 @@ xcb_shape_query_extents_reply (xcb_connection_t *c /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -857,7 +861,7 @@ xcb_shape_select_input_checked (xcb_connection_t *c /**< */, uint8_t enable /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -882,7 +886,7 @@ xcb_shape_select_input (xcb_connection_t *c /**< */, uint8_t enable /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -905,7 +909,7 @@ xcb_shape_input_selected (xcb_connection_t *c /**< */, xcb_window_t destination_window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -961,8 +965,11 @@ xcb_shape_input_selected_reply (xcb_connection_t *c /**< */, xcb_shape_input_selected_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_shape_get_rectangles_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -987,7 +994,7 @@ xcb_shape_get_rectangles (xcb_connection_t *c /**< */, xcb_shape_kind_t source_kind /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * diff --git a/src/3rdparty/xcb/include/xcb/shm.h b/src/3rdparty/xcb/include/xcb/shm.h index bcb60d81f1..315f37e9b9 100644 --- a/src/3rdparty/xcb/include/xcb/shm.h +++ b/src/3rdparty/xcb/include/xcb/shm.h @@ -255,7 +255,7 @@ xcb_generic_iterator_t xcb_shm_seg_end (xcb_shm_seg_iterator_t i /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -276,7 +276,7 @@ xcb_shm_query_version_cookie_t xcb_shm_query_version (xcb_connection_t *c /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -331,7 +331,7 @@ xcb_shm_query_version_reply (xcb_connection_t *c /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -361,7 +361,7 @@ xcb_shm_attach_checked (xcb_connection_t *c /**< */, uint8_t read_only /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -388,7 +388,7 @@ xcb_shm_attach (xcb_connection_t *c /**< */, uint8_t read_only /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -414,7 +414,7 @@ xcb_shm_detach_checked (xcb_connection_t *c /**< */, xcb_shm_seg_t shmseg /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -437,7 +437,7 @@ xcb_shm_detach (xcb_connection_t *c /**< */, xcb_shm_seg_t shmseg /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -491,7 +491,7 @@ xcb_shm_put_image_checked (xcb_connection_t *c /**< */, uint32_t offset /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -542,7 +542,7 @@ xcb_shm_put_image (xcb_connection_t *c /**< */, uint32_t offset /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -581,7 +581,7 @@ xcb_shm_get_image (xcb_connection_t *c /**< */, uint32_t offset /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -654,7 +654,7 @@ xcb_shm_get_image_reply (xcb_connection_t *c /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -692,7 +692,7 @@ xcb_shm_create_pixmap_checked (xcb_connection_t *c /**< */, uint32_t offset /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * diff --git a/src/3rdparty/xcb/include/xcb/sync.h b/src/3rdparty/xcb/include/xcb/sync.h index 50665c2865..3d0069d7ef 100644 --- a/src/3rdparty/xcb/include/xcb/sync.h +++ b/src/3rdparty/xcb/include/xcb/sync.h @@ -20,7 +20,7 @@ extern "C" { #endif #define XCB_SYNC_MAJOR_VERSION 3 -#define XCB_SYNC_MINOR_VERSION 0 +#define XCB_SYNC_MINOR_VERSION 1 extern xcb_extension_t xcb_sync_id; @@ -52,6 +52,17 @@ typedef struct xcb_sync_counter_iterator_t { int index; /**< */ } xcb_sync_counter_iterator_t; +typedef uint32_t xcb_sync_fence_t; + +/** + * @brief xcb_sync_fence_iterator_t + **/ +typedef struct xcb_sync_fence_iterator_t { + xcb_sync_fence_t *data; /**< */ + int rem; /**< */ + int index; /**< */ +} xcb_sync_fence_iterator_t; + typedef enum xcb_sync_testtype_t { XCB_SYNC_TESTTYPE_POSITIVE_TRANSITION, XCB_SYNC_TESTTYPE_NEGATIVE_TRANSITION, @@ -458,6 +469,104 @@ typedef struct xcb_sync_get_priority_reply_t { int32_t priority; /**< */ } xcb_sync_get_priority_reply_t; +/** Opcode for xcb_sync_create_fence. */ +#define XCB_SYNC_CREATE_FENCE 14 + +/** + * @brief xcb_sync_create_fence_request_t + **/ +typedef struct xcb_sync_create_fence_request_t { + uint8_t major_opcode; /**< */ + uint8_t minor_opcode; /**< */ + uint16_t length; /**< */ + xcb_drawable_t drawable; /**< */ + xcb_sync_fence_t fence; /**< */ + uint8_t initially_triggered; /**< */ +} xcb_sync_create_fence_request_t; + +/** Opcode for xcb_sync_trigger_fence. */ +#define XCB_SYNC_TRIGGER_FENCE 15 + +/** + * @brief xcb_sync_trigger_fence_request_t + **/ +typedef struct xcb_sync_trigger_fence_request_t { + uint8_t major_opcode; /**< */ + uint8_t minor_opcode; /**< */ + uint16_t length; /**< */ + xcb_sync_fence_t fence; /**< */ +} xcb_sync_trigger_fence_request_t; + +/** Opcode for xcb_sync_reset_fence. */ +#define XCB_SYNC_RESET_FENCE 16 + +/** + * @brief xcb_sync_reset_fence_request_t + **/ +typedef struct xcb_sync_reset_fence_request_t { + uint8_t major_opcode; /**< */ + uint8_t minor_opcode; /**< */ + uint16_t length; /**< */ + xcb_sync_fence_t fence; /**< */ +} xcb_sync_reset_fence_request_t; + +/** Opcode for xcb_sync_destroy_fence. */ +#define XCB_SYNC_DESTROY_FENCE 17 + +/** + * @brief xcb_sync_destroy_fence_request_t + **/ +typedef struct xcb_sync_destroy_fence_request_t { + uint8_t major_opcode; /**< */ + uint8_t minor_opcode; /**< */ + uint16_t length; /**< */ + xcb_sync_fence_t fence; /**< */ +} xcb_sync_destroy_fence_request_t; + +/** + * @brief xcb_sync_query_fence_cookie_t + **/ +typedef struct xcb_sync_query_fence_cookie_t { + unsigned int sequence; /**< */ +} xcb_sync_query_fence_cookie_t; + +/** Opcode for xcb_sync_query_fence. */ +#define XCB_SYNC_QUERY_FENCE 18 + +/** + * @brief xcb_sync_query_fence_request_t + **/ +typedef struct xcb_sync_query_fence_request_t { + uint8_t major_opcode; /**< */ + uint8_t minor_opcode; /**< */ + uint16_t length; /**< */ + xcb_sync_fence_t fence; /**< */ +} xcb_sync_query_fence_request_t; + +/** + * @brief xcb_sync_query_fence_reply_t + **/ +typedef struct xcb_sync_query_fence_reply_t { + uint8_t response_type; /**< */ + uint8_t pad0; /**< */ + uint16_t sequence; /**< */ + uint32_t length; /**< */ + uint8_t triggered; /**< */ + uint8_t pad1[23]; /**< */ +} xcb_sync_query_fence_reply_t; + +/** Opcode for xcb_sync_await_fence. */ +#define XCB_SYNC_AWAIT_FENCE 19 + +/** + * @brief xcb_sync_await_fence_request_t + **/ +typedef struct xcb_sync_await_fence_request_t { + uint8_t major_opcode; /**< */ + uint8_t minor_opcode; /**< */ + uint16_t length; /**< */ +} xcb_sync_await_fence_request_t; + /** Opcode for xcb_sync_counter_notify. */ #define XCB_SYNC_COUNTER_NOTIFY 0 @@ -583,6 +692,49 @@ xcb_sync_counter_end (xcb_sync_counter_iterator_t i /**< */); /** * Get the next element of the iterator + * @param i Pointer to a xcb_sync_fence_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_sync_fence_t) + */ + +/***************************************************************************** + ** + ** void xcb_sync_fence_next + ** + ** @param xcb_sync_fence_iterator_t *i + ** @returns void + ** + *****************************************************************************/ + +void +xcb_sync_fence_next (xcb_sync_fence_iterator_t *i /**< */); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_sync_fence_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ + +/***************************************************************************** + ** + ** xcb_generic_iterator_t xcb_sync_fence_end + ** + ** @param xcb_sync_fence_iterator_t i + ** @returns xcb_generic_iterator_t + ** + *****************************************************************************/ + +xcb_generic_iterator_t +xcb_sync_fence_end (xcb_sync_fence_iterator_t i /**< */); + +/** + * Get the next element of the iterator * @param i Pointer to a xcb_sync_int64_iterator_t * * Get the next element in the iterator. The member rem is @@ -624,6 +776,9 @@ xcb_sync_int64_next (xcb_sync_int64_iterator_t *i /**< */); xcb_generic_iterator_t xcb_sync_int64_end (xcb_sync_int64_iterator_t i /**< */); +int +xcb_sync_systemcounter_sizeof (const void *_buffer /**< */); + /***************************************************************************** ** @@ -793,7 +948,7 @@ xcb_generic_iterator_t xcb_sync_waitcondition_end (xcb_sync_waitcondition_iterator_t i /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -818,7 +973,7 @@ xcb_sync_initialize (xcb_connection_t *c /**< */, uint8_t desired_minor_version /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -876,8 +1031,11 @@ xcb_sync_initialize_reply (xcb_connection_t *c /**< */, xcb_sync_initialize_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_sync_list_system_counters_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -898,7 +1056,7 @@ xcb_sync_list_system_counters_cookie_t xcb_sync_list_system_counters (xcb_connection_t *c /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -979,7 +1137,7 @@ xcb_sync_list_system_counters_reply (xcb_connection_t *c xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1007,7 +1165,7 @@ xcb_sync_create_counter_checked (xcb_connection_t *c /**< */, xcb_sync_int64_t initial_value /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1032,7 +1190,7 @@ xcb_sync_create_counter (xcb_connection_t *c /**< */, xcb_sync_int64_t initial_value /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1058,7 +1216,7 @@ xcb_sync_destroy_counter_checked (xcb_connection_t *c /**< */, xcb_sync_counter_t counter /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1081,7 +1239,7 @@ xcb_sync_destroy_counter (xcb_connection_t *c /**< */, xcb_sync_counter_t counter /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1104,7 +1262,7 @@ xcb_sync_query_counter (xcb_connection_t *c /**< */, xcb_sync_counter_t counter /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1160,8 +1318,12 @@ xcb_sync_query_counter_reply (xcb_connection_t *c /**< */, xcb_sync_query_counter_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_sync_await_sizeof (const void *_buffer /**< */, + uint32_t wait_list_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1189,7 +1351,7 @@ xcb_sync_await_checked (xcb_connection_t *c /**< */, const xcb_sync_waitcondition_t *wait_list /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1214,7 +1376,7 @@ xcb_sync_await (xcb_connection_t *c /**< */, const xcb_sync_waitcondition_t *wait_list /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1242,7 +1404,7 @@ xcb_sync_change_counter_checked (xcb_connection_t *c /**< */, xcb_sync_int64_t amount /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1267,7 +1429,7 @@ xcb_sync_change_counter (xcb_connection_t *c /**< */, xcb_sync_int64_t amount /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1295,7 +1457,7 @@ xcb_sync_set_counter_checked (xcb_connection_t *c /**< */, xcb_sync_int64_t value /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1319,8 +1481,11 @@ xcb_sync_set_counter (xcb_connection_t *c /**< */, xcb_sync_counter_t counter /**< */, xcb_sync_int64_t value /**< */); +int +xcb_sync_create_alarm_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1350,7 +1515,7 @@ xcb_sync_create_alarm_checked (xcb_connection_t *c /**< */, const uint32_t *value_list /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1376,8 +1541,11 @@ xcb_sync_create_alarm (xcb_connection_t *c /**< */, uint32_t value_mask /**< */, const uint32_t *value_list /**< */); +int +xcb_sync_change_alarm_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1407,7 +1575,7 @@ xcb_sync_change_alarm_checked (xcb_connection_t *c /**< */, const uint32_t *value_list /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1434,7 +1602,7 @@ xcb_sync_change_alarm (xcb_connection_t *c /**< */, const uint32_t *value_list /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1460,7 +1628,7 @@ xcb_sync_destroy_alarm_checked (xcb_connection_t *c /**< */, xcb_sync_alarm_t alarm /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1483,7 +1651,7 @@ xcb_sync_destroy_alarm (xcb_connection_t *c /**< */, xcb_sync_alarm_t alarm /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1506,7 +1674,7 @@ xcb_sync_query_alarm (xcb_connection_t *c /**< */, xcb_sync_alarm_t alarm /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1563,7 +1731,7 @@ xcb_sync_query_alarm_reply (xcb_connection_t *c /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1591,7 +1759,7 @@ xcb_sync_set_priority_checked (xcb_connection_t *c /**< */, int32_t priority /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1616,7 +1784,7 @@ xcb_sync_set_priority (xcb_connection_t *c /**< */, int32_t priority /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1639,7 +1807,7 @@ xcb_sync_get_priority (xcb_connection_t *c /**< */, uint32_t id /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1695,6 +1863,347 @@ xcb_sync_get_priority_reply (xcb_connection_t *c /**< */, xcb_sync_get_priority_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_create_fence_checked + ** + ** @param xcb_connection_t *c + ** @param xcb_drawable_t drawable + ** @param xcb_sync_fence_t fence + ** @param uint8_t initially_triggered + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_create_fence_checked (xcb_connection_t *c /**< */, + xcb_drawable_t drawable /**< */, + xcb_sync_fence_t fence /**< */, + uint8_t initially_triggered /**< */); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_create_fence + ** + ** @param xcb_connection_t *c + ** @param xcb_drawable_t drawable + ** @param xcb_sync_fence_t fence + ** @param uint8_t initially_triggered + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_create_fence (xcb_connection_t *c /**< */, + xcb_drawable_t drawable /**< */, + xcb_sync_fence_t fence /**< */, + uint8_t initially_triggered /**< */); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_trigger_fence_checked + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_trigger_fence_checked (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_trigger_fence + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_trigger_fence (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_reset_fence_checked + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_reset_fence_checked (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_reset_fence + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_reset_fence (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_destroy_fence_checked + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_destroy_fence_checked (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_destroy_fence + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_destroy_fence (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ + +/***************************************************************************** + ** + ** xcb_sync_query_fence_cookie_t xcb_sync_query_fence + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_sync_query_fence_cookie_t + ** + *****************************************************************************/ + +xcb_sync_query_fence_cookie_t +xcb_sync_query_fence (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ + +/***************************************************************************** + ** + ** xcb_sync_query_fence_cookie_t xcb_sync_query_fence_unchecked + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_sync_query_fence_cookie_t + ** + *****************************************************************************/ + +xcb_sync_query_fence_cookie_t +xcb_sync_query_fence_unchecked (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_sync_query_fence_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ + +/***************************************************************************** + ** + ** xcb_sync_query_fence_reply_t * xcb_sync_query_fence_reply + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_query_fence_cookie_t cookie + ** @param xcb_generic_error_t **e + ** @returns xcb_sync_query_fence_reply_t * + ** + *****************************************************************************/ + +xcb_sync_query_fence_reply_t * +xcb_sync_query_fence_reply (xcb_connection_t *c /**< */, + xcb_sync_query_fence_cookie_t cookie /**< */, + xcb_generic_error_t **e /**< */); + +int +xcb_sync_await_fence_sizeof (const void *_buffer /**< */, + uint32_t fence_list_len /**< */); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_await_fence_checked + ** + ** @param xcb_connection_t *c + ** @param uint32_t fence_list_len + ** @param const xcb_sync_fence_t *fence_list + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_await_fence_checked (xcb_connection_t *c /**< */, + uint32_t fence_list_len /**< */, + const xcb_sync_fence_t *fence_list /**< */); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_await_fence + ** + ** @param xcb_connection_t *c + ** @param uint32_t fence_list_len + ** @param const xcb_sync_fence_t *fence_list + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_await_fence (xcb_connection_t *c /**< */, + uint32_t fence_list_len /**< */, + const xcb_sync_fence_t *fence_list /**< */); + #ifdef __cplusplus } diff --git a/src/3rdparty/xcb/include/xcb/xfixes.h b/src/3rdparty/xcb/include/xcb/xfixes.h index 4d7eb0900a..b67aa85135 100644 --- a/src/3rdparty/xcb/include/xcb/xfixes.h +++ b/src/3rdparty/xcb/include/xcb/xfixes.h @@ -683,7 +683,7 @@ typedef struct xcb_xfixes_show_cursor_request_t { } xcb_xfixes_show_cursor_request_t; /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -708,7 +708,7 @@ xcb_xfixes_query_version (xcb_connection_t *c /**< */, uint32_t client_minor_version /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -767,7 +767,7 @@ xcb_xfixes_query_version_reply (xcb_connection_t *c /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -799,7 +799,7 @@ xcb_xfixes_change_save_set_checked (xcb_connection_t *c /**< */, xcb_window_t window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -828,7 +828,7 @@ xcb_xfixes_change_save_set (xcb_connection_t *c /**< */, xcb_window_t window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -858,7 +858,7 @@ xcb_xfixes_select_selection_input_checked (xcb_connection_t *c /**< */, uint32_t event_mask /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -885,7 +885,7 @@ xcb_xfixes_select_selection_input (xcb_connection_t *c /**< */, uint32_t event_mask /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -913,7 +913,7 @@ xcb_xfixes_select_cursor_input_checked (xcb_connection_t *c /**< */, uint32_t event_mask /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -937,8 +937,11 @@ xcb_xfixes_select_cursor_input (xcb_connection_t *c /**< */, xcb_window_t window /**< */, uint32_t event_mask /**< */); +int +xcb_xfixes_get_cursor_image_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -959,7 +962,7 @@ xcb_xfixes_get_cursor_image_cookie_t xcb_xfixes_get_cursor_image (xcb_connection_t *c /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1095,8 +1098,12 @@ xcb_xfixes_region_next (xcb_xfixes_region_iterator_t *i /**< */); xcb_generic_iterator_t xcb_xfixes_region_end (xcb_xfixes_region_iterator_t i /**< */); +int +xcb_xfixes_create_region_sizeof (const void *_buffer /**< */, + uint32_t rectangles_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1126,7 +1133,7 @@ xcb_xfixes_create_region_checked (xcb_connection_t *c /**< */, const xcb_rectangle_t *rectangles /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1153,7 +1160,7 @@ xcb_xfixes_create_region (xcb_connection_t *c /**< */, const xcb_rectangle_t *rectangles /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1181,7 +1188,7 @@ xcb_xfixes_create_region_from_bitmap_checked (xcb_connection_t *c /**< */, xcb_pixmap_t bitmap /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1206,7 +1213,7 @@ xcb_xfixes_create_region_from_bitmap (xcb_connection_t *c /**< */, xcb_pixmap_t bitmap /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1236,7 +1243,7 @@ xcb_xfixes_create_region_from_window_checked (xcb_connection_t *c /**< */, xcb_shape_kind_t kind /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1263,7 +1270,7 @@ xcb_xfixes_create_region_from_window (xcb_connection_t *c /**< */, xcb_shape_kind_t kind /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1291,7 +1298,7 @@ xcb_xfixes_create_region_from_gc_checked (xcb_connection_t *c /**< */, xcb_gcontext_t gc /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1316,7 +1323,7 @@ xcb_xfixes_create_region_from_gc (xcb_connection_t *c /**< */, xcb_gcontext_t gc /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1344,7 +1351,7 @@ xcb_xfixes_create_region_from_picture_checked (xcb_connection_t *c /**< */, xcb_render_picture_t picture /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1369,7 +1376,7 @@ xcb_xfixes_create_region_from_picture (xcb_connection_t *c /**< */, xcb_render_picture_t picture /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1395,7 +1402,7 @@ xcb_xfixes_destroy_region_checked (xcb_connection_t *c /**< */, xcb_xfixes_region_t region /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1417,8 +1424,12 @@ xcb_void_cookie_t xcb_xfixes_destroy_region (xcb_connection_t *c /**< */, xcb_xfixes_region_t region /**< */); +int +xcb_xfixes_set_region_sizeof (const void *_buffer /**< */, + uint32_t rectangles_len /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1448,7 +1459,7 @@ xcb_xfixes_set_region_checked (xcb_connection_t *c /**< */, const xcb_rectangle_t *rectangles /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1475,7 +1486,7 @@ xcb_xfixes_set_region (xcb_connection_t *c /**< */, const xcb_rectangle_t *rectangles /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1503,7 +1514,7 @@ xcb_xfixes_copy_region_checked (xcb_connection_t *c /**< */, xcb_xfixes_region_t destination /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1528,7 +1539,7 @@ xcb_xfixes_copy_region (xcb_connection_t *c /**< */, xcb_xfixes_region_t destination /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1558,7 +1569,7 @@ xcb_xfixes_union_region_checked (xcb_connection_t *c /**< */, xcb_xfixes_region_t destination /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1585,7 +1596,7 @@ xcb_xfixes_union_region (xcb_connection_t *c /**< */, xcb_xfixes_region_t destination /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1615,7 +1626,7 @@ xcb_xfixes_intersect_region_checked (xcb_connection_t *c /**< */, xcb_xfixes_region_t destination /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1642,7 +1653,7 @@ xcb_xfixes_intersect_region (xcb_connection_t *c /**< */, xcb_xfixes_region_t destination /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1672,7 +1683,7 @@ xcb_xfixes_subtract_region_checked (xcb_connection_t *c /**< */, xcb_xfixes_region_t destination /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1699,7 +1710,7 @@ xcb_xfixes_subtract_region (xcb_connection_t *c /**< */, xcb_xfixes_region_t destination /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1729,7 +1740,7 @@ xcb_xfixes_invert_region_checked (xcb_connection_t *c /**< */, xcb_xfixes_region_t destination /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1756,7 +1767,7 @@ xcb_xfixes_invert_region (xcb_connection_t *c /**< */, xcb_xfixes_region_t destination /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1786,7 +1797,7 @@ xcb_xfixes_translate_region_checked (xcb_connection_t *c /**< */, int16_t dy /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1813,7 +1824,7 @@ xcb_xfixes_translate_region (xcb_connection_t *c /**< */, int16_t dy /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1841,7 +1852,7 @@ xcb_xfixes_region_extents_checked (xcb_connection_t *c /**< */, xcb_xfixes_region_t destination /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1865,8 +1876,11 @@ xcb_xfixes_region_extents (xcb_connection_t *c /**< */, xcb_xfixes_region_t source /**< */, xcb_xfixes_region_t destination /**< */); +int +xcb_xfixes_fetch_region_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1889,7 +1903,7 @@ xcb_xfixes_fetch_region (xcb_connection_t *c /**< */, xcb_xfixes_region_t region /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -1985,7 +1999,7 @@ xcb_xfixes_fetch_region_reply (xcb_connection_t *c /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2017,7 +2031,7 @@ xcb_xfixes_set_gc_clip_region_checked (xcb_connection_t *c /**< */, int16_t y_origin /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2046,7 +2060,7 @@ xcb_xfixes_set_gc_clip_region (xcb_connection_t *c /**< */, int16_t y_origin /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2080,7 +2094,7 @@ xcb_xfixes_set_window_shape_region_checked (xcb_connection_t *c /**< */, xcb_xfixes_region_t region /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2111,7 +2125,7 @@ xcb_xfixes_set_window_shape_region (xcb_connection_t *c /**< */, xcb_xfixes_region_t region /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2143,7 +2157,7 @@ xcb_xfixes_set_picture_clip_region_checked (xcb_connection_t *c /**< */, int16_t y_origin /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2171,8 +2185,11 @@ xcb_xfixes_set_picture_clip_region (xcb_connection_t *c /**< */, int16_t x_origin /**< */, int16_t y_origin /**< */); +int +xcb_xfixes_set_cursor_name_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2202,7 +2219,7 @@ xcb_xfixes_set_cursor_name_checked (xcb_connection_t *c /**< */, const char *name /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2228,8 +2245,11 @@ xcb_xfixes_set_cursor_name (xcb_connection_t *c /**< */, uint16_t nbytes /**< */, const char *name /**< */); +int +xcb_xfixes_get_cursor_name_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2252,7 +2272,7 @@ xcb_xfixes_get_cursor_name (xcb_connection_t *c /**< */, xcb_cursor_t cursor /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2347,8 +2367,11 @@ xcb_xfixes_get_cursor_name_reply (xcb_connection_t *c /**< xcb_xfixes_get_cursor_name_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_xfixes_get_cursor_image_and_name_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2369,7 +2392,7 @@ xcb_xfixes_get_cursor_image_and_name_cookie_t xcb_xfixes_get_cursor_image_and_name (xcb_connection_t *c /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2502,7 +2525,7 @@ xcb_xfixes_get_cursor_image_and_name_reply (xcb_connection_t xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2530,7 +2553,7 @@ xcb_xfixes_change_cursor_checked (xcb_connection_t *c /**< */, xcb_cursor_t destination /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2554,8 +2577,11 @@ xcb_xfixes_change_cursor (xcb_connection_t *c /**< */, xcb_cursor_t source /**< */, xcb_cursor_t destination /**< */); +int +xcb_xfixes_change_cursor_by_name_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2585,7 +2611,7 @@ xcb_xfixes_change_cursor_by_name_checked (xcb_connection_t *c /**< */, const char *name /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2612,7 +2638,7 @@ xcb_xfixes_change_cursor_by_name (xcb_connection_t *c /**< */, const char *name /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2648,7 +2674,7 @@ xcb_xfixes_expand_region_checked (xcb_connection_t *c /**< */, uint16_t bottom /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2681,7 +2707,7 @@ xcb_xfixes_expand_region (xcb_connection_t *c /**< */, uint16_t bottom /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2707,7 +2733,7 @@ xcb_xfixes_hide_cursor_checked (xcb_connection_t *c /**< */, xcb_window_t window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2730,7 +2756,7 @@ xcb_xfixes_hide_cursor (xcb_connection_t *c /**< */, xcb_window_t window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * @@ -2756,7 +2782,7 @@ xcb_xfixes_show_cursor_checked (xcb_connection_t *c /**< */, xcb_window_t window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * diff --git a/src/3rdparty/xcb/include/xcb/xinerama.h b/src/3rdparty/xcb/include/xcb/xinerama.h index 74da5458d2..f18a96c791 100644 --- a/src/3rdparty/xcb/include/xcb/xinerama.h +++ b/src/3rdparty/xcb/include/xcb/xinerama.h @@ -21,7 +21,7 @@ extern "C" { #define XCB_XINERAMA_MAJOR_VERSION 1 #define XCB_XINERAMA_MINOR_VERSION 1 - + extern xcb_extension_t xcb_xinerama_id; /** @@ -246,12 +246,12 @@ typedef struct xcb_xinerama_query_screens_reply_t { /***************************************************************************** ** ** void xcb_xinerama_screen_info_next - ** + ** ** @param xcb_xinerama_screen_info_iterator_t *i ** @returns void ** *****************************************************************************/ - + void xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i /**< */); @@ -268,47 +268,47 @@ xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i /**< */); /***************************************************************************** ** ** xcb_generic_iterator_t xcb_xinerama_screen_info_end - ** + ** ** @param xcb_xinerama_screen_info_iterator_t i ** @returns xcb_generic_iterator_t ** *****************************************************************************/ - + xcb_generic_iterator_t xcb_xinerama_screen_info_end (xcb_xinerama_screen_info_iterator_t i /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * * Delivers a request to the X server. - * + * */ /***************************************************************************** ** ** xcb_xinerama_query_version_cookie_t xcb_xinerama_query_version - ** + ** ** @param xcb_connection_t *c ** @param uint8_t major ** @param uint8_t minor ** @returns xcb_xinerama_query_version_cookie_t ** *****************************************************************************/ - + xcb_xinerama_query_version_cookie_t xcb_xinerama_query_version (xcb_connection_t *c /**< */, uint8_t major /**< */, uint8_t minor /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * * Delivers a request to the X server. - * + * * This form can be used only if the request will cause * a reply to be generated. Any returned error will be * placed in the event queue. @@ -317,14 +317,14 @@ xcb_xinerama_query_version (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_query_version_cookie_t xcb_xinerama_query_version_unchecked - ** + ** ** @param xcb_connection_t *c ** @param uint8_t major ** @param uint8_t minor ** @returns xcb_xinerama_query_version_cookie_t ** *****************************************************************************/ - + xcb_xinerama_query_version_cookie_t xcb_xinerama_query_version_unchecked (xcb_connection_t *c /**< */, uint8_t major /**< */, @@ -337,7 +337,7 @@ xcb_xinerama_query_version_unchecked (xcb_connection_t *c /**< */, * @param e The xcb_generic_error_t supplied * * Returns the reply of the request asked by - * + * * The parameter @p e supplied to this function must be NULL if * xcb_xinerama_query_version_unchecked(). is used. * Otherwise, it stores the error if any. @@ -348,49 +348,49 @@ xcb_xinerama_query_version_unchecked (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_query_version_reply_t * xcb_xinerama_query_version_reply - ** + ** ** @param xcb_connection_t *c ** @param xcb_xinerama_query_version_cookie_t cookie ** @param xcb_generic_error_t **e ** @returns xcb_xinerama_query_version_reply_t * ** *****************************************************************************/ - + xcb_xinerama_query_version_reply_t * xcb_xinerama_query_version_reply (xcb_connection_t *c /**< */, xcb_xinerama_query_version_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * * Delivers a request to the X server. - * + * */ /***************************************************************************** ** ** xcb_xinerama_get_state_cookie_t xcb_xinerama_get_state - ** + ** ** @param xcb_connection_t *c ** @param xcb_window_t window ** @returns xcb_xinerama_get_state_cookie_t ** *****************************************************************************/ - + xcb_xinerama_get_state_cookie_t xcb_xinerama_get_state (xcb_connection_t *c /**< */, xcb_window_t window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * * Delivers a request to the X server. - * + * * This form can be used only if the request will cause * a reply to be generated. Any returned error will be * placed in the event queue. @@ -399,13 +399,13 @@ xcb_xinerama_get_state (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_state_cookie_t xcb_xinerama_get_state_unchecked - ** + ** ** @param xcb_connection_t *c ** @param xcb_window_t window ** @returns xcb_xinerama_get_state_cookie_t ** *****************************************************************************/ - + xcb_xinerama_get_state_cookie_t xcb_xinerama_get_state_unchecked (xcb_connection_t *c /**< */, xcb_window_t window /**< */); @@ -417,7 +417,7 @@ xcb_xinerama_get_state_unchecked (xcb_connection_t *c /**< */, * @param e The xcb_generic_error_t supplied * * Returns the reply of the request asked by - * + * * The parameter @p e supplied to this function must be NULL if * xcb_xinerama_get_state_unchecked(). is used. * Otherwise, it stores the error if any. @@ -428,49 +428,49 @@ xcb_xinerama_get_state_unchecked (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_state_reply_t * xcb_xinerama_get_state_reply - ** + ** ** @param xcb_connection_t *c ** @param xcb_xinerama_get_state_cookie_t cookie ** @param xcb_generic_error_t **e ** @returns xcb_xinerama_get_state_reply_t * ** *****************************************************************************/ - + xcb_xinerama_get_state_reply_t * xcb_xinerama_get_state_reply (xcb_connection_t *c /**< */, xcb_xinerama_get_state_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * * Delivers a request to the X server. - * + * */ /***************************************************************************** ** ** xcb_xinerama_get_screen_count_cookie_t xcb_xinerama_get_screen_count - ** + ** ** @param xcb_connection_t *c ** @param xcb_window_t window ** @returns xcb_xinerama_get_screen_count_cookie_t ** *****************************************************************************/ - + xcb_xinerama_get_screen_count_cookie_t xcb_xinerama_get_screen_count (xcb_connection_t *c /**< */, xcb_window_t window /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * * Delivers a request to the X server. - * + * * This form can be used only if the request will cause * a reply to be generated. Any returned error will be * placed in the event queue. @@ -479,13 +479,13 @@ xcb_xinerama_get_screen_count (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_screen_count_cookie_t xcb_xinerama_get_screen_count_unchecked - ** + ** ** @param xcb_connection_t *c ** @param xcb_window_t window ** @returns xcb_xinerama_get_screen_count_cookie_t ** *****************************************************************************/ - + xcb_xinerama_get_screen_count_cookie_t xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c /**< */, xcb_window_t window /**< */); @@ -497,7 +497,7 @@ xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c /**< */, * @param e The xcb_generic_error_t supplied * * Returns the reply of the request asked by - * + * * The parameter @p e supplied to this function must be NULL if * xcb_xinerama_get_screen_count_unchecked(). is used. * Otherwise, it stores the error if any. @@ -508,51 +508,51 @@ xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_screen_count_reply_t * xcb_xinerama_get_screen_count_reply - ** + ** ** @param xcb_connection_t *c ** @param xcb_xinerama_get_screen_count_cookie_t cookie ** @param xcb_generic_error_t **e ** @returns xcb_xinerama_get_screen_count_reply_t * ** *****************************************************************************/ - + xcb_xinerama_get_screen_count_reply_t * xcb_xinerama_get_screen_count_reply (xcb_connection_t *c /**< */, xcb_xinerama_get_screen_count_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * * Delivers a request to the X server. - * + * */ /***************************************************************************** ** ** xcb_xinerama_get_screen_size_cookie_t xcb_xinerama_get_screen_size - ** + ** ** @param xcb_connection_t *c ** @param xcb_window_t window ** @param uint32_t screen ** @returns xcb_xinerama_get_screen_size_cookie_t ** *****************************************************************************/ - + xcb_xinerama_get_screen_size_cookie_t xcb_xinerama_get_screen_size (xcb_connection_t *c /**< */, xcb_window_t window /**< */, uint32_t screen /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * * Delivers a request to the X server. - * + * * This form can be used only if the request will cause * a reply to be generated. Any returned error will be * placed in the event queue. @@ -561,14 +561,14 @@ xcb_xinerama_get_screen_size (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_screen_size_cookie_t xcb_xinerama_get_screen_size_unchecked - ** + ** ** @param xcb_connection_t *c ** @param xcb_window_t window ** @param uint32_t screen ** @returns xcb_xinerama_get_screen_size_cookie_t ** *****************************************************************************/ - + xcb_xinerama_get_screen_size_cookie_t xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c /**< */, xcb_window_t window /**< */, @@ -581,7 +581,7 @@ xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c /**< */, * @param e The xcb_generic_error_t supplied * * Returns the reply of the request asked by - * + * * The parameter @p e supplied to this function must be NULL if * xcb_xinerama_get_screen_size_unchecked(). is used. * Otherwise, it stores the error if any. @@ -592,47 +592,47 @@ xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_screen_size_reply_t * xcb_xinerama_get_screen_size_reply - ** + ** ** @param xcb_connection_t *c ** @param xcb_xinerama_get_screen_size_cookie_t cookie ** @param xcb_generic_error_t **e ** @returns xcb_xinerama_get_screen_size_reply_t * ** *****************************************************************************/ - + xcb_xinerama_get_screen_size_reply_t * xcb_xinerama_get_screen_size_reply (xcb_connection_t *c /**< */, xcb_xinerama_get_screen_size_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * * Delivers a request to the X server. - * + * */ /***************************************************************************** ** ** xcb_xinerama_is_active_cookie_t xcb_xinerama_is_active - ** + ** ** @param xcb_connection_t *c ** @returns xcb_xinerama_is_active_cookie_t ** *****************************************************************************/ - + xcb_xinerama_is_active_cookie_t xcb_xinerama_is_active (xcb_connection_t *c /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * * Delivers a request to the X server. - * + * * This form can be used only if the request will cause * a reply to be generated. Any returned error will be * placed in the event queue. @@ -641,12 +641,12 @@ xcb_xinerama_is_active (xcb_connection_t *c /**< */); /***************************************************************************** ** ** xcb_xinerama_is_active_cookie_t xcb_xinerama_is_active_unchecked - ** + ** ** @param xcb_connection_t *c ** @returns xcb_xinerama_is_active_cookie_t ** *****************************************************************************/ - + xcb_xinerama_is_active_cookie_t xcb_xinerama_is_active_unchecked (xcb_connection_t *c /**< */); @@ -657,7 +657,7 @@ xcb_xinerama_is_active_unchecked (xcb_connection_t *c /**< */); * @param e The xcb_generic_error_t supplied * * Returns the reply of the request asked by - * + * * The parameter @p e supplied to this function must be NULL if * xcb_xinerama_is_active_unchecked(). is used. * Otherwise, it stores the error if any. @@ -668,47 +668,50 @@ xcb_xinerama_is_active_unchecked (xcb_connection_t *c /**< */); /***************************************************************************** ** ** xcb_xinerama_is_active_reply_t * xcb_xinerama_is_active_reply - ** + ** ** @param xcb_connection_t *c ** @param xcb_xinerama_is_active_cookie_t cookie ** @param xcb_generic_error_t **e ** @returns xcb_xinerama_is_active_reply_t * ** *****************************************************************************/ - + xcb_xinerama_is_active_reply_t * xcb_xinerama_is_active_reply (xcb_connection_t *c /**< */, xcb_xinerama_is_active_cookie_t cookie /**< */, xcb_generic_error_t **e /**< */); +int +xcb_xinerama_query_screens_sizeof (const void *_buffer /**< */); + /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * * Delivers a request to the X server. - * + * */ /***************************************************************************** ** ** xcb_xinerama_query_screens_cookie_t xcb_xinerama_query_screens - ** + ** ** @param xcb_connection_t *c ** @returns xcb_xinerama_query_screens_cookie_t ** *****************************************************************************/ - + xcb_xinerama_query_screens_cookie_t xcb_xinerama_query_screens (xcb_connection_t *c /**< */); /** - * Delivers a request to the X server + * * @param c The connection * @return A cookie * * Delivers a request to the X server. - * + * * This form can be used only if the request will cause * a reply to be generated. Any returned error will be * placed in the event queue. @@ -717,12 +720,12 @@ xcb_xinerama_query_screens (xcb_connection_t *c /**< */); /***************************************************************************** ** ** xcb_xinerama_query_screens_cookie_t xcb_xinerama_query_screens_unchecked - ** + ** ** @param xcb_connection_t *c ** @returns xcb_xinerama_query_screens_cookie_t ** *****************************************************************************/ - + xcb_xinerama_query_screens_cookie_t xcb_xinerama_query_screens_unchecked (xcb_connection_t *c /**< */); @@ -730,12 +733,12 @@ xcb_xinerama_query_screens_unchecked (xcb_connection_t *c /**< */); /***************************************************************************** ** ** xcb_xinerama_screen_info_t * xcb_xinerama_query_screens_screen_info - ** + ** ** @param const xcb_xinerama_query_screens_reply_t *R ** @returns xcb_xinerama_screen_info_t * ** *****************************************************************************/ - + xcb_xinerama_screen_info_t * xcb_xinerama_query_screens_screen_info (const xcb_xinerama_query_screens_reply_t *R /**< */); @@ -743,12 +746,12 @@ xcb_xinerama_query_screens_screen_info (const xcb_xinerama_query_screens_reply_t /***************************************************************************** ** ** int xcb_xinerama_query_screens_screen_info_length - ** + ** ** @param const xcb_xinerama_query_screens_reply_t *R ** @returns int ** *****************************************************************************/ - + int xcb_xinerama_query_screens_screen_info_length (const xcb_xinerama_query_screens_reply_t *R /**< */); @@ -756,12 +759,12 @@ xcb_xinerama_query_screens_screen_info_length (const xcb_xinerama_query_screens_ /***************************************************************************** ** ** xcb_xinerama_screen_info_iterator_t xcb_xinerama_query_screens_screen_info_iterator - ** + ** ** @param const xcb_xinerama_query_screens_reply_t *R ** @returns xcb_xinerama_screen_info_iterator_t ** *****************************************************************************/ - + xcb_xinerama_screen_info_iterator_t xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screens_reply_t *R /**< */); @@ -772,7 +775,7 @@ xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screen * @param e The xcb_generic_error_t supplied * * Returns the reply of the request asked by - * + * * The parameter @p e supplied to this function must be NULL if * xcb_xinerama_query_screens_unchecked(). is used. * Otherwise, it stores the error if any. @@ -783,14 +786,14 @@ xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screen /***************************************************************************** ** ** xcb_xinerama_query_screens_reply_t * xcb_xinerama_query_screens_reply - ** + ** ** @param xcb_connection_t *c ** @param xcb_xinerama_query_screens_cookie_t cookie ** @param xcb_generic_error_t **e ** @returns xcb_xinerama_query_screens_reply_t * ** *****************************************************************************/ - + xcb_xinerama_query_screens_reply_t * xcb_xinerama_query_screens_reply (xcb_connection_t *c /**< */, xcb_xinerama_query_screens_cookie_t cookie /**< */, diff --git a/src/3rdparty/xcb/include/xcb/xinput.h b/src/3rdparty/xcb/include/xcb/xinput.h new file mode 100644 index 0000000000..9420047c71 --- /dev/null +++ b/src/3rdparty/xcb/include/xcb/xinput.h @@ -0,0 +1,9306 @@ +/* + * This file generated automatically from xinput.xml by c_client.py. + * Edit at your peril. + */ + +/** + * @defgroup XCB_Input_API XCB Input API + * @brief Input XCB Protocol Implementation. + * @{ + **/ + +#ifndef __XINPUT_H +#define __XINPUT_H + +#include "xcb.h" +#include "xfixes.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define XCB_INPUT_MAJOR_VERSION 2 +#define XCB_INPUT_MINOR_VERSION 3 + +extern xcb_extension_t xcb_input_id; + +typedef uint32_t xcb_input_event_class_t; + +/** + * @brief xcb_input_event_class_iterator_t + **/ +typedef struct xcb_input_event_class_iterator_t { + xcb_input_event_class_t *data; + int rem; + int index; +} xcb_input_event_class_iterator_t; + +typedef uint8_t xcb_input_key_code_t; + +/** + * @brief xcb_input_key_code_iterator_t + **/ +typedef struct xcb_input_key_code_iterator_t { + xcb_input_key_code_t *data; + int rem; + int index; +} xcb_input_key_code_iterator_t; + +typedef uint16_t xcb_input_device_id_t; + +/** + * @brief xcb_input_device_id_iterator_t + **/ +typedef struct xcb_input_device_id_iterator_t { + xcb_input_device_id_t *data; + int rem; + int index; +} xcb_input_device_id_iterator_t; + +typedef int32_t xcb_input_fp1616_t; + +/** + * @brief xcb_input_fp1616_iterator_t + **/ +typedef struct xcb_input_fp1616_iterator_t { + xcb_input_fp1616_t *data; + int rem; + int index; +} xcb_input_fp1616_iterator_t; + +/** + * @brief xcb_input_fp3232_t + **/ +typedef struct xcb_input_fp3232_t { + int32_t integral; + uint32_t frac; +} xcb_input_fp3232_t; + +/** + * @brief xcb_input_fp3232_iterator_t + **/ +typedef struct xcb_input_fp3232_iterator_t { + xcb_input_fp3232_t *data; + int rem; + int index; +} xcb_input_fp3232_iterator_t; + +/** + * @brief xcb_input_get_extension_version_cookie_t + **/ +typedef struct xcb_input_get_extension_version_cookie_t { + unsigned int sequence; +} xcb_input_get_extension_version_cookie_t; + +/** Opcode for xcb_input_get_extension_version. */ +#define XCB_INPUT_GET_EXTENSION_VERSION 1 + +/** + * @brief xcb_input_get_extension_version_request_t + **/ +typedef struct xcb_input_get_extension_version_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t name_len; + uint8_t pad0[2]; +} xcb_input_get_extension_version_request_t; + +/** + * @brief xcb_input_get_extension_version_reply_t + **/ +typedef struct xcb_input_get_extension_version_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint16_t server_major; + uint16_t server_minor; + uint8_t present; + uint8_t pad0[19]; +} xcb_input_get_extension_version_reply_t; + +typedef enum xcb_input_device_use_t { + XCB_INPUT_DEVICE_USE_IS_X_POINTER = 0, + XCB_INPUT_DEVICE_USE_IS_X_KEYBOARD = 1, + XCB_INPUT_DEVICE_USE_IS_X_EXTENSION_DEVICE = 2, + XCB_INPUT_DEVICE_USE_IS_X_EXTENSION_KEYBOARD = 3, + XCB_INPUT_DEVICE_USE_IS_X_EXTENSION_POINTER = 4 +} xcb_input_device_use_t; + +typedef enum xcb_input_input_class_t { + XCB_INPUT_INPUT_CLASS_KEY = 0, + XCB_INPUT_INPUT_CLASS_BUTTON = 1, + XCB_INPUT_INPUT_CLASS_VALUATOR = 2, + XCB_INPUT_INPUT_CLASS_FEEDBACK = 3, + XCB_INPUT_INPUT_CLASS_PROXIMITY = 4, + XCB_INPUT_INPUT_CLASS_FOCUS = 5, + XCB_INPUT_INPUT_CLASS_OTHER = 6 +} xcb_input_input_class_t; + +typedef enum xcb_input_valuator_mode_t { + XCB_INPUT_VALUATOR_MODE_RELATIVE = 0, + XCB_INPUT_VALUATOR_MODE_ABSOLUTE = 1 +} xcb_input_valuator_mode_t; + +/** + * @brief xcb_input_device_info_t + **/ +typedef struct xcb_input_device_info_t { + xcb_atom_t device_type; + uint8_t device_id; + uint8_t num_class_info; + uint8_t device_use; + uint8_t pad0; +} xcb_input_device_info_t; + +/** + * @brief xcb_input_device_info_iterator_t + **/ +typedef struct xcb_input_device_info_iterator_t { + xcb_input_device_info_t *data; + int rem; + int index; +} xcb_input_device_info_iterator_t; + +/** + * @brief xcb_input_key_info_t + **/ +typedef struct xcb_input_key_info_t { + uint8_t class_id; + uint8_t len; + xcb_input_key_code_t min_keycode; + xcb_input_key_code_t max_keycode; + uint16_t num_keys; + uint8_t pad0[2]; +} xcb_input_key_info_t; + +/** + * @brief xcb_input_key_info_iterator_t + **/ +typedef struct xcb_input_key_info_iterator_t { + xcb_input_key_info_t *data; + int rem; + int index; +} xcb_input_key_info_iterator_t; + +/** + * @brief xcb_input_button_info_t + **/ +typedef struct xcb_input_button_info_t { + uint8_t class_id; + uint8_t len; + uint16_t num_buttons; +} xcb_input_button_info_t; + +/** + * @brief xcb_input_button_info_iterator_t + **/ +typedef struct xcb_input_button_info_iterator_t { + xcb_input_button_info_t *data; + int rem; + int index; +} xcb_input_button_info_iterator_t; + +/** + * @brief xcb_input_axis_info_t + **/ +typedef struct xcb_input_axis_info_t { + uint32_t resolution; + int32_t minimum; + int32_t maximum; +} xcb_input_axis_info_t; + +/** + * @brief xcb_input_axis_info_iterator_t + **/ +typedef struct xcb_input_axis_info_iterator_t { + xcb_input_axis_info_t *data; + int rem; + int index; +} xcb_input_axis_info_iterator_t; + +/** + * @brief xcb_input_valuator_info_t + **/ +typedef struct xcb_input_valuator_info_t { + uint8_t class_id; + uint8_t len; + uint8_t axes_len; + uint8_t mode; + uint32_t motion_size; +} xcb_input_valuator_info_t; + +/** + * @brief xcb_input_valuator_info_iterator_t + **/ +typedef struct xcb_input_valuator_info_iterator_t { + xcb_input_valuator_info_t *data; + int rem; + int index; +} xcb_input_valuator_info_iterator_t; + +/** + * @brief xcb_input_input_info_info_t + **/ +typedef struct xcb_input_input_info_info_t { + struct { + xcb_input_key_code_t min_keycode; + xcb_input_key_code_t max_keycode; + uint16_t num_keys; + uint8_t pad0[2]; + } key; + struct { + uint16_t num_buttons; + } button; + struct { + uint8_t axes_len; + uint8_t mode; + uint32_t motion_size; + xcb_input_axis_info_t *axes; + } valuator; +} xcb_input_input_info_info_t; + +/** + * @brief xcb_input_input_info_t + **/ +typedef struct xcb_input_input_info_t { + uint8_t class_id; + uint8_t len; +} xcb_input_input_info_t; + +void * +xcb_input_input_info_info (const xcb_input_input_info_t *R); + +/** + * @brief xcb_input_input_info_iterator_t + **/ +typedef struct xcb_input_input_info_iterator_t { + xcb_input_input_info_t *data; + int rem; + int index; +} xcb_input_input_info_iterator_t; + +/** + * @brief xcb_input_device_name_t + **/ +typedef struct xcb_input_device_name_t { + uint8_t len; +} xcb_input_device_name_t; + +/** + * @brief xcb_input_device_name_iterator_t + **/ +typedef struct xcb_input_device_name_iterator_t { + xcb_input_device_name_t *data; + int rem; + int index; +} xcb_input_device_name_iterator_t; + +/** + * @brief xcb_input_list_input_devices_cookie_t + **/ +typedef struct xcb_input_list_input_devices_cookie_t { + unsigned int sequence; +} xcb_input_list_input_devices_cookie_t; + +/** Opcode for xcb_input_list_input_devices. */ +#define XCB_INPUT_LIST_INPUT_DEVICES 2 + +/** + * @brief xcb_input_list_input_devices_request_t + **/ +typedef struct xcb_input_list_input_devices_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; +} xcb_input_list_input_devices_request_t; + +/** + * @brief xcb_input_list_input_devices_reply_t + **/ +typedef struct xcb_input_list_input_devices_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t devices_len; + uint8_t pad0[23]; +} xcb_input_list_input_devices_reply_t; + +typedef uint8_t xcb_input_event_type_base_t; + +/** + * @brief xcb_input_event_type_base_iterator_t + **/ +typedef struct xcb_input_event_type_base_iterator_t { + xcb_input_event_type_base_t *data; + int rem; + int index; +} xcb_input_event_type_base_iterator_t; + +/** + * @brief xcb_input_input_class_info_t + **/ +typedef struct xcb_input_input_class_info_t { + uint8_t class_id; + xcb_input_event_type_base_t event_type_base; +} xcb_input_input_class_info_t; + +/** + * @brief xcb_input_input_class_info_iterator_t + **/ +typedef struct xcb_input_input_class_info_iterator_t { + xcb_input_input_class_info_t *data; + int rem; + int index; +} xcb_input_input_class_info_iterator_t; + +/** + * @brief xcb_input_open_device_cookie_t + **/ +typedef struct xcb_input_open_device_cookie_t { + unsigned int sequence; +} xcb_input_open_device_cookie_t; + +/** Opcode for xcb_input_open_device. */ +#define XCB_INPUT_OPEN_DEVICE 3 + +/** + * @brief xcb_input_open_device_request_t + **/ +typedef struct xcb_input_open_device_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; +} xcb_input_open_device_request_t; + +/** + * @brief xcb_input_open_device_reply_t + **/ +typedef struct xcb_input_open_device_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t num_classes; + uint8_t pad0[23]; +} xcb_input_open_device_reply_t; + +/** Opcode for xcb_input_close_device. */ +#define XCB_INPUT_CLOSE_DEVICE 4 + +/** + * @brief xcb_input_close_device_request_t + **/ +typedef struct xcb_input_close_device_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; +} xcb_input_close_device_request_t; + +/** + * @brief xcb_input_set_device_mode_cookie_t + **/ +typedef struct xcb_input_set_device_mode_cookie_t { + unsigned int sequence; +} xcb_input_set_device_mode_cookie_t; + +/** Opcode for xcb_input_set_device_mode. */ +#define XCB_INPUT_SET_DEVICE_MODE 5 + +/** + * @brief xcb_input_set_device_mode_request_t + **/ +typedef struct xcb_input_set_device_mode_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t mode; + uint8_t pad0[2]; +} xcb_input_set_device_mode_request_t; + +/** + * @brief xcb_input_set_device_mode_reply_t + **/ +typedef struct xcb_input_set_device_mode_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; +} xcb_input_set_device_mode_reply_t; + +/** Opcode for xcb_input_select_extension_event. */ +#define XCB_INPUT_SELECT_EXTENSION_EVENT 6 + +/** + * @brief xcb_input_select_extension_event_request_t + **/ +typedef struct xcb_input_select_extension_event_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint16_t num_classes; + uint8_t pad0[2]; +} xcb_input_select_extension_event_request_t; + +/** + * @brief xcb_input_get_selected_extension_events_cookie_t + **/ +typedef struct xcb_input_get_selected_extension_events_cookie_t { + unsigned int sequence; +} xcb_input_get_selected_extension_events_cookie_t; + +/** Opcode for xcb_input_get_selected_extension_events. */ +#define XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS 7 + +/** + * @brief xcb_input_get_selected_extension_events_request_t + **/ +typedef struct xcb_input_get_selected_extension_events_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; +} xcb_input_get_selected_extension_events_request_t; + +/** + * @brief xcb_input_get_selected_extension_events_reply_t + **/ +typedef struct xcb_input_get_selected_extension_events_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint16_t num_this_classes; + uint16_t num_all_classes; + uint8_t pad0[20]; +} xcb_input_get_selected_extension_events_reply_t; + +typedef enum xcb_input_propagate_mode_t { + XCB_INPUT_PROPAGATE_MODE_ADD_TO_LIST = 0, + XCB_INPUT_PROPAGATE_MODE_DELETE_FROM_LIST = 1 +} xcb_input_propagate_mode_t; + +/** Opcode for xcb_input_change_device_dont_propagate_list. */ +#define XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST 8 + +/** + * @brief xcb_input_change_device_dont_propagate_list_request_t + **/ +typedef struct xcb_input_change_device_dont_propagate_list_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint16_t num_classes; + uint8_t mode; + uint8_t pad0; +} xcb_input_change_device_dont_propagate_list_request_t; + +/** + * @brief xcb_input_get_device_dont_propagate_list_cookie_t + **/ +typedef struct xcb_input_get_device_dont_propagate_list_cookie_t { + unsigned int sequence; +} xcb_input_get_device_dont_propagate_list_cookie_t; + +/** Opcode for xcb_input_get_device_dont_propagate_list. */ +#define XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST 9 + +/** + * @brief xcb_input_get_device_dont_propagate_list_request_t + **/ +typedef struct xcb_input_get_device_dont_propagate_list_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; +} xcb_input_get_device_dont_propagate_list_request_t; + +/** + * @brief xcb_input_get_device_dont_propagate_list_reply_t + **/ +typedef struct xcb_input_get_device_dont_propagate_list_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint16_t num_classes; + uint8_t pad0[22]; +} xcb_input_get_device_dont_propagate_list_reply_t; + +/** + * @brief xcb_input_device_time_coord_t + **/ +typedef struct xcb_input_device_time_coord_t { + xcb_timestamp_t time; +} xcb_input_device_time_coord_t; + +/** + * @brief xcb_input_device_time_coord_iterator_t + **/ +typedef struct xcb_input_device_time_coord_iterator_t { + xcb_input_device_time_coord_t *data; + int rem; + int index; + uint8_t num_axes; /**< */ +} xcb_input_device_time_coord_iterator_t; + +/** + * @brief xcb_input_get_device_motion_events_cookie_t + **/ +typedef struct xcb_input_get_device_motion_events_cookie_t { + unsigned int sequence; +} xcb_input_get_device_motion_events_cookie_t; + +/** Opcode for xcb_input_get_device_motion_events. */ +#define XCB_INPUT_GET_DEVICE_MOTION_EVENTS 10 + +/** + * @brief xcb_input_get_device_motion_events_request_t + **/ +typedef struct xcb_input_get_device_motion_events_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_timestamp_t start; + xcb_timestamp_t stop; + uint8_t device_id; + uint8_t pad0[3]; +} xcb_input_get_device_motion_events_request_t; + +/** + * @brief xcb_input_get_device_motion_events_reply_t + **/ +typedef struct xcb_input_get_device_motion_events_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint32_t num_events; + uint8_t num_axes; + uint8_t device_mode; + uint8_t pad0[18]; +} xcb_input_get_device_motion_events_reply_t; + +/** + * @brief xcb_input_change_keyboard_device_cookie_t + **/ +typedef struct xcb_input_change_keyboard_device_cookie_t { + unsigned int sequence; +} xcb_input_change_keyboard_device_cookie_t; + +/** Opcode for xcb_input_change_keyboard_device. */ +#define XCB_INPUT_CHANGE_KEYBOARD_DEVICE 11 + +/** + * @brief xcb_input_change_keyboard_device_request_t + **/ +typedef struct xcb_input_change_keyboard_device_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; +} xcb_input_change_keyboard_device_request_t; + +/** + * @brief xcb_input_change_keyboard_device_reply_t + **/ +typedef struct xcb_input_change_keyboard_device_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; +} xcb_input_change_keyboard_device_reply_t; + +/** + * @brief xcb_input_change_pointer_device_cookie_t + **/ +typedef struct xcb_input_change_pointer_device_cookie_t { + unsigned int sequence; +} xcb_input_change_pointer_device_cookie_t; + +/** Opcode for xcb_input_change_pointer_device. */ +#define XCB_INPUT_CHANGE_POINTER_DEVICE 12 + +/** + * @brief xcb_input_change_pointer_device_request_t + **/ +typedef struct xcb_input_change_pointer_device_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t x_axis; + uint8_t y_axis; + uint8_t device_id; + uint8_t pad0; +} xcb_input_change_pointer_device_request_t; + +/** + * @brief xcb_input_change_pointer_device_reply_t + **/ +typedef struct xcb_input_change_pointer_device_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; +} xcb_input_change_pointer_device_reply_t; + +/** + * @brief xcb_input_grab_device_cookie_t + **/ +typedef struct xcb_input_grab_device_cookie_t { + unsigned int sequence; +} xcb_input_grab_device_cookie_t; + +/** Opcode for xcb_input_grab_device. */ +#define XCB_INPUT_GRAB_DEVICE 13 + +/** + * @brief xcb_input_grab_device_request_t + **/ +typedef struct xcb_input_grab_device_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t grab_window; + xcb_timestamp_t time; + uint16_t num_classes; + uint8_t this_device_mode; + uint8_t other_device_mode; + uint8_t owner_events; + uint8_t device_id; + uint8_t pad0[2]; +} xcb_input_grab_device_request_t; + +/** + * @brief xcb_input_grab_device_reply_t + **/ +typedef struct xcb_input_grab_device_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; +} xcb_input_grab_device_reply_t; + +/** Opcode for xcb_input_ungrab_device. */ +#define XCB_INPUT_UNGRAB_DEVICE 14 + +/** + * @brief xcb_input_ungrab_device_request_t + **/ +typedef struct xcb_input_ungrab_device_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_timestamp_t time; + uint8_t device_id; + uint8_t pad0[3]; +} xcb_input_ungrab_device_request_t; + +typedef enum xcb_input_modifier_device_t { + XCB_INPUT_MODIFIER_DEVICE_USE_X_KEYBOARD = 255 +} xcb_input_modifier_device_t; + +/** Opcode for xcb_input_grab_device_key. */ +#define XCB_INPUT_GRAB_DEVICE_KEY 15 + +/** + * @brief xcb_input_grab_device_key_request_t + **/ +typedef struct xcb_input_grab_device_key_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t grab_window; + uint16_t num_classes; + uint16_t modifiers; + uint8_t modifier_device; + uint8_t grabbed_device; + uint8_t key; + uint8_t this_device_mode; + uint8_t other_device_mode; + uint8_t owner_events; + uint8_t pad0[2]; +} xcb_input_grab_device_key_request_t; + +/** Opcode for xcb_input_ungrab_device_key. */ +#define XCB_INPUT_UNGRAB_DEVICE_KEY 16 + +/** + * @brief xcb_input_ungrab_device_key_request_t + **/ +typedef struct xcb_input_ungrab_device_key_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t grabWindow; + uint16_t modifiers; + uint8_t modifier_device; + uint8_t key; + uint8_t grabbed_device; +} xcb_input_ungrab_device_key_request_t; + +/** Opcode for xcb_input_grab_device_button. */ +#define XCB_INPUT_GRAB_DEVICE_BUTTON 17 + +/** + * @brief xcb_input_grab_device_button_request_t + **/ +typedef struct xcb_input_grab_device_button_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t grab_window; + uint8_t grabbed_device; + uint8_t modifier_device; + uint16_t num_classes; + uint16_t modifiers; + uint8_t this_device_mode; + uint8_t other_device_mode; + uint8_t button; + uint8_t owner_events; + uint8_t pad0[2]; +} xcb_input_grab_device_button_request_t; + +/** Opcode for xcb_input_ungrab_device_button. */ +#define XCB_INPUT_UNGRAB_DEVICE_BUTTON 18 + +/** + * @brief xcb_input_ungrab_device_button_request_t + **/ +typedef struct xcb_input_ungrab_device_button_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t grab_window; + uint16_t modifiers; + uint8_t modifier_device; + uint8_t button; + uint8_t grabbed_device; + uint8_t pad0[3]; +} xcb_input_ungrab_device_button_request_t; + +typedef enum xcb_input_device_input_mode_t { + XCB_INPUT_DEVICE_INPUT_MODE_ASYNC_THIS_DEVICE = 0, + XCB_INPUT_DEVICE_INPUT_MODE_SYNC_THIS_DEVICE = 1, + XCB_INPUT_DEVICE_INPUT_MODE_REPLAY_THIS_DEVICE = 2, + XCB_INPUT_DEVICE_INPUT_MODE_ASYNC_OTHER_DEVICES = 3, + XCB_INPUT_DEVICE_INPUT_MODE_ASYNC_ALL = 4, + XCB_INPUT_DEVICE_INPUT_MODE_SYNC_ALL = 5 +} xcb_input_device_input_mode_t; + +/** Opcode for xcb_input_allow_device_events. */ +#define XCB_INPUT_ALLOW_DEVICE_EVENTS 19 + +/** + * @brief xcb_input_allow_device_events_request_t + **/ +typedef struct xcb_input_allow_device_events_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_timestamp_t time; + uint8_t mode; + uint8_t device_id; + uint8_t pad0[2]; +} xcb_input_allow_device_events_request_t; + +/** + * @brief xcb_input_get_device_focus_cookie_t + **/ +typedef struct xcb_input_get_device_focus_cookie_t { + unsigned int sequence; +} xcb_input_get_device_focus_cookie_t; + +/** Opcode for xcb_input_get_device_focus. */ +#define XCB_INPUT_GET_DEVICE_FOCUS 20 + +/** + * @brief xcb_input_get_device_focus_request_t + **/ +typedef struct xcb_input_get_device_focus_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; +} xcb_input_get_device_focus_request_t; + +/** + * @brief xcb_input_get_device_focus_reply_t + **/ +typedef struct xcb_input_get_device_focus_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + xcb_window_t focus; + xcb_timestamp_t time; + uint8_t revert_to; + uint8_t pad0[15]; +} xcb_input_get_device_focus_reply_t; + +/** Opcode for xcb_input_set_device_focus. */ +#define XCB_INPUT_SET_DEVICE_FOCUS 21 + +/** + * @brief xcb_input_set_device_focus_request_t + **/ +typedef struct xcb_input_set_device_focus_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t focus; + xcb_timestamp_t time; + uint8_t revert_to; + uint8_t device_id; + uint8_t pad0[2]; +} xcb_input_set_device_focus_request_t; + +typedef enum xcb_input_feedback_class_t { + XCB_INPUT_FEEDBACK_CLASS_KEYBOARD = 0, + XCB_INPUT_FEEDBACK_CLASS_POINTER = 1, + XCB_INPUT_FEEDBACK_CLASS_STRING = 2, + XCB_INPUT_FEEDBACK_CLASS_INTEGER = 3, + XCB_INPUT_FEEDBACK_CLASS_LED = 4, + XCB_INPUT_FEEDBACK_CLASS_BELL = 5 +} xcb_input_feedback_class_t; + +/** + * @brief xcb_input_kbd_feedback_state_t + **/ +typedef struct xcb_input_kbd_feedback_state_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint16_t pitch; + uint16_t duration; + uint32_t led_mask; + uint32_t led_values; + uint8_t global_auto_repeat; + uint8_t click; + uint8_t percent; + uint8_t pad0; + uint8_t auto_repeats[32]; +} xcb_input_kbd_feedback_state_t; + +/** + * @brief xcb_input_kbd_feedback_state_iterator_t + **/ +typedef struct xcb_input_kbd_feedback_state_iterator_t { + xcb_input_kbd_feedback_state_t *data; + int rem; + int index; +} xcb_input_kbd_feedback_state_iterator_t; + +/** + * @brief xcb_input_ptr_feedback_state_t + **/ +typedef struct xcb_input_ptr_feedback_state_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint8_t pad0[2]; + uint16_t accel_num; + uint16_t accel_denom; + uint16_t threshold; +} xcb_input_ptr_feedback_state_t; + +/** + * @brief xcb_input_ptr_feedback_state_iterator_t + **/ +typedef struct xcb_input_ptr_feedback_state_iterator_t { + xcb_input_ptr_feedback_state_t *data; + int rem; + int index; +} xcb_input_ptr_feedback_state_iterator_t; + +/** + * @brief xcb_input_integer_feedback_state_t + **/ +typedef struct xcb_input_integer_feedback_state_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint32_t resolution; + int32_t min_value; + int32_t max_value; +} xcb_input_integer_feedback_state_t; + +/** + * @brief xcb_input_integer_feedback_state_iterator_t + **/ +typedef struct xcb_input_integer_feedback_state_iterator_t { + xcb_input_integer_feedback_state_t *data; + int rem; + int index; +} xcb_input_integer_feedback_state_iterator_t; + +/** + * @brief xcb_input_string_feedback_state_t + **/ +typedef struct xcb_input_string_feedback_state_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint16_t max_symbols; + uint16_t num_keysyms; +} xcb_input_string_feedback_state_t; + +/** + * @brief xcb_input_string_feedback_state_iterator_t + **/ +typedef struct xcb_input_string_feedback_state_iterator_t { + xcb_input_string_feedback_state_t *data; + int rem; + int index; +} xcb_input_string_feedback_state_iterator_t; + +/** + * @brief xcb_input_bell_feedback_state_t + **/ +typedef struct xcb_input_bell_feedback_state_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint8_t percent; + uint8_t pad0[3]; + uint16_t pitch; + uint16_t duration; +} xcb_input_bell_feedback_state_t; + +/** + * @brief xcb_input_bell_feedback_state_iterator_t + **/ +typedef struct xcb_input_bell_feedback_state_iterator_t { + xcb_input_bell_feedback_state_t *data; + int rem; + int index; +} xcb_input_bell_feedback_state_iterator_t; + +/** + * @brief xcb_input_led_feedback_state_t + **/ +typedef struct xcb_input_led_feedback_state_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint32_t led_mask; + uint32_t led_values; +} xcb_input_led_feedback_state_t; + +/** + * @brief xcb_input_led_feedback_state_iterator_t + **/ +typedef struct xcb_input_led_feedback_state_iterator_t { + xcb_input_led_feedback_state_t *data; + int rem; + int index; +} xcb_input_led_feedback_state_iterator_t; + +/** + * @brief xcb_input_feedback_state_data_t + **/ +typedef struct xcb_input_feedback_state_data_t { + struct { + uint16_t pitch; + uint16_t duration; + uint32_t led_mask; + uint32_t led_values; + uint8_t global_auto_repeat; + uint8_t click; + uint8_t percent; + uint8_t pad0; + uint8_t auto_repeats[32]; + } keyboard; + struct { + uint8_t pad1[2]; + uint16_t accel_num; + uint16_t accel_denom; + uint16_t threshold; + } pointer; + struct { + uint16_t max_symbols; + uint16_t num_keysyms; + xcb_keysym_t *keysyms; + } string; + struct { + uint32_t resolution; + int32_t min_value; + int32_t max_value; + } integer; + struct { + uint32_t led_mask; + uint32_t led_values; + } led; + struct { + uint8_t percent; + uint8_t pad2[3]; + uint16_t pitch; + uint16_t duration; + } bell; +} xcb_input_feedback_state_data_t; + +/** + * @brief xcb_input_feedback_state_t + **/ +typedef struct xcb_input_feedback_state_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; +} xcb_input_feedback_state_t; + +void * +xcb_input_feedback_state_data (const xcb_input_feedback_state_t *R); + +/** + * @brief xcb_input_feedback_state_iterator_t + **/ +typedef struct xcb_input_feedback_state_iterator_t { + xcb_input_feedback_state_t *data; + int rem; + int index; +} xcb_input_feedback_state_iterator_t; + +/** + * @brief xcb_input_get_feedback_control_cookie_t + **/ +typedef struct xcb_input_get_feedback_control_cookie_t { + unsigned int sequence; +} xcb_input_get_feedback_control_cookie_t; + +/** Opcode for xcb_input_get_feedback_control. */ +#define XCB_INPUT_GET_FEEDBACK_CONTROL 22 + +/** + * @brief xcb_input_get_feedback_control_request_t + **/ +typedef struct xcb_input_get_feedback_control_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; +} xcb_input_get_feedback_control_request_t; + +/** + * @brief xcb_input_get_feedback_control_reply_t + **/ +typedef struct xcb_input_get_feedback_control_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint16_t num_feedbacks; + uint8_t pad0[22]; +} xcb_input_get_feedback_control_reply_t; + +/** + * @brief xcb_input_kbd_feedback_ctl_t + **/ +typedef struct xcb_input_kbd_feedback_ctl_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + xcb_input_key_code_t key; + uint8_t auto_repeat_mode; + int8_t key_click_percent; + int8_t bell_percent; + int16_t bell_pitch; + int16_t bell_duration; + uint32_t led_mask; + uint32_t led_values; +} xcb_input_kbd_feedback_ctl_t; + +/** + * @brief xcb_input_kbd_feedback_ctl_iterator_t + **/ +typedef struct xcb_input_kbd_feedback_ctl_iterator_t { + xcb_input_kbd_feedback_ctl_t *data; + int rem; + int index; +} xcb_input_kbd_feedback_ctl_iterator_t; + +/** + * @brief xcb_input_ptr_feedback_ctl_t + **/ +typedef struct xcb_input_ptr_feedback_ctl_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint8_t pad0[2]; + int16_t num; + int16_t denom; + int16_t threshold; +} xcb_input_ptr_feedback_ctl_t; + +/** + * @brief xcb_input_ptr_feedback_ctl_iterator_t + **/ +typedef struct xcb_input_ptr_feedback_ctl_iterator_t { + xcb_input_ptr_feedback_ctl_t *data; + int rem; + int index; +} xcb_input_ptr_feedback_ctl_iterator_t; + +/** + * @brief xcb_input_integer_feedback_ctl_t + **/ +typedef struct xcb_input_integer_feedback_ctl_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + int32_t int_to_display; +} xcb_input_integer_feedback_ctl_t; + +/** + * @brief xcb_input_integer_feedback_ctl_iterator_t + **/ +typedef struct xcb_input_integer_feedback_ctl_iterator_t { + xcb_input_integer_feedback_ctl_t *data; + int rem; + int index; +} xcb_input_integer_feedback_ctl_iterator_t; + +/** + * @brief xcb_input_string_feedback_ctl_t + **/ +typedef struct xcb_input_string_feedback_ctl_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint8_t pad0[2]; + uint16_t num_keysyms; +} xcb_input_string_feedback_ctl_t; + +/** + * @brief xcb_input_string_feedback_ctl_iterator_t + **/ +typedef struct xcb_input_string_feedback_ctl_iterator_t { + xcb_input_string_feedback_ctl_t *data; + int rem; + int index; +} xcb_input_string_feedback_ctl_iterator_t; + +/** + * @brief xcb_input_bell_feedback_ctl_t + **/ +typedef struct xcb_input_bell_feedback_ctl_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + int8_t percent; + uint8_t pad0[3]; + int16_t pitch; + int16_t duration; +} xcb_input_bell_feedback_ctl_t; + +/** + * @brief xcb_input_bell_feedback_ctl_iterator_t + **/ +typedef struct xcb_input_bell_feedback_ctl_iterator_t { + xcb_input_bell_feedback_ctl_t *data; + int rem; + int index; +} xcb_input_bell_feedback_ctl_iterator_t; + +/** + * @brief xcb_input_led_feedback_ctl_t + **/ +typedef struct xcb_input_led_feedback_ctl_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint32_t led_mask; + uint32_t led_values; +} xcb_input_led_feedback_ctl_t; + +/** + * @brief xcb_input_led_feedback_ctl_iterator_t + **/ +typedef struct xcb_input_led_feedback_ctl_iterator_t { + xcb_input_led_feedback_ctl_t *data; + int rem; + int index; +} xcb_input_led_feedback_ctl_iterator_t; + +/** + * @brief xcb_input_feedback_ctl_data_t + **/ +typedef struct xcb_input_feedback_ctl_data_t { + struct { + xcb_input_key_code_t key; + uint8_t auto_repeat_mode; + int8_t key_click_percent; + int8_t bell_percent; + int16_t bell_pitch; + int16_t bell_duration; + uint32_t led_mask; + uint32_t led_values; + } keyboard; + struct { + uint8_t pad0[2]; + int16_t num; + int16_t denom; + int16_t threshold; + } pointer; + struct { + uint8_t pad1[2]; + uint16_t num_keysyms; + xcb_keysym_t *keysyms; + } string; + struct { + int32_t int_to_display; + } integer; + struct { + uint32_t led_mask; + uint32_t led_values; + } led; + struct { + int8_t percent; + uint8_t pad2[3]; + int16_t pitch; + int16_t duration; + } bell; +} xcb_input_feedback_ctl_data_t; + +/** + * @brief xcb_input_feedback_ctl_t + **/ +typedef struct xcb_input_feedback_ctl_t { + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; +} xcb_input_feedback_ctl_t; + +void * +xcb_input_feedback_ctl_data (const xcb_input_feedback_ctl_t *R); + +/** + * @brief xcb_input_feedback_ctl_iterator_t + **/ +typedef struct xcb_input_feedback_ctl_iterator_t { + xcb_input_feedback_ctl_t *data; + int rem; + int index; +} xcb_input_feedback_ctl_iterator_t; + +typedef enum xcb_input_change_feedback_control_mask_t { + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_KEY_CLICK_PERCENT = 1, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_PERCENT = 2, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_PITCH = 4, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_DURATION = 8, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_LED = 16, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_LED_MODE = 32, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_KEY = 64, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_AUTO_REPEAT_MODE = 128, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_STRING = 1, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_INTEGER = 1, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_ACCEL_NUM = 1, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_ACCEL_DENOM = 2, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_THRESHOLD = 4 +} xcb_input_change_feedback_control_mask_t; + +/** Opcode for xcb_input_change_feedback_control. */ +#define XCB_INPUT_CHANGE_FEEDBACK_CONTROL 23 + +/** + * @brief xcb_input_change_feedback_control_request_t + **/ +typedef struct xcb_input_change_feedback_control_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t mask; + uint8_t device_id; + uint8_t feedback_id; + uint8_t pad0[2]; +} xcb_input_change_feedback_control_request_t; + +/** + * @brief xcb_input_get_device_key_mapping_cookie_t + **/ +typedef struct xcb_input_get_device_key_mapping_cookie_t { + unsigned int sequence; +} xcb_input_get_device_key_mapping_cookie_t; + +/** Opcode for xcb_input_get_device_key_mapping. */ +#define XCB_INPUT_GET_DEVICE_KEY_MAPPING 24 + +/** + * @brief xcb_input_get_device_key_mapping_request_t + **/ +typedef struct xcb_input_get_device_key_mapping_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + xcb_input_key_code_t first_keycode; + uint8_t count; + uint8_t pad0; +} xcb_input_get_device_key_mapping_request_t; + +/** + * @brief xcb_input_get_device_key_mapping_reply_t + **/ +typedef struct xcb_input_get_device_key_mapping_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t keysyms_per_keycode; + uint8_t pad0[23]; +} xcb_input_get_device_key_mapping_reply_t; + +/** Opcode for xcb_input_change_device_key_mapping. */ +#define XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING 25 + +/** + * @brief xcb_input_change_device_key_mapping_request_t + **/ +typedef struct xcb_input_change_device_key_mapping_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + xcb_input_key_code_t first_keycode; + uint8_t keysyms_per_keycode; + uint8_t keycode_count; +} xcb_input_change_device_key_mapping_request_t; + +/** + * @brief xcb_input_get_device_modifier_mapping_cookie_t + **/ +typedef struct xcb_input_get_device_modifier_mapping_cookie_t { + unsigned int sequence; +} xcb_input_get_device_modifier_mapping_cookie_t; + +/** Opcode for xcb_input_get_device_modifier_mapping. */ +#define XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING 26 + +/** + * @brief xcb_input_get_device_modifier_mapping_request_t + **/ +typedef struct xcb_input_get_device_modifier_mapping_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; +} xcb_input_get_device_modifier_mapping_request_t; + +/** + * @brief xcb_input_get_device_modifier_mapping_reply_t + **/ +typedef struct xcb_input_get_device_modifier_mapping_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t keycodes_per_modifier; + uint8_t pad0[23]; +} xcb_input_get_device_modifier_mapping_reply_t; + +/** + * @brief xcb_input_set_device_modifier_mapping_cookie_t + **/ +typedef struct xcb_input_set_device_modifier_mapping_cookie_t { + unsigned int sequence; +} xcb_input_set_device_modifier_mapping_cookie_t; + +/** Opcode for xcb_input_set_device_modifier_mapping. */ +#define XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING 27 + +/** + * @brief xcb_input_set_device_modifier_mapping_request_t + **/ +typedef struct xcb_input_set_device_modifier_mapping_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t keycodes_per_modifier; + uint8_t pad0[2]; +} xcb_input_set_device_modifier_mapping_request_t; + +/** + * @brief xcb_input_set_device_modifier_mapping_reply_t + **/ +typedef struct xcb_input_set_device_modifier_mapping_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; +} xcb_input_set_device_modifier_mapping_reply_t; + +/** + * @brief xcb_input_get_device_button_mapping_cookie_t + **/ +typedef struct xcb_input_get_device_button_mapping_cookie_t { + unsigned int sequence; +} xcb_input_get_device_button_mapping_cookie_t; + +/** Opcode for xcb_input_get_device_button_mapping. */ +#define XCB_INPUT_GET_DEVICE_BUTTON_MAPPING 28 + +/** + * @brief xcb_input_get_device_button_mapping_request_t + **/ +typedef struct xcb_input_get_device_button_mapping_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; +} xcb_input_get_device_button_mapping_request_t; + +/** + * @brief xcb_input_get_device_button_mapping_reply_t + **/ +typedef struct xcb_input_get_device_button_mapping_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t map_size; + uint8_t pad0[23]; +} xcb_input_get_device_button_mapping_reply_t; + +/** + * @brief xcb_input_set_device_button_mapping_cookie_t + **/ +typedef struct xcb_input_set_device_button_mapping_cookie_t { + unsigned int sequence; +} xcb_input_set_device_button_mapping_cookie_t; + +/** Opcode for xcb_input_set_device_button_mapping. */ +#define XCB_INPUT_SET_DEVICE_BUTTON_MAPPING 29 + +/** + * @brief xcb_input_set_device_button_mapping_request_t + **/ +typedef struct xcb_input_set_device_button_mapping_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t map_size; + uint8_t pad0[2]; +} xcb_input_set_device_button_mapping_request_t; + +/** + * @brief xcb_input_set_device_button_mapping_reply_t + **/ +typedef struct xcb_input_set_device_button_mapping_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; +} xcb_input_set_device_button_mapping_reply_t; + +/** + * @brief xcb_input_key_state_t + **/ +typedef struct xcb_input_key_state_t { + uint8_t class_id; + uint8_t len; + uint8_t num_keys; + uint8_t pad0; + uint8_t keys[32]; +} xcb_input_key_state_t; + +/** + * @brief xcb_input_key_state_iterator_t + **/ +typedef struct xcb_input_key_state_iterator_t { + xcb_input_key_state_t *data; + int rem; + int index; +} xcb_input_key_state_iterator_t; + +/** + * @brief xcb_input_button_state_t + **/ +typedef struct xcb_input_button_state_t { + uint8_t class_id; + uint8_t len; + uint8_t num_buttons; + uint8_t pad0; + uint8_t buttons[32]; +} xcb_input_button_state_t; + +/** + * @brief xcb_input_button_state_iterator_t + **/ +typedef struct xcb_input_button_state_iterator_t { + xcb_input_button_state_t *data; + int rem; + int index; +} xcb_input_button_state_iterator_t; + +typedef enum xcb_input_valuator_state_mode_mask_t { + XCB_INPUT_VALUATOR_STATE_MODE_MASK_DEVICE_MODE_ABSOLUTE = 1, + XCB_INPUT_VALUATOR_STATE_MODE_MASK_OUT_OF_PROXIMITY = 2 +} xcb_input_valuator_state_mode_mask_t; + +/** + * @brief xcb_input_valuator_state_t + **/ +typedef struct xcb_input_valuator_state_t { + uint8_t class_id; + uint8_t len; + uint8_t num_valuators; + uint8_t mode; +} xcb_input_valuator_state_t; + +/** + * @brief xcb_input_valuator_state_iterator_t + **/ +typedef struct xcb_input_valuator_state_iterator_t { + xcb_input_valuator_state_t *data; + int rem; + int index; +} xcb_input_valuator_state_iterator_t; + +/** + * @brief xcb_input_input_state_data_t + **/ +typedef struct xcb_input_input_state_data_t { + struct { + uint8_t num_keys; + uint8_t pad0; + uint8_t keys[32]; + } key; + struct { + uint8_t num_buttons; + uint8_t pad1; + uint8_t buttons[32]; + } button; + struct { + uint8_t num_valuators; + uint8_t mode; + int32_t *valuators; + } valuator; +} xcb_input_input_state_data_t; + +/** + * @brief xcb_input_input_state_t + **/ +typedef struct xcb_input_input_state_t { + uint8_t class_id; + uint8_t len; +} xcb_input_input_state_t; + +void * +xcb_input_input_state_data (const xcb_input_input_state_t *R); + +/** + * @brief xcb_input_input_state_iterator_t + **/ +typedef struct xcb_input_input_state_iterator_t { + xcb_input_input_state_t *data; + int rem; + int index; +} xcb_input_input_state_iterator_t; + +/** + * @brief xcb_input_query_device_state_cookie_t + **/ +typedef struct xcb_input_query_device_state_cookie_t { + unsigned int sequence; +} xcb_input_query_device_state_cookie_t; + +/** Opcode for xcb_input_query_device_state. */ +#define XCB_INPUT_QUERY_DEVICE_STATE 30 + +/** + * @brief xcb_input_query_device_state_request_t + **/ +typedef struct xcb_input_query_device_state_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; +} xcb_input_query_device_state_request_t; + +/** + * @brief xcb_input_query_device_state_reply_t + **/ +typedef struct xcb_input_query_device_state_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t num_classes; + uint8_t pad0[23]; +} xcb_input_query_device_state_reply_t; + +/** Opcode for xcb_input_device_bell. */ +#define XCB_INPUT_DEVICE_BELL 32 + +/** + * @brief xcb_input_device_bell_request_t + **/ +typedef struct xcb_input_device_bell_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t feedback_id; + uint8_t feedback_class; + int8_t percent; +} xcb_input_device_bell_request_t; + +/** + * @brief xcb_input_set_device_valuators_cookie_t + **/ +typedef struct xcb_input_set_device_valuators_cookie_t { + unsigned int sequence; +} xcb_input_set_device_valuators_cookie_t; + +/** Opcode for xcb_input_set_device_valuators. */ +#define XCB_INPUT_SET_DEVICE_VALUATORS 33 + +/** + * @brief xcb_input_set_device_valuators_request_t + **/ +typedef struct xcb_input_set_device_valuators_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t first_valuator; + uint8_t num_valuators; + uint8_t pad0; +} xcb_input_set_device_valuators_request_t; + +/** + * @brief xcb_input_set_device_valuators_reply_t + **/ +typedef struct xcb_input_set_device_valuators_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; +} xcb_input_set_device_valuators_reply_t; + +typedef enum xcb_input_device_control_t { + XCB_INPUT_DEVICE_CONTROL_RESOLUTION = 1, + XCB_INPUT_DEVICE_CONTROL_ABS_CALIB = 2, + XCB_INPUT_DEVICE_CONTROL_CORE = 3, + XCB_INPUT_DEVICE_CONTROL_ENABLE = 4, + XCB_INPUT_DEVICE_CONTROL_ABS_AREA = 5 +} xcb_input_device_control_t; + +/** + * @brief xcb_input_device_resolution_state_t + **/ +typedef struct xcb_input_device_resolution_state_t { + uint16_t control_id; + uint16_t len; + uint32_t num_valuators; +} xcb_input_device_resolution_state_t; + +/** + * @brief xcb_input_device_resolution_state_iterator_t + **/ +typedef struct xcb_input_device_resolution_state_iterator_t { + xcb_input_device_resolution_state_t *data; + int rem; + int index; +} xcb_input_device_resolution_state_iterator_t; + +/** + * @brief xcb_input_device_abs_calib_state_t + **/ +typedef struct xcb_input_device_abs_calib_state_t { + uint16_t control_id; + uint16_t len; + int32_t min_x; + int32_t max_x; + int32_t min_y; + int32_t max_y; + uint32_t flip_x; + uint32_t flip_y; + uint32_t rotation; + uint32_t button_threshold; +} xcb_input_device_abs_calib_state_t; + +/** + * @brief xcb_input_device_abs_calib_state_iterator_t + **/ +typedef struct xcb_input_device_abs_calib_state_iterator_t { + xcb_input_device_abs_calib_state_t *data; + int rem; + int index; +} xcb_input_device_abs_calib_state_iterator_t; + +/** + * @brief xcb_input_device_abs_area_state_t + **/ +typedef struct xcb_input_device_abs_area_state_t { + uint16_t control_id; + uint16_t len; + uint32_t offset_x; + uint32_t offset_y; + uint32_t width; + uint32_t height; + uint32_t screen; + uint32_t following; +} xcb_input_device_abs_area_state_t; + +/** + * @brief xcb_input_device_abs_area_state_iterator_t + **/ +typedef struct xcb_input_device_abs_area_state_iterator_t { + xcb_input_device_abs_area_state_t *data; + int rem; + int index; +} xcb_input_device_abs_area_state_iterator_t; + +/** + * @brief xcb_input_device_core_state_t + **/ +typedef struct xcb_input_device_core_state_t { + uint16_t control_id; + uint16_t len; + uint8_t status; + uint8_t iscore; + uint8_t pad0[2]; +} xcb_input_device_core_state_t; + +/** + * @brief xcb_input_device_core_state_iterator_t + **/ +typedef struct xcb_input_device_core_state_iterator_t { + xcb_input_device_core_state_t *data; + int rem; + int index; +} xcb_input_device_core_state_iterator_t; + +/** + * @brief xcb_input_device_enable_state_t + **/ +typedef struct xcb_input_device_enable_state_t { + uint16_t control_id; + uint16_t len; + uint8_t enable; + uint8_t pad0[3]; +} xcb_input_device_enable_state_t; + +/** + * @brief xcb_input_device_enable_state_iterator_t + **/ +typedef struct xcb_input_device_enable_state_iterator_t { + xcb_input_device_enable_state_t *data; + int rem; + int index; +} xcb_input_device_enable_state_iterator_t; + +/** + * @brief xcb_input_device_state_data_t + **/ +typedef struct xcb_input_device_state_data_t { + struct { + uint32_t num_valuators; + uint32_t *resolution_values; + uint32_t *resolution_min; + uint32_t *resolution_max; + } resolution; + struct { + int32_t min_x; + int32_t max_x; + int32_t min_y; + int32_t max_y; + uint32_t flip_x; + uint32_t flip_y; + uint32_t rotation; + uint32_t button_threshold; + } abs_calib; + struct { + uint8_t status; + uint8_t iscore; + uint8_t pad0[2]; + } core; + struct { + uint8_t enable; + uint8_t pad1[3]; + } enable; + struct { + uint32_t offset_x; + uint32_t offset_y; + uint32_t width; + uint32_t height; + uint32_t screen; + uint32_t following; + } abs_area; +} xcb_input_device_state_data_t; + +/** + * @brief xcb_input_device_state_t + **/ +typedef struct xcb_input_device_state_t { + uint16_t control_id; + uint16_t len; +} xcb_input_device_state_t; + +void * +xcb_input_device_state_data (const xcb_input_device_state_t *R); + +/** + * @brief xcb_input_device_state_iterator_t + **/ +typedef struct xcb_input_device_state_iterator_t { + xcb_input_device_state_t *data; + int rem; + int index; +} xcb_input_device_state_iterator_t; + +/** + * @brief xcb_input_get_device_control_cookie_t + **/ +typedef struct xcb_input_get_device_control_cookie_t { + unsigned int sequence; +} xcb_input_get_device_control_cookie_t; + +/** Opcode for xcb_input_get_device_control. */ +#define XCB_INPUT_GET_DEVICE_CONTROL 34 + +/** + * @brief xcb_input_get_device_control_request_t + **/ +typedef struct xcb_input_get_device_control_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t control_id; + uint8_t device_id; + uint8_t pad0; +} xcb_input_get_device_control_request_t; + +/** + * @brief xcb_input_get_device_control_reply_t + **/ +typedef struct xcb_input_get_device_control_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; +} xcb_input_get_device_control_reply_t; + +/** + * @brief xcb_input_device_resolution_ctl_t + **/ +typedef struct xcb_input_device_resolution_ctl_t { + uint16_t control_id; + uint16_t len; + uint8_t first_valuator; + uint8_t num_valuators; + uint8_t pad0[2]; +} xcb_input_device_resolution_ctl_t; + +/** + * @brief xcb_input_device_resolution_ctl_iterator_t + **/ +typedef struct xcb_input_device_resolution_ctl_iterator_t { + xcb_input_device_resolution_ctl_t *data; + int rem; + int index; +} xcb_input_device_resolution_ctl_iterator_t; + +/** + * @brief xcb_input_device_abs_calib_ctl_t + **/ +typedef struct xcb_input_device_abs_calib_ctl_t { + uint16_t control_id; + uint16_t len; + int32_t min_x; + int32_t max_x; + int32_t min_y; + int32_t max_y; + uint32_t flip_x; + uint32_t flip_y; + uint32_t rotation; + uint32_t button_threshold; +} xcb_input_device_abs_calib_ctl_t; + +/** + * @brief xcb_input_device_abs_calib_ctl_iterator_t + **/ +typedef struct xcb_input_device_abs_calib_ctl_iterator_t { + xcb_input_device_abs_calib_ctl_t *data; + int rem; + int index; +} xcb_input_device_abs_calib_ctl_iterator_t; + +/** + * @brief xcb_input_device_abs_area_ctrl_t + **/ +typedef struct xcb_input_device_abs_area_ctrl_t { + uint16_t control_id; + uint16_t len; + uint32_t offset_x; + uint32_t offset_y; + int32_t width; + int32_t height; + int32_t screen; + uint32_t following; +} xcb_input_device_abs_area_ctrl_t; + +/** + * @brief xcb_input_device_abs_area_ctrl_iterator_t + **/ +typedef struct xcb_input_device_abs_area_ctrl_iterator_t { + xcb_input_device_abs_area_ctrl_t *data; + int rem; + int index; +} xcb_input_device_abs_area_ctrl_iterator_t; + +/** + * @brief xcb_input_device_core_ctrl_t + **/ +typedef struct xcb_input_device_core_ctrl_t { + uint16_t control_id; + uint16_t len; + uint8_t status; + uint8_t pad0[3]; +} xcb_input_device_core_ctrl_t; + +/** + * @brief xcb_input_device_core_ctrl_iterator_t + **/ +typedef struct xcb_input_device_core_ctrl_iterator_t { + xcb_input_device_core_ctrl_t *data; + int rem; + int index; +} xcb_input_device_core_ctrl_iterator_t; + +/** + * @brief xcb_input_device_enable_ctrl_t + **/ +typedef struct xcb_input_device_enable_ctrl_t { + uint16_t control_id; + uint16_t len; + uint8_t enable; + uint8_t pad0[3]; +} xcb_input_device_enable_ctrl_t; + +/** + * @brief xcb_input_device_enable_ctrl_iterator_t + **/ +typedef struct xcb_input_device_enable_ctrl_iterator_t { + xcb_input_device_enable_ctrl_t *data; + int rem; + int index; +} xcb_input_device_enable_ctrl_iterator_t; + +/** + * @brief xcb_input_device_ctl_data_t + **/ +typedef struct xcb_input_device_ctl_data_t { + struct { + uint8_t first_valuator; + uint8_t num_valuators; + uint8_t pad0[2]; + uint32_t *resolution_values; + } resolution; + struct { + int32_t min_x; + int32_t max_x; + int32_t min_y; + int32_t max_y; + uint32_t flip_x; + uint32_t flip_y; + uint32_t rotation; + uint32_t button_threshold; + } abs_calib; + struct { + uint8_t status; + uint8_t pad1[3]; + } core; + struct { + uint8_t enable; + uint8_t pad2[3]; + } enable; + struct { + uint32_t offset_x; + uint32_t offset_y; + int32_t width; + int32_t height; + int32_t screen; + uint32_t following; + } abs_area; +} xcb_input_device_ctl_data_t; + +/** + * @brief xcb_input_device_ctl_t + **/ +typedef struct xcb_input_device_ctl_t { + uint16_t control_id; + uint16_t len; +} xcb_input_device_ctl_t; + +void * +xcb_input_device_ctl_data (const xcb_input_device_ctl_t *R); + +/** + * @brief xcb_input_device_ctl_iterator_t + **/ +typedef struct xcb_input_device_ctl_iterator_t { + xcb_input_device_ctl_t *data; + int rem; + int index; +} xcb_input_device_ctl_iterator_t; + +/** + * @brief xcb_input_change_device_control_cookie_t + **/ +typedef struct xcb_input_change_device_control_cookie_t { + unsigned int sequence; +} xcb_input_change_device_control_cookie_t; + +/** Opcode for xcb_input_change_device_control. */ +#define XCB_INPUT_CHANGE_DEVICE_CONTROL 35 + +/** + * @brief xcb_input_change_device_control_request_t + **/ +typedef struct xcb_input_change_device_control_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t control_id; + uint8_t device_id; + uint8_t pad0; +} xcb_input_change_device_control_request_t; + +/** + * @brief xcb_input_change_device_control_reply_t + **/ +typedef struct xcb_input_change_device_control_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; +} xcb_input_change_device_control_reply_t; + +/** + * @brief xcb_input_list_device_properties_cookie_t + **/ +typedef struct xcb_input_list_device_properties_cookie_t { + unsigned int sequence; +} xcb_input_list_device_properties_cookie_t; + +/** Opcode for xcb_input_list_device_properties. */ +#define XCB_INPUT_LIST_DEVICE_PROPERTIES 36 + +/** + * @brief xcb_input_list_device_properties_request_t + **/ +typedef struct xcb_input_list_device_properties_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; +} xcb_input_list_device_properties_request_t; + +/** + * @brief xcb_input_list_device_properties_reply_t + **/ +typedef struct xcb_input_list_device_properties_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint16_t num_atoms; + uint8_t pad0[22]; +} xcb_input_list_device_properties_reply_t; + +typedef enum xcb_input_property_format_t { + XCB_INPUT_PROPERTY_FORMAT_8_BITS = 8, + XCB_INPUT_PROPERTY_FORMAT_16_BITS = 16, + XCB_INPUT_PROPERTY_FORMAT_32_BITS = 32 +} xcb_input_property_format_t; + +/** + * @brief xcb_input_change_device_property_items_t + **/ +typedef struct xcb_input_change_device_property_items_t { + uint8_t *data8; + uint16_t *data16; + uint32_t *data32; +} xcb_input_change_device_property_items_t; + +/** Opcode for xcb_input_change_device_property. */ +#define XCB_INPUT_CHANGE_DEVICE_PROPERTY 37 + +/** + * @brief xcb_input_change_device_property_request_t + **/ +typedef struct xcb_input_change_device_property_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_atom_t property; + xcb_atom_t type; + uint8_t device_id; + uint8_t format; + uint8_t mode; + uint8_t pad0; + uint32_t num_items; +} xcb_input_change_device_property_request_t; + +/** Opcode for xcb_input_delete_device_property. */ +#define XCB_INPUT_DELETE_DEVICE_PROPERTY 38 + +/** + * @brief xcb_input_delete_device_property_request_t + **/ +typedef struct xcb_input_delete_device_property_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_atom_t property; + uint8_t device_id; + uint8_t pad0[3]; +} xcb_input_delete_device_property_request_t; + +/** + * @brief xcb_input_get_device_property_cookie_t + **/ +typedef struct xcb_input_get_device_property_cookie_t { + unsigned int sequence; +} xcb_input_get_device_property_cookie_t; + +/** Opcode for xcb_input_get_device_property. */ +#define XCB_INPUT_GET_DEVICE_PROPERTY 39 + +/** + * @brief xcb_input_get_device_property_request_t + **/ +typedef struct xcb_input_get_device_property_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_atom_t property; + xcb_atom_t type; + uint32_t offset; + uint32_t len; + uint8_t device_id; + uint8_t _delete; + uint8_t pad0[2]; +} xcb_input_get_device_property_request_t; + +/** + * @brief xcb_input_get_device_property_items_t + **/ +typedef struct xcb_input_get_device_property_items_t { + uint8_t *data8; + uint16_t *data16; + uint32_t *data32; +} xcb_input_get_device_property_items_t; + +/** + * @brief xcb_input_get_device_property_reply_t + **/ +typedef struct xcb_input_get_device_property_reply_t { + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + xcb_atom_t type; + uint32_t bytes_after; + uint32_t num_items; + uint8_t format; + uint8_t device_id; + uint8_t pad0[10]; +} xcb_input_get_device_property_reply_t; + +typedef enum xcb_input_device_t { + XCB_INPUT_DEVICE_ALL = 0, + XCB_INPUT_DEVICE_ALL_MASTER = 1 +} xcb_input_device_t; + +/** + * @brief xcb_input_group_info_t + **/ +typedef struct xcb_input_group_info_t { + uint8_t base; + uint8_t latched; + uint8_t locked; + uint8_t effective; +} xcb_input_group_info_t; + +/** + * @brief xcb_input_group_info_iterator_t + **/ +typedef struct xcb_input_group_info_iterator_t { + xcb_input_group_info_t *data; + int rem; + int index; +} xcb_input_group_info_iterator_t; + +/** + * @brief xcb_input_modifier_info_t + **/ +typedef struct xcb_input_modifier_info_t { + uint32_t base; + uint32_t latched; + uint32_t locked; + uint32_t effective; +} xcb_input_modifier_info_t; + +/** + * @brief xcb_input_modifier_info_iterator_t + **/ +typedef struct xcb_input_modifier_info_iterator_t { + xcb_input_modifier_info_t *data; + int rem; + int index; +} xcb_input_modifier_info_iterator_t; + +/** + * @brief xcb_input_xi_query_pointer_cookie_t + **/ +typedef struct xcb_input_xi_query_pointer_cookie_t { + unsigned int sequence; +} xcb_input_xi_query_pointer_cookie_t; + +/** Opcode for xcb_input_xi_query_pointer. */ +#define XCB_INPUT_XI_QUERY_POINTER 40 + +/** + * @brief xcb_input_xi_query_pointer_request_t + **/ +typedef struct xcb_input_xi_query_pointer_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; +} xcb_input_xi_query_pointer_request_t; + +/** + * @brief xcb_input_xi_query_pointer_reply_t + **/ +typedef struct xcb_input_xi_query_pointer_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_window_t root; + xcb_window_t child; + xcb_input_fp1616_t root_x; + xcb_input_fp1616_t root_y; + xcb_input_fp1616_t win_x; + xcb_input_fp1616_t win_y; + uint8_t same_screen; + uint8_t pad1; + uint16_t buttons_len; + xcb_input_modifier_info_t mods; + xcb_input_group_info_t group; +} xcb_input_xi_query_pointer_reply_t; + +/** Opcode for xcb_input_xi_warp_pointer. */ +#define XCB_INPUT_XI_WARP_POINTER 41 + +/** + * @brief xcb_input_xi_warp_pointer_request_t + **/ +typedef struct xcb_input_xi_warp_pointer_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t src_win; + xcb_window_t dst_win; + xcb_input_fp1616_t src_x; + xcb_input_fp1616_t src_y; + uint16_t src_width; + uint16_t src_height; + xcb_input_fp1616_t dst_x; + xcb_input_fp1616_t dst_y; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; +} xcb_input_xi_warp_pointer_request_t; + +/** Opcode for xcb_input_xi_change_cursor. */ +#define XCB_INPUT_XI_CHANGE_CURSOR 42 + +/** + * @brief xcb_input_xi_change_cursor_request_t + **/ +typedef struct xcb_input_xi_change_cursor_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_cursor_t cursor; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; +} xcb_input_xi_change_cursor_request_t; + +typedef enum xcb_input_hierarchy_change_type_t { + XCB_INPUT_HIERARCHY_CHANGE_TYPE_ADD_MASTER = 1, + XCB_INPUT_HIERARCHY_CHANGE_TYPE_REMOVE_MASTER = 2, + XCB_INPUT_HIERARCHY_CHANGE_TYPE_ATTACH_SLAVE = 3, + XCB_INPUT_HIERARCHY_CHANGE_TYPE_DETACH_SLAVE = 4 +} xcb_input_hierarchy_change_type_t; + +typedef enum xcb_input_change_mode_t { + XCB_INPUT_CHANGE_MODE_ATTACH = 1, + XCB_INPUT_CHANGE_MODE_FLOAT = 2 +} xcb_input_change_mode_t; + +/** + * @brief xcb_input_add_master_t + **/ +typedef struct xcb_input_add_master_t { + uint16_t type; + uint16_t len; + uint16_t name_len; + uint8_t send_core; + uint8_t enable; +} xcb_input_add_master_t; + +/** + * @brief xcb_input_add_master_iterator_t + **/ +typedef struct xcb_input_add_master_iterator_t { + xcb_input_add_master_t *data; + int rem; + int index; +} xcb_input_add_master_iterator_t; + +/** + * @brief xcb_input_remove_master_t + **/ +typedef struct xcb_input_remove_master_t { + uint16_t type; + uint16_t len; + xcb_input_device_id_t deviceid; + uint8_t return_mode; + uint8_t pad0; + xcb_input_device_id_t return_pointer; + xcb_input_device_id_t return_keyboard; +} xcb_input_remove_master_t; + +/** + * @brief xcb_input_remove_master_iterator_t + **/ +typedef struct xcb_input_remove_master_iterator_t { + xcb_input_remove_master_t *data; + int rem; + int index; +} xcb_input_remove_master_iterator_t; + +/** + * @brief xcb_input_attach_slave_t + **/ +typedef struct xcb_input_attach_slave_t { + uint16_t type; + uint16_t len; + xcb_input_device_id_t deviceid; + xcb_input_device_id_t master; +} xcb_input_attach_slave_t; + +/** + * @brief xcb_input_attach_slave_iterator_t + **/ +typedef struct xcb_input_attach_slave_iterator_t { + xcb_input_attach_slave_t *data; + int rem; + int index; +} xcb_input_attach_slave_iterator_t; + +/** + * @brief xcb_input_detach_slave_t + **/ +typedef struct xcb_input_detach_slave_t { + uint16_t type; + uint16_t len; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; +} xcb_input_detach_slave_t; + +/** + * @brief xcb_input_detach_slave_iterator_t + **/ +typedef struct xcb_input_detach_slave_iterator_t { + xcb_input_detach_slave_t *data; + int rem; + int index; +} xcb_input_detach_slave_iterator_t; + +/** + * @brief xcb_input_hierarchy_change_data_t + **/ +typedef struct xcb_input_hierarchy_change_data_t { + struct { + uint16_t name_len; + uint8_t send_core; + uint8_t enable; + char *name; + } add_master; + struct { + xcb_input_device_id_t deviceid; + uint8_t return_mode; + uint8_t pad1; + xcb_input_device_id_t return_pointer; + xcb_input_device_id_t return_keyboard; + } remove_master; + struct { + xcb_input_device_id_t deviceid; + xcb_input_device_id_t master; + } attach_slave; + struct { + xcb_input_device_id_t deviceid; + uint8_t pad2[2]; + } detach_slave; +} xcb_input_hierarchy_change_data_t; + +/** + * @brief xcb_input_hierarchy_change_t + **/ +typedef struct xcb_input_hierarchy_change_t { + uint16_t type; + uint16_t len; +} xcb_input_hierarchy_change_t; + +void * +xcb_input_hierarchy_change_data (const xcb_input_hierarchy_change_t *R); + +/** + * @brief xcb_input_hierarchy_change_iterator_t + **/ +typedef struct xcb_input_hierarchy_change_iterator_t { + xcb_input_hierarchy_change_t *data; + int rem; + int index; +} xcb_input_hierarchy_change_iterator_t; + +/** Opcode for xcb_input_xi_change_hierarchy. */ +#define XCB_INPUT_XI_CHANGE_HIERARCHY 43 + +/** + * @brief xcb_input_xi_change_hierarchy_request_t + **/ +typedef struct xcb_input_xi_change_hierarchy_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t num_changes; + uint8_t pad0[3]; +} xcb_input_xi_change_hierarchy_request_t; + +/** Opcode for xcb_input_xi_set_client_pointer. */ +#define XCB_INPUT_XI_SET_CLIENT_POINTER 44 + +/** + * @brief xcb_input_xi_set_client_pointer_request_t + **/ +typedef struct xcb_input_xi_set_client_pointer_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; +} xcb_input_xi_set_client_pointer_request_t; + +/** + * @brief xcb_input_xi_get_client_pointer_cookie_t + **/ +typedef struct xcb_input_xi_get_client_pointer_cookie_t { + unsigned int sequence; +} xcb_input_xi_get_client_pointer_cookie_t; + +/** Opcode for xcb_input_xi_get_client_pointer. */ +#define XCB_INPUT_XI_GET_CLIENT_POINTER 45 + +/** + * @brief xcb_input_xi_get_client_pointer_request_t + **/ +typedef struct xcb_input_xi_get_client_pointer_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; +} xcb_input_xi_get_client_pointer_request_t; + +/** + * @brief xcb_input_xi_get_client_pointer_reply_t + **/ +typedef struct xcb_input_xi_get_client_pointer_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t set; + uint8_t pad1; + xcb_input_device_id_t deviceid; + uint8_t pad2[20]; +} xcb_input_xi_get_client_pointer_reply_t; + +typedef enum xcb_input_xi_event_mask_t { + XCB_INPUT_XI_EVENT_MASK_DEVICE_CHANGED = 2, + XCB_INPUT_XI_EVENT_MASK_KEY_PRESS = 4, + XCB_INPUT_XI_EVENT_MASK_KEY_RELEASE = 8, + XCB_INPUT_XI_EVENT_MASK_BUTTON_PRESS = 16, + XCB_INPUT_XI_EVENT_MASK_BUTTON_RELEASE = 32, + XCB_INPUT_XI_EVENT_MASK_MOTION = 64, + XCB_INPUT_XI_EVENT_MASK_ENTER = 128, + XCB_INPUT_XI_EVENT_MASK_LEAVE = 256, + XCB_INPUT_XI_EVENT_MASK_FOCUS_IN = 512, + XCB_INPUT_XI_EVENT_MASK_FOCUS_OUT = 1024, + XCB_INPUT_XI_EVENT_MASK_HIERARCHY = 2048, + XCB_INPUT_XI_EVENT_MASK_PROPERTY = 4096, + XCB_INPUT_XI_EVENT_MASK_RAW_KEY_PRESS = 8192, + XCB_INPUT_XI_EVENT_MASK_RAW_KEY_RELEASE = 16384, + XCB_INPUT_XI_EVENT_MASK_RAW_BUTTON_PRESS = 32768, + XCB_INPUT_XI_EVENT_MASK_RAW_BUTTON_RELEASE = 65536, + XCB_INPUT_XI_EVENT_MASK_RAW_MOTION = 131072, + XCB_INPUT_XI_EVENT_MASK_TOUCH_BEGIN = 262144, + XCB_INPUT_XI_EVENT_MASK_TOUCH_UPDATE = 524288, + XCB_INPUT_XI_EVENT_MASK_TOUCH_END = 1048576, + XCB_INPUT_XI_EVENT_MASK_TOUCH_OWNERSHIP = 2097152, + XCB_INPUT_XI_EVENT_MASK_RAW_TOUCH_BEGIN = 4194304, + XCB_INPUT_XI_EVENT_MASK_RAW_TOUCH_UPDATE = 8388608, + XCB_INPUT_XI_EVENT_MASK_RAW_TOUCH_END = 16777216, + XCB_INPUT_XI_EVENT_MASK_BARRIER_HIT = 33554432, + XCB_INPUT_XI_EVENT_MASK_BARRIER_LEAVE = 67108864 +} xcb_input_xi_event_mask_t; + +/** + * @brief xcb_input_event_mask_t + **/ +typedef struct xcb_input_event_mask_t { + xcb_input_device_id_t deviceid; + uint16_t mask_len; +} xcb_input_event_mask_t; + +/** + * @brief xcb_input_event_mask_iterator_t + **/ +typedef struct xcb_input_event_mask_iterator_t { + xcb_input_event_mask_t *data; + int rem; + int index; +} xcb_input_event_mask_iterator_t; + +/** Opcode for xcb_input_xi_select_events. */ +#define XCB_INPUT_XI_SELECT_EVENTS 46 + +/** + * @brief xcb_input_xi_select_events_request_t + **/ +typedef struct xcb_input_xi_select_events_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint16_t num_mask; + uint8_t pad0[2]; +} xcb_input_xi_select_events_request_t; + +/** + * @brief xcb_input_xi_query_version_cookie_t + **/ +typedef struct xcb_input_xi_query_version_cookie_t { + unsigned int sequence; +} xcb_input_xi_query_version_cookie_t; + +/** Opcode for xcb_input_xi_query_version. */ +#define XCB_INPUT_XI_QUERY_VERSION 47 + +/** + * @brief xcb_input_xi_query_version_request_t + **/ +typedef struct xcb_input_xi_query_version_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t major_version; + uint16_t minor_version; +} xcb_input_xi_query_version_request_t; + +/** + * @brief xcb_input_xi_query_version_reply_t + **/ +typedef struct xcb_input_xi_query_version_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t major_version; + uint16_t minor_version; + uint8_t pad1[20]; +} xcb_input_xi_query_version_reply_t; + +typedef enum xcb_input_device_class_type_t { + XCB_INPUT_DEVICE_CLASS_TYPE_KEY = 0, + XCB_INPUT_DEVICE_CLASS_TYPE_BUTTON = 1, + XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR = 2, + XCB_INPUT_DEVICE_CLASS_TYPE_SCROLL = 3, + XCB_INPUT_DEVICE_CLASS_TYPE_TOUCH = 8 +} xcb_input_device_class_type_t; + +typedef enum xcb_input_device_type_t { + XCB_INPUT_DEVICE_TYPE_MASTER_POINTER = 1, + XCB_INPUT_DEVICE_TYPE_MASTER_KEYBOARD = 2, + XCB_INPUT_DEVICE_TYPE_SLAVE_POINTER = 3, + XCB_INPUT_DEVICE_TYPE_SLAVE_KEYBOARD = 4, + XCB_INPUT_DEVICE_TYPE_FLOATING_SLAVE = 5 +} xcb_input_device_type_t; + +typedef enum xcb_input_scroll_flags_t { + XCB_INPUT_SCROLL_FLAGS_NO_EMULATION = 1, + XCB_INPUT_SCROLL_FLAGS_PREFERRED = 2 +} xcb_input_scroll_flags_t; + +typedef enum xcb_input_scroll_type_t { + XCB_INPUT_SCROLL_TYPE_VERTICAL = 1, + XCB_INPUT_SCROLL_TYPE_HORIZONTAL = 2 +} xcb_input_scroll_type_t; + +typedef enum xcb_input_touch_mode_t { + XCB_INPUT_TOUCH_MODE_DIRECT = 1, + XCB_INPUT_TOUCH_MODE_DEPENDENT = 2 +} xcb_input_touch_mode_t; + +/** + * @brief xcb_input_button_class_t + **/ +typedef struct xcb_input_button_class_t { + uint16_t type; + uint16_t len; + xcb_input_device_id_t sourceid; + uint16_t num_buttons; +} xcb_input_button_class_t; + +/** + * @brief xcb_input_button_class_iterator_t + **/ +typedef struct xcb_input_button_class_iterator_t { + xcb_input_button_class_t *data; + int rem; + int index; +} xcb_input_button_class_iterator_t; + +/** + * @brief xcb_input_key_class_t + **/ +typedef struct xcb_input_key_class_t { + uint16_t type; + uint16_t len; + xcb_input_device_id_t sourceid; + uint16_t num_keys; +} xcb_input_key_class_t; + +/** + * @brief xcb_input_key_class_iterator_t + **/ +typedef struct xcb_input_key_class_iterator_t { + xcb_input_key_class_t *data; + int rem; + int index; +} xcb_input_key_class_iterator_t; + +/** + * @brief xcb_input_scroll_class_t + **/ +typedef struct xcb_input_scroll_class_t { + uint16_t type; + uint16_t len; + xcb_input_device_id_t sourceid; + uint16_t number; + uint16_t scroll_type; + uint8_t pad0[2]; + uint32_t flags; + xcb_input_fp3232_t increment; +} xcb_input_scroll_class_t; + +/** + * @brief xcb_input_scroll_class_iterator_t + **/ +typedef struct xcb_input_scroll_class_iterator_t { + xcb_input_scroll_class_t *data; + int rem; + int index; +} xcb_input_scroll_class_iterator_t; + +/** + * @brief xcb_input_touch_class_t + **/ +typedef struct xcb_input_touch_class_t { + uint16_t type; + uint16_t len; + xcb_input_device_id_t sourceid; + uint8_t mode; + uint8_t num_touches; +} xcb_input_touch_class_t; + +/** + * @brief xcb_input_touch_class_iterator_t + **/ +typedef struct xcb_input_touch_class_iterator_t { + xcb_input_touch_class_t *data; + int rem; + int index; +} xcb_input_touch_class_iterator_t; + +/** + * @brief xcb_input_valuator_class_t + **/ +typedef struct xcb_input_valuator_class_t { + uint16_t type; + uint16_t len; + xcb_input_device_id_t sourceid; + uint16_t number; + xcb_atom_t label; + xcb_input_fp3232_t min; + xcb_input_fp3232_t max; + xcb_input_fp3232_t value; + uint32_t resolution; + uint8_t mode; + uint8_t pad0[3]; +} xcb_input_valuator_class_t; + +/** + * @brief xcb_input_valuator_class_iterator_t + **/ +typedef struct xcb_input_valuator_class_iterator_t { + xcb_input_valuator_class_t *data; + int rem; + int index; +} xcb_input_valuator_class_iterator_t; + +/** + * @brief xcb_input_device_class_data_t + **/ +typedef struct xcb_input_device_class_data_t { + struct { + uint16_t num_keys; + uint32_t *keys; + } key; + struct { + uint16_t num_buttons; + uint32_t *state; + xcb_atom_t *labels; + } button; + struct { + uint16_t number; + xcb_atom_t label; + xcb_input_fp3232_t min; + xcb_input_fp3232_t max; + xcb_input_fp3232_t value; + uint32_t resolution; + uint8_t mode; + uint8_t pad0[3]; + } valuator; + struct { + uint16_t number; + uint16_t scroll_type; + uint8_t pad1[2]; + uint32_t flags; + xcb_input_fp3232_t increment; + } scroll; + struct { + uint8_t mode; + uint8_t num_touches; + } touch; +} xcb_input_device_class_data_t; + +/** + * @brief xcb_input_device_class_t + **/ +typedef struct xcb_input_device_class_t { + uint16_t type; + uint16_t len; + xcb_input_device_id_t sourceid; +} xcb_input_device_class_t; + +void * +xcb_input_device_class_data (const xcb_input_device_class_t *R); + +/** + * @brief xcb_input_device_class_iterator_t + **/ +typedef struct xcb_input_device_class_iterator_t { + xcb_input_device_class_t *data; + int rem; + int index; +} xcb_input_device_class_iterator_t; + +/** + * @brief xcb_input_xi_device_info_t + **/ +typedef struct xcb_input_xi_device_info_t { + xcb_input_device_id_t deviceid; + uint16_t type; + xcb_input_device_id_t attachment; + uint16_t num_classes; + uint16_t name_len; + uint8_t enabled; + uint8_t pad0; +} xcb_input_xi_device_info_t; + +/** + * @brief xcb_input_xi_device_info_iterator_t + **/ +typedef struct xcb_input_xi_device_info_iterator_t { + xcb_input_xi_device_info_t *data; + int rem; + int index; +} xcb_input_xi_device_info_iterator_t; + +/** + * @brief xcb_input_xi_query_device_cookie_t + **/ +typedef struct xcb_input_xi_query_device_cookie_t { + unsigned int sequence; +} xcb_input_xi_query_device_cookie_t; + +/** Opcode for xcb_input_xi_query_device. */ +#define XCB_INPUT_XI_QUERY_DEVICE 48 + +/** + * @brief xcb_input_xi_query_device_request_t + **/ +typedef struct xcb_input_xi_query_device_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; +} xcb_input_xi_query_device_request_t; + +/** + * @brief xcb_input_xi_query_device_reply_t + **/ +typedef struct xcb_input_xi_query_device_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t num_infos; + uint8_t pad1[22]; +} xcb_input_xi_query_device_reply_t; + +/** Opcode for xcb_input_xi_set_focus. */ +#define XCB_INPUT_XI_SET_FOCUS 49 + +/** + * @brief xcb_input_xi_set_focus_request_t + **/ +typedef struct xcb_input_xi_set_focus_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_timestamp_t time; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; +} xcb_input_xi_set_focus_request_t; + +/** + * @brief xcb_input_xi_get_focus_cookie_t + **/ +typedef struct xcb_input_xi_get_focus_cookie_t { + unsigned int sequence; +} xcb_input_xi_get_focus_cookie_t; + +/** Opcode for xcb_input_xi_get_focus. */ +#define XCB_INPUT_XI_GET_FOCUS 50 + +/** + * @brief xcb_input_xi_get_focus_request_t + **/ +typedef struct xcb_input_xi_get_focus_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; +} xcb_input_xi_get_focus_request_t; + +/** + * @brief xcb_input_xi_get_focus_reply_t + **/ +typedef struct xcb_input_xi_get_focus_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_window_t focus; + uint8_t pad1[20]; +} xcb_input_xi_get_focus_reply_t; + +typedef enum xcb_input_grab_owner_t { + XCB_INPUT_GRAB_OWNER_NO_OWNER = 0, + XCB_INPUT_GRAB_OWNER_OWNER = 1 +} xcb_input_grab_owner_t; + +/** + * @brief xcb_input_xi_grab_device_cookie_t + **/ +typedef struct xcb_input_xi_grab_device_cookie_t { + unsigned int sequence; +} xcb_input_xi_grab_device_cookie_t; + +/** Opcode for xcb_input_xi_grab_device. */ +#define XCB_INPUT_XI_GRAB_DEVICE 51 + +/** + * @brief xcb_input_xi_grab_device_request_t + **/ +typedef struct xcb_input_xi_grab_device_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_timestamp_t time; + xcb_cursor_t cursor; + xcb_input_device_id_t deviceid; + uint8_t mode; + uint8_t paired_device_mode; + uint8_t owner_events; + uint8_t pad0; + uint16_t mask_len; +} xcb_input_xi_grab_device_request_t; + +/** + * @brief xcb_input_xi_grab_device_reply_t + **/ +typedef struct xcb_input_xi_grab_device_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad1[23]; +} xcb_input_xi_grab_device_reply_t; + +/** Opcode for xcb_input_xi_ungrab_device. */ +#define XCB_INPUT_XI_UNGRAB_DEVICE 52 + +/** + * @brief xcb_input_xi_ungrab_device_request_t + **/ +typedef struct xcb_input_xi_ungrab_device_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_timestamp_t time; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; +} xcb_input_xi_ungrab_device_request_t; + +typedef enum xcb_input_event_mode_t { + XCB_INPUT_EVENT_MODE_ASYNC_DEVICE = 0, + XCB_INPUT_EVENT_MODE_SYNC_DEVICE = 1, + XCB_INPUT_EVENT_MODE_REPLAY_DEVICE = 2, + XCB_INPUT_EVENT_MODE_ASYNC_PAIRED_DEVICE = 3, + XCB_INPUT_EVENT_MODE_ASYNC_PAIR = 4, + XCB_INPUT_EVENT_MODE_SYNC_PAIR = 5, + XCB_INPUT_EVENT_MODE_ACCEPT_TOUCH = 6, + XCB_INPUT_EVENT_MODE_REJECT_TOUCH = 7 +} xcb_input_event_mode_t; + +/** Opcode for xcb_input_xi_allow_events. */ +#define XCB_INPUT_XI_ALLOW_EVENTS 53 + +/** + * @brief xcb_input_xi_allow_events_request_t + **/ +typedef struct xcb_input_xi_allow_events_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_timestamp_t time; + xcb_input_device_id_t deviceid; + uint8_t event_mode; + uint8_t pad0; + uint32_t touchid; + xcb_window_t grab_window; +} xcb_input_xi_allow_events_request_t; + +typedef enum xcb_input_grab_mode_22_t { + XCB_INPUT_GRAB_MODE_22_SYNC = 0, + XCB_INPUT_GRAB_MODE_22_ASYNC = 1, + XCB_INPUT_GRAB_MODE_22_TOUCH = 2 +} xcb_input_grab_mode_22_t; + +typedef enum xcb_input_grab_type_t { + XCB_INPUT_GRAB_TYPE_BUTTON = 0, + XCB_INPUT_GRAB_TYPE_KEYCODE = 1, + XCB_INPUT_GRAB_TYPE_ENTER = 2, + XCB_INPUT_GRAB_TYPE_FOCUS_IN = 3, + XCB_INPUT_GRAB_TYPE_TOUCH_BEGIN = 4 +} xcb_input_grab_type_t; + +typedef enum xcb_input_modifier_mask_t { + XCB_INPUT_MODIFIER_MASK_ANY = 2147483648 +} xcb_input_modifier_mask_t; + +/** + * @brief xcb_input_grab_modifier_info_t + **/ +typedef struct xcb_input_grab_modifier_info_t { + uint32_t modifiers; + uint8_t status; + uint8_t pad0[3]; +} xcb_input_grab_modifier_info_t; + +/** + * @brief xcb_input_grab_modifier_info_iterator_t + **/ +typedef struct xcb_input_grab_modifier_info_iterator_t { + xcb_input_grab_modifier_info_t *data; + int rem; + int index; +} xcb_input_grab_modifier_info_iterator_t; + +/** + * @brief xcb_input_xi_passive_grab_device_cookie_t + **/ +typedef struct xcb_input_xi_passive_grab_device_cookie_t { + unsigned int sequence; +} xcb_input_xi_passive_grab_device_cookie_t; + +/** Opcode for xcb_input_xi_passive_grab_device. */ +#define XCB_INPUT_XI_PASSIVE_GRAB_DEVICE 54 + +/** + * @brief xcb_input_xi_passive_grab_device_request_t + **/ +typedef struct xcb_input_xi_passive_grab_device_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_timestamp_t time; + xcb_window_t grab_window; + xcb_cursor_t cursor; + uint32_t detail; + xcb_input_device_id_t deviceid; + uint16_t num_modifiers; + uint16_t mask_len; + uint8_t grab_type; + uint8_t grab_mode; + uint8_t paired_device_mode; + uint8_t owner_events; + uint8_t pad0[2]; +} xcb_input_xi_passive_grab_device_request_t; + +/** + * @brief xcb_input_xi_passive_grab_device_reply_t + **/ +typedef struct xcb_input_xi_passive_grab_device_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t num_modifiers; + uint8_t pad1[22]; +} xcb_input_xi_passive_grab_device_reply_t; + +/** Opcode for xcb_input_xi_passive_ungrab_device. */ +#define XCB_INPUT_XI_PASSIVE_UNGRAB_DEVICE 55 + +/** + * @brief xcb_input_xi_passive_ungrab_device_request_t + **/ +typedef struct xcb_input_xi_passive_ungrab_device_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t grab_window; + uint32_t detail; + xcb_input_device_id_t deviceid; + uint16_t num_modifiers; + uint8_t grab_type; + uint8_t pad0[3]; +} xcb_input_xi_passive_ungrab_device_request_t; + +/** + * @brief xcb_input_xi_list_properties_cookie_t + **/ +typedef struct xcb_input_xi_list_properties_cookie_t { + unsigned int sequence; +} xcb_input_xi_list_properties_cookie_t; + +/** Opcode for xcb_input_xi_list_properties. */ +#define XCB_INPUT_XI_LIST_PROPERTIES 56 + +/** + * @brief xcb_input_xi_list_properties_request_t + **/ +typedef struct xcb_input_xi_list_properties_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; +} xcb_input_xi_list_properties_request_t; + +/** + * @brief xcb_input_xi_list_properties_reply_t + **/ +typedef struct xcb_input_xi_list_properties_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t num_properties; + uint8_t pad1[22]; +} xcb_input_xi_list_properties_reply_t; + +/** + * @brief xcb_input_xi_change_property_items_t + **/ +typedef struct xcb_input_xi_change_property_items_t { + uint8_t *data8; + uint16_t *data16; + uint32_t *data32; +} xcb_input_xi_change_property_items_t; + +/** Opcode for xcb_input_xi_change_property. */ +#define XCB_INPUT_XI_CHANGE_PROPERTY 57 + +/** + * @brief xcb_input_xi_change_property_request_t + **/ +typedef struct xcb_input_xi_change_property_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_input_device_id_t deviceid; + uint8_t mode; + uint8_t format; + xcb_atom_t property; + xcb_atom_t type; + uint32_t num_items; +} xcb_input_xi_change_property_request_t; + +/** Opcode for xcb_input_xi_delete_property. */ +#define XCB_INPUT_XI_DELETE_PROPERTY 58 + +/** + * @brief xcb_input_xi_delete_property_request_t + **/ +typedef struct xcb_input_xi_delete_property_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; + xcb_atom_t property; +} xcb_input_xi_delete_property_request_t; + +/** + * @brief xcb_input_xi_get_property_cookie_t + **/ +typedef struct xcb_input_xi_get_property_cookie_t { + unsigned int sequence; +} xcb_input_xi_get_property_cookie_t; + +/** Opcode for xcb_input_xi_get_property. */ +#define XCB_INPUT_XI_GET_PROPERTY 59 + +/** + * @brief xcb_input_xi_get_property_request_t + **/ +typedef struct xcb_input_xi_get_property_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_input_device_id_t deviceid; + uint8_t _delete; + uint8_t pad0; + xcb_atom_t property; + xcb_atom_t type; + uint32_t offset; + uint32_t len; +} xcb_input_xi_get_property_request_t; + +/** + * @brief xcb_input_xi_get_property_items_t + **/ +typedef struct xcb_input_xi_get_property_items_t { + uint8_t *data8; + uint16_t *data16; + uint32_t *data32; +} xcb_input_xi_get_property_items_t; + +/** + * @brief xcb_input_xi_get_property_reply_t + **/ +typedef struct xcb_input_xi_get_property_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_atom_t type; + uint32_t bytes_after; + uint32_t num_items; + uint8_t format; + uint8_t pad1[11]; +} xcb_input_xi_get_property_reply_t; + +/** + * @brief xcb_input_xi_get_selected_events_cookie_t + **/ +typedef struct xcb_input_xi_get_selected_events_cookie_t { + unsigned int sequence; +} xcb_input_xi_get_selected_events_cookie_t; + +/** Opcode for xcb_input_xi_get_selected_events. */ +#define XCB_INPUT_XI_GET_SELECTED_EVENTS 60 + +/** + * @brief xcb_input_xi_get_selected_events_request_t + **/ +typedef struct xcb_input_xi_get_selected_events_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; +} xcb_input_xi_get_selected_events_request_t; + +/** + * @brief xcb_input_xi_get_selected_events_reply_t + **/ +typedef struct xcb_input_xi_get_selected_events_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t num_masks; + uint8_t pad1[22]; +} xcb_input_xi_get_selected_events_reply_t; + +/** Opcode for xcb_input_device_valuator. */ +#define XCB_INPUT_DEVICE_VALUATOR 0 + +/** + * @brief xcb_input_device_valuator_event_t + **/ +typedef struct xcb_input_device_valuator_event_t { + uint8_t response_type; + uint8_t device_id; + uint16_t sequence; + uint16_t device_state; + uint8_t num_valuators; + uint8_t first_valuator; + int32_t valuators[6]; +} xcb_input_device_valuator_event_t; + +typedef enum xcb_input_more_events_mask_t { + XCB_INPUT_MORE_EVENTS_MASK_MORE_EVENTS = 128 +} xcb_input_more_events_mask_t; + +/** Opcode for xcb_input_device_key_press. */ +#define XCB_INPUT_DEVICE_KEY_PRESS 1 + +/** + * @brief xcb_input_device_key_press_event_t + **/ +typedef struct xcb_input_device_key_press_event_t { + uint8_t response_type; + uint8_t detail; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + int16_t root_x; + int16_t root_y; + int16_t event_x; + int16_t event_y; + uint16_t state; + uint8_t same_screen; + uint8_t device_id; +} xcb_input_device_key_press_event_t; + +/** Opcode for xcb_input_device_key_release. */ +#define XCB_INPUT_DEVICE_KEY_RELEASE 2 + +typedef xcb_input_device_key_press_event_t xcb_input_device_key_release_event_t; + +/** Opcode for xcb_input_device_button_press. */ +#define XCB_INPUT_DEVICE_BUTTON_PRESS 3 + +typedef xcb_input_device_key_press_event_t xcb_input_device_button_press_event_t; + +/** Opcode for xcb_input_device_button_release. */ +#define XCB_INPUT_DEVICE_BUTTON_RELEASE 4 + +typedef xcb_input_device_key_press_event_t xcb_input_device_button_release_event_t; + +/** Opcode for xcb_input_device_motion_notify. */ +#define XCB_INPUT_DEVICE_MOTION_NOTIFY 5 + +typedef xcb_input_device_key_press_event_t xcb_input_device_motion_notify_event_t; + +/** Opcode for xcb_input_device_focus_in. */ +#define XCB_INPUT_DEVICE_FOCUS_IN 6 + +/** + * @brief xcb_input_device_focus_in_event_t + **/ +typedef struct xcb_input_device_focus_in_event_t { + uint8_t response_type; + uint8_t detail; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t window; + uint8_t mode; + uint8_t device_id; + uint8_t pad0[18]; +} xcb_input_device_focus_in_event_t; + +/** Opcode for xcb_input_device_focus_out. */ +#define XCB_INPUT_DEVICE_FOCUS_OUT 7 + +typedef xcb_input_device_focus_in_event_t xcb_input_device_focus_out_event_t; + +/** Opcode for xcb_input_proximity_in. */ +#define XCB_INPUT_PROXIMITY_IN 8 + +typedef xcb_input_device_key_press_event_t xcb_input_proximity_in_event_t; + +/** Opcode for xcb_input_proximity_out. */ +#define XCB_INPUT_PROXIMITY_OUT 9 + +typedef xcb_input_device_key_press_event_t xcb_input_proximity_out_event_t; + +typedef enum xcb_input_classes_reported_mask_t { + XCB_INPUT_CLASSES_REPORTED_MASK_OUT_OF_PROXIMITY = 128, + XCB_INPUT_CLASSES_REPORTED_MASK_DEVICE_MODE_ABSOLUTE = 64, + XCB_INPUT_CLASSES_REPORTED_MASK_REPORTING_VALUATORS = 4, + XCB_INPUT_CLASSES_REPORTED_MASK_REPORTING_BUTTONS = 2, + XCB_INPUT_CLASSES_REPORTED_MASK_REPORTING_KEYS = 1 +} xcb_input_classes_reported_mask_t; + +/** Opcode for xcb_input_device_state_notify. */ +#define XCB_INPUT_DEVICE_STATE_NOTIFY 10 + +/** + * @brief xcb_input_device_state_notify_event_t + **/ +typedef struct xcb_input_device_state_notify_event_t { + uint8_t response_type; + uint8_t device_id; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t num_keys; + uint8_t num_buttons; + uint8_t num_valuators; + uint8_t classes_reported; + uint8_t buttons[4]; + uint8_t keys[4]; + uint32_t valuators[3]; +} xcb_input_device_state_notify_event_t; + +/** Opcode for xcb_input_device_mapping_notify. */ +#define XCB_INPUT_DEVICE_MAPPING_NOTIFY 11 + +/** + * @brief xcb_input_device_mapping_notify_event_t + **/ +typedef struct xcb_input_device_mapping_notify_event_t { + uint8_t response_type; + uint8_t device_id; + uint16_t sequence; + uint8_t request; + xcb_input_key_code_t first_keycode; + uint8_t count; + uint8_t pad0; + xcb_timestamp_t time; + uint8_t pad1[20]; +} xcb_input_device_mapping_notify_event_t; + +typedef enum xcb_input_change_device_t { + XCB_INPUT_CHANGE_DEVICE_NEW_POINTER = 0, + XCB_INPUT_CHANGE_DEVICE_NEW_KEYBOARD = 1 +} xcb_input_change_device_t; + +/** Opcode for xcb_input_change_device_notify. */ +#define XCB_INPUT_CHANGE_DEVICE_NOTIFY 12 + +/** + * @brief xcb_input_change_device_notify_event_t + **/ +typedef struct xcb_input_change_device_notify_event_t { + uint8_t response_type; + uint8_t device_id; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t request; + uint8_t pad0[23]; +} xcb_input_change_device_notify_event_t; + +/** Opcode for xcb_input_device_key_state_notify. */ +#define XCB_INPUT_DEVICE_KEY_STATE_NOTIFY 13 + +/** + * @brief xcb_input_device_key_state_notify_event_t + **/ +typedef struct xcb_input_device_key_state_notify_event_t { + uint8_t response_type; + uint8_t device_id; + uint16_t sequence; + uint8_t keys[28]; +} xcb_input_device_key_state_notify_event_t; + +/** Opcode for xcb_input_device_button_state_notify. */ +#define XCB_INPUT_DEVICE_BUTTON_STATE_NOTIFY 14 + +/** + * @brief xcb_input_device_button_state_notify_event_t + **/ +typedef struct xcb_input_device_button_state_notify_event_t { + uint8_t response_type; + uint8_t device_id; + uint16_t sequence; + uint8_t buttons[28]; +} xcb_input_device_button_state_notify_event_t; + +typedef enum xcb_input_device_change_t { + XCB_INPUT_DEVICE_CHANGE_ADDED = 0, + XCB_INPUT_DEVICE_CHANGE_REMOVED = 1, + XCB_INPUT_DEVICE_CHANGE_ENABLED = 2, + XCB_INPUT_DEVICE_CHANGE_DISABLED = 3, + XCB_INPUT_DEVICE_CHANGE_UNRECOVERABLE = 4, + XCB_INPUT_DEVICE_CHANGE_CONTROL_CHANGED = 5 +} xcb_input_device_change_t; + +/** Opcode for xcb_input_device_presence_notify. */ +#define XCB_INPUT_DEVICE_PRESENCE_NOTIFY 15 + +/** + * @brief xcb_input_device_presence_notify_event_t + **/ +typedef struct xcb_input_device_presence_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t devchange; + uint8_t device_id; + uint16_t control; + uint8_t pad1[20]; +} xcb_input_device_presence_notify_event_t; + +/** Opcode for xcb_input_device_property_notify. */ +#define XCB_INPUT_DEVICE_PROPERTY_NOTIFY 16 + +/** + * @brief xcb_input_device_property_notify_event_t + **/ +typedef struct xcb_input_device_property_notify_event_t { + uint8_t response_type; + uint8_t state; + uint16_t sequence; + xcb_timestamp_t time; + xcb_atom_t property; + uint8_t pad0[19]; + uint8_t device_id; +} xcb_input_device_property_notify_event_t; + +typedef enum xcb_input_change_reason_t { + XCB_INPUT_CHANGE_REASON_SLAVE_SWITCH = 1, + XCB_INPUT_CHANGE_REASON_DEVICE_CHANGE = 2 +} xcb_input_change_reason_t; + +/** Opcode for xcb_input_device_changed. */ +#define XCB_INPUT_DEVICE_CHANGED 1 + +/** + * @brief xcb_input_device_changed_event_t + **/ +typedef struct xcb_input_device_changed_event_t { + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint16_t num_classes; + xcb_input_device_id_t sourceid; + uint8_t reason; + uint8_t pad0[11]; + uint32_t full_sequence; +} xcb_input_device_changed_event_t; + +typedef enum xcb_input_key_event_flags_t { + XCB_INPUT_KEY_EVENT_FLAGS_KEY_REPEAT = 65536 +} xcb_input_key_event_flags_t; + +/** Opcode for xcb_input_key_press. */ +#define XCB_INPUT_KEY_PRESS 2 + +/** + * @brief xcb_input_key_press_event_t + **/ +typedef struct xcb_input_key_press_event_t { + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t detail; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + uint32_t full_sequence; + xcb_input_fp1616_t root_x; + xcb_input_fp1616_t root_y; + xcb_input_fp1616_t event_x; + xcb_input_fp1616_t event_y; + uint16_t buttons_len; + uint16_t valuators_len; + xcb_input_device_id_t sourceid; + uint8_t pad0[2]; + uint32_t flags; + xcb_input_modifier_info_t mods; + xcb_input_group_info_t group; +} xcb_input_key_press_event_t; + +/** Opcode for xcb_input_key_release. */ +#define XCB_INPUT_KEY_RELEASE 3 + +typedef xcb_input_key_press_event_t xcb_input_key_release_event_t; + +typedef enum xcb_input_pointer_event_flags_t { + XCB_INPUT_POINTER_EVENT_FLAGS_POINTER_EMULATED = 65536 +} xcb_input_pointer_event_flags_t; + +/** Opcode for xcb_input_button_press. */ +#define XCB_INPUT_BUTTON_PRESS 4 + +/** + * @brief xcb_input_button_press_event_t + **/ +typedef struct xcb_input_button_press_event_t { + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t detail; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + uint32_t full_sequence; + xcb_input_fp1616_t root_x; + xcb_input_fp1616_t root_y; + xcb_input_fp1616_t event_x; + xcb_input_fp1616_t event_y; + uint16_t buttons_len; + uint16_t valuators_len; + xcb_input_device_id_t sourceid; + uint8_t pad0[2]; + uint32_t flags; + xcb_input_modifier_info_t mods; + xcb_input_group_info_t group; +} xcb_input_button_press_event_t; + +/** Opcode for xcb_input_button_release. */ +#define XCB_INPUT_BUTTON_RELEASE 5 + +typedef xcb_input_button_press_event_t xcb_input_button_release_event_t; + +/** Opcode for xcb_input_motion. */ +#define XCB_INPUT_MOTION 6 + +typedef xcb_input_button_press_event_t xcb_input_motion_event_t; + +typedef enum xcb_input_notify_mode_t { + XCB_INPUT_NOTIFY_MODE_NORMAL = 0, + XCB_INPUT_NOTIFY_MODE_GRAB = 1, + XCB_INPUT_NOTIFY_MODE_UNGRAB = 2, + XCB_INPUT_NOTIFY_MODE_WHILE_GRABBED = 3, + XCB_INPUT_NOTIFY_MODE_PASSIVE_GRAB = 4, + XCB_INPUT_NOTIFY_MODE_PASSIVE_UNGRAB = 5 +} xcb_input_notify_mode_t; + +typedef enum xcb_input_notify_detail_t { + XCB_INPUT_NOTIFY_DETAIL_ANCESTOR = 0, + XCB_INPUT_NOTIFY_DETAIL_VIRTUAL = 1, + XCB_INPUT_NOTIFY_DETAIL_INFERIOR = 2, + XCB_INPUT_NOTIFY_DETAIL_NONLINEAR = 3, + XCB_INPUT_NOTIFY_DETAIL_NONLINEAR_VIRTUAL = 4, + XCB_INPUT_NOTIFY_DETAIL_POINTER = 5, + XCB_INPUT_NOTIFY_DETAIL_POINTER_ROOT = 6, + XCB_INPUT_NOTIFY_DETAIL_NONE = 7 +} xcb_input_notify_detail_t; + +/** Opcode for xcb_input_enter. */ +#define XCB_INPUT_ENTER 7 + +/** + * @brief xcb_input_enter_event_t + **/ +typedef struct xcb_input_enter_event_t { + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + xcb_input_device_id_t sourceid; + uint8_t mode; + uint8_t detail; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + uint32_t full_sequence; + xcb_input_fp1616_t root_x; + xcb_input_fp1616_t root_y; + xcb_input_fp1616_t event_x; + xcb_input_fp1616_t event_y; + uint8_t same_screen; + uint8_t focus; + uint16_t buttons_len; + xcb_input_modifier_info_t mods; + xcb_input_group_info_t group; +} xcb_input_enter_event_t; + +/** Opcode for xcb_input_leave. */ +#define XCB_INPUT_LEAVE 8 + +typedef xcb_input_enter_event_t xcb_input_leave_event_t; + +/** Opcode for xcb_input_focus_in. */ +#define XCB_INPUT_FOCUS_IN 9 + +typedef xcb_input_enter_event_t xcb_input_focus_in_event_t; + +/** Opcode for xcb_input_focus_out. */ +#define XCB_INPUT_FOCUS_OUT 10 + +typedef xcb_input_enter_event_t xcb_input_focus_out_event_t; + +typedef enum xcb_input_hierarchy_mask_t { + XCB_INPUT_HIERARCHY_MASK_MASTER_ADDED = 1, + XCB_INPUT_HIERARCHY_MASK_MASTER_REMOVED = 2, + XCB_INPUT_HIERARCHY_MASK_SLAVE_ADDED = 4, + XCB_INPUT_HIERARCHY_MASK_SLAVE_REMOVED = 8, + XCB_INPUT_HIERARCHY_MASK_SLAVE_ATTACHED = 16, + XCB_INPUT_HIERARCHY_MASK_SLAVE_DETACHED = 32, + XCB_INPUT_HIERARCHY_MASK_DEVICE_ENABLED = 64, + XCB_INPUT_HIERARCHY_MASK_DEVICE_DISABLED = 128 +} xcb_input_hierarchy_mask_t; + +/** + * @brief xcb_input_hierarchy_info_t + **/ +typedef struct xcb_input_hierarchy_info_t { + xcb_input_device_id_t deviceid; + xcb_input_device_id_t attachment; + uint8_t type; + uint8_t enabled; + uint8_t pad0[2]; + uint32_t flags; +} xcb_input_hierarchy_info_t; + +/** + * @brief xcb_input_hierarchy_info_iterator_t + **/ +typedef struct xcb_input_hierarchy_info_iterator_t { + xcb_input_hierarchy_info_t *data; + int rem; + int index; +} xcb_input_hierarchy_info_iterator_t; + +/** Opcode for xcb_input_hierarchy. */ +#define XCB_INPUT_HIERARCHY 11 + +/** + * @brief xcb_input_hierarchy_event_t + **/ +typedef struct xcb_input_hierarchy_event_t { + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t flags; + uint16_t num_infos; + uint8_t pad0[10]; + uint32_t full_sequence; +} xcb_input_hierarchy_event_t; + +typedef enum xcb_input_property_flag_t { + XCB_INPUT_PROPERTY_FLAG_DELETED = 0, + XCB_INPUT_PROPERTY_FLAG_CREATED = 1, + XCB_INPUT_PROPERTY_FLAG_MODIFIED = 2 +} xcb_input_property_flag_t; + +/** Opcode for xcb_input_property. */ +#define XCB_INPUT_PROPERTY 12 + +/** + * @brief xcb_input_property_event_t + **/ +typedef struct xcb_input_property_event_t { + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + xcb_atom_t property; + uint8_t what; + uint8_t pad0[11]; + uint32_t full_sequence; +} xcb_input_property_event_t; + +/** Opcode for xcb_input_raw_key_press. */ +#define XCB_INPUT_RAW_KEY_PRESS 13 + +/** + * @brief xcb_input_raw_key_press_event_t + **/ +typedef struct xcb_input_raw_key_press_event_t { + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t detail; + xcb_input_device_id_t sourceid; + uint16_t valuators_len; + uint32_t flags; + uint8_t pad0[4]; + uint32_t full_sequence; +} xcb_input_raw_key_press_event_t; + +/** Opcode for xcb_input_raw_key_release. */ +#define XCB_INPUT_RAW_KEY_RELEASE 14 + +typedef xcb_input_raw_key_press_event_t xcb_input_raw_key_release_event_t; + +/** Opcode for xcb_input_raw_button_press. */ +#define XCB_INPUT_RAW_BUTTON_PRESS 15 + +/** + * @brief xcb_input_raw_button_press_event_t + **/ +typedef struct xcb_input_raw_button_press_event_t { + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t detail; + xcb_input_device_id_t sourceid; + uint16_t valuators_len; + uint32_t flags; + uint8_t pad0[4]; + uint32_t full_sequence; +} xcb_input_raw_button_press_event_t; + +/** Opcode for xcb_input_raw_button_release. */ +#define XCB_INPUT_RAW_BUTTON_RELEASE 16 + +typedef xcb_input_raw_button_press_event_t xcb_input_raw_button_release_event_t; + +/** Opcode for xcb_input_raw_motion. */ +#define XCB_INPUT_RAW_MOTION 17 + +typedef xcb_input_raw_button_press_event_t xcb_input_raw_motion_event_t; + +typedef enum xcb_input_touch_event_flags_t { + XCB_INPUT_TOUCH_EVENT_FLAGS_TOUCH_PENDING_END = 65536, + XCB_INPUT_TOUCH_EVENT_FLAGS_TOUCH_EMULATING_POINTER = 131072 +} xcb_input_touch_event_flags_t; + +/** Opcode for xcb_input_touch_begin. */ +#define XCB_INPUT_TOUCH_BEGIN 18 + +/** + * @brief xcb_input_touch_begin_event_t + **/ +typedef struct xcb_input_touch_begin_event_t { + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t detail; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + uint32_t full_sequence; + xcb_input_fp1616_t root_x; + xcb_input_fp1616_t root_y; + xcb_input_fp1616_t event_x; + xcb_input_fp1616_t event_y; + uint16_t buttons_len; + uint16_t valuators_len; + xcb_input_device_id_t sourceid; + uint8_t pad0[2]; + uint32_t flags; + xcb_input_modifier_info_t mods; + xcb_input_group_info_t group; +} xcb_input_touch_begin_event_t; + +/** Opcode for xcb_input_touch_update. */ +#define XCB_INPUT_TOUCH_UPDATE 19 + +typedef xcb_input_touch_begin_event_t xcb_input_touch_update_event_t; + +/** Opcode for xcb_input_touch_end. */ +#define XCB_INPUT_TOUCH_END 20 + +typedef xcb_input_touch_begin_event_t xcb_input_touch_end_event_t; + +typedef enum xcb_input_touch_ownership_flags_t { + XCB_INPUT_TOUCH_OWNERSHIP_FLAGS_NONE = 0 +} xcb_input_touch_ownership_flags_t; + +/** Opcode for xcb_input_touch_ownership. */ +#define XCB_INPUT_TOUCH_OWNERSHIP 21 + +/** + * @brief xcb_input_touch_ownership_event_t + **/ +typedef struct xcb_input_touch_ownership_event_t { + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t touchid; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + uint32_t full_sequence; + xcb_input_device_id_t sourceid; + uint8_t pad0[2]; + uint32_t flags; + uint8_t pad1[8]; +} xcb_input_touch_ownership_event_t; + +/** Opcode for xcb_input_raw_touch_begin. */ +#define XCB_INPUT_RAW_TOUCH_BEGIN 22 + +/** + * @brief xcb_input_raw_touch_begin_event_t + **/ +typedef struct xcb_input_raw_touch_begin_event_t { + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t detail; + xcb_input_device_id_t sourceid; + uint16_t valuators_len; + uint32_t flags; + uint8_t pad0[4]; + uint32_t full_sequence; +} xcb_input_raw_touch_begin_event_t; + +/** Opcode for xcb_input_raw_touch_update. */ +#define XCB_INPUT_RAW_TOUCH_UPDATE 23 + +typedef xcb_input_raw_touch_begin_event_t xcb_input_raw_touch_update_event_t; + +/** Opcode for xcb_input_raw_touch_end. */ +#define XCB_INPUT_RAW_TOUCH_END 24 + +typedef xcb_input_raw_touch_begin_event_t xcb_input_raw_touch_end_event_t; + +/** Opcode for xcb_input_barrier_hit. */ +#define XCB_INPUT_BARRIER_HIT 25 + +/** Opcode for xcb_input_barrier_leave. */ +#define XCB_INPUT_BARRIER_LEAVE 26 + +/** Opcode for xcb_input_device. */ +#define XCB_INPUT_DEVICE 0 + +/** + * @brief xcb_input_device_error_t + **/ +typedef struct xcb_input_device_error_t { + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; +} xcb_input_device_error_t; + +/** Opcode for xcb_input_event. */ +#define XCB_INPUT_EVENT 1 + +/** + * @brief xcb_input_event_error_t + **/ +typedef struct xcb_input_event_error_t { + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; +} xcb_input_event_error_t; + +/** Opcode for xcb_input_mode. */ +#define XCB_INPUT_MODE 2 + +/** + * @brief xcb_input_mode_error_t + **/ +typedef struct xcb_input_mode_error_t { + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; +} xcb_input_mode_error_t; + +/** Opcode for xcb_input_device_busy. */ +#define XCB_INPUT_DEVICE_BUSY 3 + +/** + * @brief xcb_input_device_busy_error_t + **/ +typedef struct xcb_input_device_busy_error_t { + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; +} xcb_input_device_busy_error_t; + +/** Opcode for xcb_input_class. */ +#define XCB_INPUT_CLASS 4 + +/** + * @brief xcb_input_class_error_t + **/ +typedef struct xcb_input_class_error_t { + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; +} xcb_input_class_error_t; + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_event_class_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_event_class_t) + */ +void +xcb_input_event_class_next (xcb_input_event_class_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_event_class_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_event_class_end (xcb_input_event_class_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_key_code_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_key_code_t) + */ +void +xcb_input_key_code_next (xcb_input_key_code_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_key_code_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_key_code_end (xcb_input_key_code_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_id_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_id_t) + */ +void +xcb_input_device_id_next (xcb_input_device_id_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_id_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_id_end (xcb_input_device_id_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_fp1616_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_fp1616_t) + */ +void +xcb_input_fp1616_next (xcb_input_fp1616_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_fp1616_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_fp1616_end (xcb_input_fp1616_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_fp3232_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_fp3232_t) + */ +void +xcb_input_fp3232_next (xcb_input_fp3232_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_fp3232_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_fp3232_end (xcb_input_fp3232_iterator_t i); + +int +xcb_input_get_extension_version_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_get_extension_version_cookie_t +xcb_input_get_extension_version (xcb_connection_t *c, + uint16_t name_len, + const char *name); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_get_extension_version_cookie_t +xcb_input_get_extension_version_unchecked (xcb_connection_t *c, + uint16_t name_len, + const char *name); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_get_extension_version_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_get_extension_version_reply_t * +xcb_input_get_extension_version_reply (xcb_connection_t *c, + xcb_input_get_extension_version_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_info_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_info_t) + */ +void +xcb_input_device_info_next (xcb_input_device_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_info_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_info_end (xcb_input_device_info_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_key_info_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_key_info_t) + */ +void +xcb_input_key_info_next (xcb_input_key_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_key_info_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_key_info_end (xcb_input_key_info_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_button_info_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_button_info_t) + */ +void +xcb_input_button_info_next (xcb_input_button_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_button_info_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_button_info_end (xcb_input_button_info_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_axis_info_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_axis_info_t) + */ +void +xcb_input_axis_info_next (xcb_input_axis_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_axis_info_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_axis_info_end (xcb_input_axis_info_iterator_t i); + +int +xcb_input_valuator_info_sizeof (const void *_buffer); + +xcb_input_axis_info_t * +xcb_input_valuator_info_axes (const xcb_input_valuator_info_t *R); + +int +xcb_input_valuator_info_axes_length (const xcb_input_valuator_info_t *R); + +xcb_input_axis_info_iterator_t +xcb_input_valuator_info_axes_iterator (const xcb_input_valuator_info_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_valuator_info_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_valuator_info_t) + */ +void +xcb_input_valuator_info_next (xcb_input_valuator_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_valuator_info_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_valuator_info_end (xcb_input_valuator_info_iterator_t i); + +xcb_input_axis_info_t * +xcb_input_input_info_info_valuator_axes (const xcb_input_input_info_info_t *S); + +int +xcb_input_input_info_info_valuator_axes_length (const xcb_input_input_info_t *R, + const xcb_input_input_info_info_t *S); + +xcb_input_axis_info_iterator_t +xcb_input_input_info_info_valuator_axes_iterator (const xcb_input_input_info_t *R, + const xcb_input_input_info_info_t *S); + +int +xcb_input_input_info_info_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_input_info_info_t *_aux); + +int +xcb_input_input_info_info_unpack (const void *_buffer, + uint8_t class_id, + xcb_input_input_info_info_t *_aux); + +int +xcb_input_input_info_info_sizeof (const void *_buffer, + uint8_t class_id); + +int +xcb_input_input_info_sizeof (const void *_buffer); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_input_info_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_input_info_t) + */ +void +xcb_input_input_info_next (xcb_input_input_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_input_info_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_input_info_end (xcb_input_input_info_iterator_t i); + +int +xcb_input_device_name_sizeof (const void *_buffer); + +char * +xcb_input_device_name_string (const xcb_input_device_name_t *R); + +int +xcb_input_device_name_string_length (const xcb_input_device_name_t *R); + +xcb_generic_iterator_t +xcb_input_device_name_string_end (const xcb_input_device_name_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_name_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_name_t) + */ +void +xcb_input_device_name_next (xcb_input_device_name_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_name_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_name_end (xcb_input_device_name_iterator_t i); + +int +xcb_input_list_input_devices_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_list_input_devices_cookie_t +xcb_input_list_input_devices (xcb_connection_t *c); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_list_input_devices_cookie_t +xcb_input_list_input_devices_unchecked (xcb_connection_t *c); + +xcb_input_device_info_t * +xcb_input_list_input_devices_devices (const xcb_input_list_input_devices_reply_t *R); + +int +xcb_input_list_input_devices_devices_length (const xcb_input_list_input_devices_reply_t *R); + +xcb_input_device_info_iterator_t +xcb_input_list_input_devices_devices_iterator (const xcb_input_list_input_devices_reply_t *R); + +int +xcb_input_list_input_devices_infos_length (const xcb_input_list_input_devices_reply_t *R); + +xcb_input_input_info_iterator_t +xcb_input_list_input_devices_infos_iterator (const xcb_input_list_input_devices_reply_t *R); + +int +xcb_input_list_input_devices_names_length (const xcb_input_list_input_devices_reply_t *R); + +xcb_str_iterator_t +xcb_input_list_input_devices_names_iterator (const xcb_input_list_input_devices_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_list_input_devices_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_list_input_devices_reply_t * +xcb_input_list_input_devices_reply (xcb_connection_t *c, + xcb_input_list_input_devices_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_event_type_base_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_event_type_base_t) + */ +void +xcb_input_event_type_base_next (xcb_input_event_type_base_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_event_type_base_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_event_type_base_end (xcb_input_event_type_base_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_input_class_info_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_input_class_info_t) + */ +void +xcb_input_input_class_info_next (xcb_input_input_class_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_input_class_info_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_input_class_info_end (xcb_input_input_class_info_iterator_t i); + +int +xcb_input_open_device_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_open_device_cookie_t +xcb_input_open_device (xcb_connection_t *c, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_open_device_cookie_t +xcb_input_open_device_unchecked (xcb_connection_t *c, + uint8_t device_id); + +xcb_input_input_class_info_t * +xcb_input_open_device_class_info (const xcb_input_open_device_reply_t *R); + +int +xcb_input_open_device_class_info_length (const xcb_input_open_device_reply_t *R); + +xcb_input_input_class_info_iterator_t +xcb_input_open_device_class_info_iterator (const xcb_input_open_device_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_open_device_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_open_device_reply_t * +xcb_input_open_device_reply (xcb_connection_t *c, + xcb_input_open_device_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_close_device_checked (xcb_connection_t *c, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_close_device (xcb_connection_t *c, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_set_device_mode_cookie_t +xcb_input_set_device_mode (xcb_connection_t *c, + uint8_t device_id, + uint8_t mode); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_set_device_mode_cookie_t +xcb_input_set_device_mode_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t mode); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_set_device_mode_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_set_device_mode_reply_t * +xcb_input_set_device_mode_reply (xcb_connection_t *c, + xcb_input_set_device_mode_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_select_extension_event_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_select_extension_event_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + const xcb_input_event_class_t *classes); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_select_extension_event (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + const xcb_input_event_class_t *classes); + +xcb_input_event_class_t * +xcb_input_select_extension_event_classes (const xcb_input_select_extension_event_request_t *R); + +int +xcb_input_select_extension_event_classes_length (const xcb_input_select_extension_event_request_t *R); + +xcb_generic_iterator_t +xcb_input_select_extension_event_classes_end (const xcb_input_select_extension_event_request_t *R); + +int +xcb_input_get_selected_extension_events_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_get_selected_extension_events_cookie_t +xcb_input_get_selected_extension_events (xcb_connection_t *c, + xcb_window_t window); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_get_selected_extension_events_cookie_t +xcb_input_get_selected_extension_events_unchecked (xcb_connection_t *c, + xcb_window_t window); + +xcb_input_event_class_t * +xcb_input_get_selected_extension_events_this_classes (const xcb_input_get_selected_extension_events_reply_t *R); + +int +xcb_input_get_selected_extension_events_this_classes_length (const xcb_input_get_selected_extension_events_reply_t *R); + +xcb_generic_iterator_t +xcb_input_get_selected_extension_events_this_classes_end (const xcb_input_get_selected_extension_events_reply_t *R); + +xcb_input_event_class_t * +xcb_input_get_selected_extension_events_all_classes (const xcb_input_get_selected_extension_events_reply_t *R); + +int +xcb_input_get_selected_extension_events_all_classes_length (const xcb_input_get_selected_extension_events_reply_t *R); + +xcb_generic_iterator_t +xcb_input_get_selected_extension_events_all_classes_end (const xcb_input_get_selected_extension_events_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_get_selected_extension_events_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_get_selected_extension_events_reply_t * +xcb_input_get_selected_extension_events_reply (xcb_connection_t *c, + xcb_input_get_selected_extension_events_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_change_device_dont_propagate_list_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_change_device_dont_propagate_list_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + uint8_t mode, + const xcb_input_event_class_t *classes); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_change_device_dont_propagate_list (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + uint8_t mode, + const xcb_input_event_class_t *classes); + +xcb_input_event_class_t * +xcb_input_change_device_dont_propagate_list_classes (const xcb_input_change_device_dont_propagate_list_request_t *R); + +int +xcb_input_change_device_dont_propagate_list_classes_length (const xcb_input_change_device_dont_propagate_list_request_t *R); + +xcb_generic_iterator_t +xcb_input_change_device_dont_propagate_list_classes_end (const xcb_input_change_device_dont_propagate_list_request_t *R); + +int +xcb_input_get_device_dont_propagate_list_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_get_device_dont_propagate_list_cookie_t +xcb_input_get_device_dont_propagate_list (xcb_connection_t *c, + xcb_window_t window); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_get_device_dont_propagate_list_cookie_t +xcb_input_get_device_dont_propagate_list_unchecked (xcb_connection_t *c, + xcb_window_t window); + +xcb_input_event_class_t * +xcb_input_get_device_dont_propagate_list_classes (const xcb_input_get_device_dont_propagate_list_reply_t *R); + +int +xcb_input_get_device_dont_propagate_list_classes_length (const xcb_input_get_device_dont_propagate_list_reply_t *R); + +xcb_generic_iterator_t +xcb_input_get_device_dont_propagate_list_classes_end (const xcb_input_get_device_dont_propagate_list_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_get_device_dont_propagate_list_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_get_device_dont_propagate_list_reply_t * +xcb_input_get_device_dont_propagate_list_reply (xcb_connection_t *c, + xcb_input_get_device_dont_propagate_list_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_device_time_coord_sizeof (const void *_buffer, + uint8_t num_axes); + +int32_t * +xcb_input_device_time_coord_axisvalues (const xcb_input_device_time_coord_t *R); + +int +xcb_input_device_time_coord_axisvalues_length (const xcb_input_device_time_coord_t *R, + uint8_t num_axes); + +xcb_generic_iterator_t +xcb_input_device_time_coord_axisvalues_end (const xcb_input_device_time_coord_t *R, + uint8_t num_axes); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_time_coord_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_time_coord_t) + */ +void +xcb_input_device_time_coord_next (xcb_input_device_time_coord_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_time_coord_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_time_coord_end (xcb_input_device_time_coord_iterator_t i); + +int +xcb_input_get_device_motion_events_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_get_device_motion_events_cookie_t +xcb_input_get_device_motion_events (xcb_connection_t *c, + xcb_timestamp_t start, + xcb_timestamp_t stop, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_get_device_motion_events_cookie_t +xcb_input_get_device_motion_events_unchecked (xcb_connection_t *c, + xcb_timestamp_t start, + xcb_timestamp_t stop, + uint8_t device_id); + +int +xcb_input_get_device_motion_events_events_length (const xcb_input_get_device_motion_events_reply_t *R); + +xcb_input_device_time_coord_iterator_t +xcb_input_get_device_motion_events_events_iterator (const xcb_input_get_device_motion_events_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_get_device_motion_events_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_get_device_motion_events_reply_t * +xcb_input_get_device_motion_events_reply (xcb_connection_t *c, + xcb_input_get_device_motion_events_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_change_keyboard_device_cookie_t +xcb_input_change_keyboard_device (xcb_connection_t *c, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_change_keyboard_device_cookie_t +xcb_input_change_keyboard_device_unchecked (xcb_connection_t *c, + uint8_t device_id); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_change_keyboard_device_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_change_keyboard_device_reply_t * +xcb_input_change_keyboard_device_reply (xcb_connection_t *c, + xcb_input_change_keyboard_device_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_change_pointer_device_cookie_t +xcb_input_change_pointer_device (xcb_connection_t *c, + uint8_t x_axis, + uint8_t y_axis, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_change_pointer_device_cookie_t +xcb_input_change_pointer_device_unchecked (xcb_connection_t *c, + uint8_t x_axis, + uint8_t y_axis, + uint8_t device_id); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_change_pointer_device_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_change_pointer_device_reply_t * +xcb_input_change_pointer_device_reply (xcb_connection_t *c, + xcb_input_change_pointer_device_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_grab_device_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_grab_device_cookie_t +xcb_input_grab_device (xcb_connection_t *c, + xcb_window_t grab_window, + xcb_timestamp_t time, + uint16_t num_classes, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + uint8_t device_id, + const xcb_input_event_class_t *classes); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_grab_device_cookie_t +xcb_input_grab_device_unchecked (xcb_connection_t *c, + xcb_window_t grab_window, + xcb_timestamp_t time, + uint16_t num_classes, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + uint8_t device_id, + const xcb_input_event_class_t *classes); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_grab_device_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_grab_device_reply_t * +xcb_input_grab_device_reply (xcb_connection_t *c, + xcb_input_grab_device_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_ungrab_device_checked (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_ungrab_device (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t device_id); + +int +xcb_input_grab_device_key_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_grab_device_key_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t num_classes, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t grabbed_device, + uint8_t key, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + const xcb_input_event_class_t *classes); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_grab_device_key (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t num_classes, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t grabbed_device, + uint8_t key, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + const xcb_input_event_class_t *classes); + +xcb_input_event_class_t * +xcb_input_grab_device_key_classes (const xcb_input_grab_device_key_request_t *R); + +int +xcb_input_grab_device_key_classes_length (const xcb_input_grab_device_key_request_t *R); + +xcb_generic_iterator_t +xcb_input_grab_device_key_classes_end (const xcb_input_grab_device_key_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_ungrab_device_key_checked (xcb_connection_t *c, + xcb_window_t grabWindow, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t key, + uint8_t grabbed_device); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_ungrab_device_key (xcb_connection_t *c, + xcb_window_t grabWindow, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t key, + uint8_t grabbed_device); + +int +xcb_input_grab_device_button_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_grab_device_button_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint8_t grabbed_device, + uint8_t modifier_device, + uint16_t num_classes, + uint16_t modifiers, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t button, + uint8_t owner_events, + const xcb_input_event_class_t *classes); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_grab_device_button (xcb_connection_t *c, + xcb_window_t grab_window, + uint8_t grabbed_device, + uint8_t modifier_device, + uint16_t num_classes, + uint16_t modifiers, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t button, + uint8_t owner_events, + const xcb_input_event_class_t *classes); + +xcb_input_event_class_t * +xcb_input_grab_device_button_classes (const xcb_input_grab_device_button_request_t *R); + +int +xcb_input_grab_device_button_classes_length (const xcb_input_grab_device_button_request_t *R); + +xcb_generic_iterator_t +xcb_input_grab_device_button_classes_end (const xcb_input_grab_device_button_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_ungrab_device_button_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t button, + uint8_t grabbed_device); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_ungrab_device_button (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t button, + uint8_t grabbed_device); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_allow_device_events_checked (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t mode, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_allow_device_events (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t mode, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_get_device_focus_cookie_t +xcb_input_get_device_focus (xcb_connection_t *c, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_get_device_focus_cookie_t +xcb_input_get_device_focus_unchecked (xcb_connection_t *c, + uint8_t device_id); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_get_device_focus_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_get_device_focus_reply_t * +xcb_input_get_device_focus_reply (xcb_connection_t *c, + xcb_input_get_device_focus_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_set_device_focus_checked (xcb_connection_t *c, + xcb_window_t focus, + xcb_timestamp_t time, + uint8_t revert_to, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_set_device_focus (xcb_connection_t *c, + xcb_window_t focus, + xcb_timestamp_t time, + uint8_t revert_to, + uint8_t device_id); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_kbd_feedback_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_kbd_feedback_state_t) + */ +void +xcb_input_kbd_feedback_state_next (xcb_input_kbd_feedback_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_kbd_feedback_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_kbd_feedback_state_end (xcb_input_kbd_feedback_state_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_ptr_feedback_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_ptr_feedback_state_t) + */ +void +xcb_input_ptr_feedback_state_next (xcb_input_ptr_feedback_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_ptr_feedback_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_ptr_feedback_state_end (xcb_input_ptr_feedback_state_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_integer_feedback_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_integer_feedback_state_t) + */ +void +xcb_input_integer_feedback_state_next (xcb_input_integer_feedback_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_integer_feedback_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_integer_feedback_state_end (xcb_input_integer_feedback_state_iterator_t i); + +int +xcb_input_string_feedback_state_sizeof (const void *_buffer); + +xcb_keysym_t * +xcb_input_string_feedback_state_keysyms (const xcb_input_string_feedback_state_t *R); + +int +xcb_input_string_feedback_state_keysyms_length (const xcb_input_string_feedback_state_t *R); + +xcb_generic_iterator_t +xcb_input_string_feedback_state_keysyms_end (const xcb_input_string_feedback_state_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_string_feedback_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_string_feedback_state_t) + */ +void +xcb_input_string_feedback_state_next (xcb_input_string_feedback_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_string_feedback_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_string_feedback_state_end (xcb_input_string_feedback_state_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_bell_feedback_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_bell_feedback_state_t) + */ +void +xcb_input_bell_feedback_state_next (xcb_input_bell_feedback_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_bell_feedback_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_bell_feedback_state_end (xcb_input_bell_feedback_state_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_led_feedback_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_led_feedback_state_t) + */ +void +xcb_input_led_feedback_state_next (xcb_input_led_feedback_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_led_feedback_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_led_feedback_state_end (xcb_input_led_feedback_state_iterator_t i); + +xcb_keysym_t * +xcb_input_feedback_state_data_string_keysyms (const xcb_input_feedback_state_data_t *S); + +int +xcb_input_feedback_state_data_string_keysyms_length (const xcb_input_feedback_state_t *R, + const xcb_input_feedback_state_data_t *S); + +xcb_generic_iterator_t +xcb_input_feedback_state_data_string_keysyms_end (const xcb_input_feedback_state_t *R, + const xcb_input_feedback_state_data_t *S); + +int +xcb_input_feedback_state_data_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_feedback_state_data_t *_aux); + +int +xcb_input_feedback_state_data_unpack (const void *_buffer, + uint8_t class_id, + xcb_input_feedback_state_data_t *_aux); + +int +xcb_input_feedback_state_data_sizeof (const void *_buffer, + uint8_t class_id); + +int +xcb_input_feedback_state_sizeof (const void *_buffer); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_feedback_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_feedback_state_t) + */ +void +xcb_input_feedback_state_next (xcb_input_feedback_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_feedback_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_feedback_state_end (xcb_input_feedback_state_iterator_t i); + +int +xcb_input_get_feedback_control_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_get_feedback_control_cookie_t +xcb_input_get_feedback_control (xcb_connection_t *c, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_get_feedback_control_cookie_t +xcb_input_get_feedback_control_unchecked (xcb_connection_t *c, + uint8_t device_id); + +int +xcb_input_get_feedback_control_feedbacks_length (const xcb_input_get_feedback_control_reply_t *R); + +xcb_input_feedback_state_iterator_t +xcb_input_get_feedback_control_feedbacks_iterator (const xcb_input_get_feedback_control_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_get_feedback_control_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_get_feedback_control_reply_t * +xcb_input_get_feedback_control_reply (xcb_connection_t *c, + xcb_input_get_feedback_control_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_kbd_feedback_ctl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_kbd_feedback_ctl_t) + */ +void +xcb_input_kbd_feedback_ctl_next (xcb_input_kbd_feedback_ctl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_kbd_feedback_ctl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_kbd_feedback_ctl_end (xcb_input_kbd_feedback_ctl_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_ptr_feedback_ctl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_ptr_feedback_ctl_t) + */ +void +xcb_input_ptr_feedback_ctl_next (xcb_input_ptr_feedback_ctl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_ptr_feedback_ctl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_ptr_feedback_ctl_end (xcb_input_ptr_feedback_ctl_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_integer_feedback_ctl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_integer_feedback_ctl_t) + */ +void +xcb_input_integer_feedback_ctl_next (xcb_input_integer_feedback_ctl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_integer_feedback_ctl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_integer_feedback_ctl_end (xcb_input_integer_feedback_ctl_iterator_t i); + +int +xcb_input_string_feedback_ctl_sizeof (const void *_buffer); + +xcb_keysym_t * +xcb_input_string_feedback_ctl_keysyms (const xcb_input_string_feedback_ctl_t *R); + +int +xcb_input_string_feedback_ctl_keysyms_length (const xcb_input_string_feedback_ctl_t *R); + +xcb_generic_iterator_t +xcb_input_string_feedback_ctl_keysyms_end (const xcb_input_string_feedback_ctl_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_string_feedback_ctl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_string_feedback_ctl_t) + */ +void +xcb_input_string_feedback_ctl_next (xcb_input_string_feedback_ctl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_string_feedback_ctl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_string_feedback_ctl_end (xcb_input_string_feedback_ctl_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_bell_feedback_ctl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_bell_feedback_ctl_t) + */ +void +xcb_input_bell_feedback_ctl_next (xcb_input_bell_feedback_ctl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_bell_feedback_ctl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_bell_feedback_ctl_end (xcb_input_bell_feedback_ctl_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_led_feedback_ctl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_led_feedback_ctl_t) + */ +void +xcb_input_led_feedback_ctl_next (xcb_input_led_feedback_ctl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_led_feedback_ctl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_led_feedback_ctl_end (xcb_input_led_feedback_ctl_iterator_t i); + +xcb_keysym_t * +xcb_input_feedback_ctl_data_string_keysyms (const xcb_input_feedback_ctl_data_t *S); + +int +xcb_input_feedback_ctl_data_string_keysyms_length (const xcb_input_feedback_ctl_t *R, + const xcb_input_feedback_ctl_data_t *S); + +xcb_generic_iterator_t +xcb_input_feedback_ctl_data_string_keysyms_end (const xcb_input_feedback_ctl_t *R, + const xcb_input_feedback_ctl_data_t *S); + +int +xcb_input_feedback_ctl_data_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_feedback_ctl_data_t *_aux); + +int +xcb_input_feedback_ctl_data_unpack (const void *_buffer, + uint8_t class_id, + xcb_input_feedback_ctl_data_t *_aux); + +int +xcb_input_feedback_ctl_data_sizeof (const void *_buffer, + uint8_t class_id); + +int +xcb_input_feedback_ctl_sizeof (const void *_buffer); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_feedback_ctl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_feedback_ctl_t) + */ +void +xcb_input_feedback_ctl_next (xcb_input_feedback_ctl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_feedback_ctl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_feedback_ctl_end (xcb_input_feedback_ctl_iterator_t i); + +int +xcb_input_change_feedback_control_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_change_feedback_control_checked (xcb_connection_t *c, + uint32_t mask, + uint8_t device_id, + uint8_t feedback_id, + xcb_input_feedback_ctl_t *feedback); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_change_feedback_control (xcb_connection_t *c, + uint32_t mask, + uint8_t device_id, + uint8_t feedback_id, + xcb_input_feedback_ctl_t *feedback); + +xcb_input_feedback_ctl_t * +xcb_input_change_feedback_control_feedback (const xcb_input_change_feedback_control_request_t *R); + +int +xcb_input_get_device_key_mapping_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_get_device_key_mapping_cookie_t +xcb_input_get_device_key_mapping (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t count); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_get_device_key_mapping_cookie_t +xcb_input_get_device_key_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t count); + +xcb_keysym_t * +xcb_input_get_device_key_mapping_keysyms (const xcb_input_get_device_key_mapping_reply_t *R); + +int +xcb_input_get_device_key_mapping_keysyms_length (const xcb_input_get_device_key_mapping_reply_t *R); + +xcb_generic_iterator_t +xcb_input_get_device_key_mapping_keysyms_end (const xcb_input_get_device_key_mapping_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_get_device_key_mapping_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_get_device_key_mapping_reply_t * +xcb_input_get_device_key_mapping_reply (xcb_connection_t *c, + xcb_input_get_device_key_mapping_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_change_device_key_mapping_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_change_device_key_mapping_checked (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t keysyms_per_keycode, + uint8_t keycode_count, + const xcb_keysym_t *keysyms); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_change_device_key_mapping (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t keysyms_per_keycode, + uint8_t keycode_count, + const xcb_keysym_t *keysyms); + +xcb_keysym_t * +xcb_input_change_device_key_mapping_keysyms (const xcb_input_change_device_key_mapping_request_t *R); + +int +xcb_input_change_device_key_mapping_keysyms_length (const xcb_input_change_device_key_mapping_request_t *R); + +xcb_generic_iterator_t +xcb_input_change_device_key_mapping_keysyms_end (const xcb_input_change_device_key_mapping_request_t *R); + +int +xcb_input_get_device_modifier_mapping_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_get_device_modifier_mapping_cookie_t +xcb_input_get_device_modifier_mapping (xcb_connection_t *c, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_get_device_modifier_mapping_cookie_t +xcb_input_get_device_modifier_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id); + +uint8_t * +xcb_input_get_device_modifier_mapping_keymaps (const xcb_input_get_device_modifier_mapping_reply_t *R); + +int +xcb_input_get_device_modifier_mapping_keymaps_length (const xcb_input_get_device_modifier_mapping_reply_t *R); + +xcb_generic_iterator_t +xcb_input_get_device_modifier_mapping_keymaps_end (const xcb_input_get_device_modifier_mapping_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_get_device_modifier_mapping_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_get_device_modifier_mapping_reply_t * +xcb_input_get_device_modifier_mapping_reply (xcb_connection_t *c, + xcb_input_get_device_modifier_mapping_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_set_device_modifier_mapping_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_set_device_modifier_mapping_cookie_t +xcb_input_set_device_modifier_mapping (xcb_connection_t *c, + uint8_t device_id, + uint8_t keycodes_per_modifier, + const uint8_t *keymaps); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_set_device_modifier_mapping_cookie_t +xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t keycodes_per_modifier, + const uint8_t *keymaps); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_set_device_modifier_mapping_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_set_device_modifier_mapping_reply_t * +xcb_input_set_device_modifier_mapping_reply (xcb_connection_t *c, + xcb_input_set_device_modifier_mapping_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_get_device_button_mapping_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_get_device_button_mapping_cookie_t +xcb_input_get_device_button_mapping (xcb_connection_t *c, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_get_device_button_mapping_cookie_t +xcb_input_get_device_button_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id); + +uint8_t * +xcb_input_get_device_button_mapping_map (const xcb_input_get_device_button_mapping_reply_t *R); + +int +xcb_input_get_device_button_mapping_map_length (const xcb_input_get_device_button_mapping_reply_t *R); + +xcb_generic_iterator_t +xcb_input_get_device_button_mapping_map_end (const xcb_input_get_device_button_mapping_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_get_device_button_mapping_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_get_device_button_mapping_reply_t * +xcb_input_get_device_button_mapping_reply (xcb_connection_t *c, + xcb_input_get_device_button_mapping_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_set_device_button_mapping_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_set_device_button_mapping_cookie_t +xcb_input_set_device_button_mapping (xcb_connection_t *c, + uint8_t device_id, + uint8_t map_size, + const uint8_t *map); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_set_device_button_mapping_cookie_t +xcb_input_set_device_button_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t map_size, + const uint8_t *map); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_set_device_button_mapping_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_set_device_button_mapping_reply_t * +xcb_input_set_device_button_mapping_reply (xcb_connection_t *c, + xcb_input_set_device_button_mapping_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_key_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_key_state_t) + */ +void +xcb_input_key_state_next (xcb_input_key_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_key_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_key_state_end (xcb_input_key_state_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_button_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_button_state_t) + */ +void +xcb_input_button_state_next (xcb_input_button_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_button_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_button_state_end (xcb_input_button_state_iterator_t i); + +int +xcb_input_valuator_state_sizeof (const void *_buffer); + +int32_t * +xcb_input_valuator_state_valuators (const xcb_input_valuator_state_t *R); + +int +xcb_input_valuator_state_valuators_length (const xcb_input_valuator_state_t *R); + +xcb_generic_iterator_t +xcb_input_valuator_state_valuators_end (const xcb_input_valuator_state_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_valuator_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_valuator_state_t) + */ +void +xcb_input_valuator_state_next (xcb_input_valuator_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_valuator_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_valuator_state_end (xcb_input_valuator_state_iterator_t i); + +int32_t * +xcb_input_input_state_data_valuator_valuators (const xcb_input_input_state_data_t *S); + +int +xcb_input_input_state_data_valuator_valuators_length (const xcb_input_input_state_t *R, + const xcb_input_input_state_data_t *S); + +xcb_generic_iterator_t +xcb_input_input_state_data_valuator_valuators_end (const xcb_input_input_state_t *R, + const xcb_input_input_state_data_t *S); + +int +xcb_input_input_state_data_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_input_state_data_t *_aux); + +int +xcb_input_input_state_data_unpack (const void *_buffer, + uint8_t class_id, + xcb_input_input_state_data_t *_aux); + +int +xcb_input_input_state_data_sizeof (const void *_buffer, + uint8_t class_id); + +int +xcb_input_input_state_sizeof (const void *_buffer); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_input_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_input_state_t) + */ +void +xcb_input_input_state_next (xcb_input_input_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_input_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_input_state_end (xcb_input_input_state_iterator_t i); + +int +xcb_input_query_device_state_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_query_device_state_cookie_t +xcb_input_query_device_state (xcb_connection_t *c, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_query_device_state_cookie_t +xcb_input_query_device_state_unchecked (xcb_connection_t *c, + uint8_t device_id); + +int +xcb_input_query_device_state_classes_length (const xcb_input_query_device_state_reply_t *R); + +xcb_input_input_state_iterator_t +xcb_input_query_device_state_classes_iterator (const xcb_input_query_device_state_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_query_device_state_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_query_device_state_reply_t * +xcb_input_query_device_state_reply (xcb_connection_t *c, + xcb_input_query_device_state_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_device_bell_checked (xcb_connection_t *c, + uint8_t device_id, + uint8_t feedback_id, + uint8_t feedback_class, + int8_t percent); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_device_bell (xcb_connection_t *c, + uint8_t device_id, + uint8_t feedback_id, + uint8_t feedback_class, + int8_t percent); + +int +xcb_input_set_device_valuators_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_set_device_valuators_cookie_t +xcb_input_set_device_valuators (xcb_connection_t *c, + uint8_t device_id, + uint8_t first_valuator, + uint8_t num_valuators, + const int32_t *valuators); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_set_device_valuators_cookie_t +xcb_input_set_device_valuators_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t first_valuator, + uint8_t num_valuators, + const int32_t *valuators); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_set_device_valuators_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_set_device_valuators_reply_t * +xcb_input_set_device_valuators_reply (xcb_connection_t *c, + xcb_input_set_device_valuators_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_device_resolution_state_sizeof (const void *_buffer); + +uint32_t * +xcb_input_device_resolution_state_resolution_values (const xcb_input_device_resolution_state_t *R); + +int +xcb_input_device_resolution_state_resolution_values_length (const xcb_input_device_resolution_state_t *R); + +xcb_generic_iterator_t +xcb_input_device_resolution_state_resolution_values_end (const xcb_input_device_resolution_state_t *R); + +uint32_t * +xcb_input_device_resolution_state_resolution_min (const xcb_input_device_resolution_state_t *R); + +int +xcb_input_device_resolution_state_resolution_min_length (const xcb_input_device_resolution_state_t *R); + +xcb_generic_iterator_t +xcb_input_device_resolution_state_resolution_min_end (const xcb_input_device_resolution_state_t *R); + +uint32_t * +xcb_input_device_resolution_state_resolution_max (const xcb_input_device_resolution_state_t *R); + +int +xcb_input_device_resolution_state_resolution_max_length (const xcb_input_device_resolution_state_t *R); + +xcb_generic_iterator_t +xcb_input_device_resolution_state_resolution_max_end (const xcb_input_device_resolution_state_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_resolution_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_resolution_state_t) + */ +void +xcb_input_device_resolution_state_next (xcb_input_device_resolution_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_resolution_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_resolution_state_end (xcb_input_device_resolution_state_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_abs_calib_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_abs_calib_state_t) + */ +void +xcb_input_device_abs_calib_state_next (xcb_input_device_abs_calib_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_abs_calib_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_abs_calib_state_end (xcb_input_device_abs_calib_state_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_abs_area_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_abs_area_state_t) + */ +void +xcb_input_device_abs_area_state_next (xcb_input_device_abs_area_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_abs_area_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_abs_area_state_end (xcb_input_device_abs_area_state_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_core_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_core_state_t) + */ +void +xcb_input_device_core_state_next (xcb_input_device_core_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_core_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_core_state_end (xcb_input_device_core_state_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_enable_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_enable_state_t) + */ +void +xcb_input_device_enable_state_next (xcb_input_device_enable_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_enable_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_enable_state_end (xcb_input_device_enable_state_iterator_t i); + +uint32_t * +xcb_input_device_state_data_resolution_resolution_values (const xcb_input_device_state_data_t *S); + +int +xcb_input_device_state_data_resolution_resolution_values_length (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S); + +xcb_generic_iterator_t +xcb_input_device_state_data_resolution_resolution_values_end (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S); + +uint32_t * +xcb_input_device_state_data_resolution_resolution_min (const xcb_input_device_state_data_t *S); + +int +xcb_input_device_state_data_resolution_resolution_min_length (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S); + +xcb_generic_iterator_t +xcb_input_device_state_data_resolution_resolution_min_end (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S); + +uint32_t * +xcb_input_device_state_data_resolution_resolution_max (const xcb_input_device_state_data_t *S); + +int +xcb_input_device_state_data_resolution_resolution_max_length (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S); + +xcb_generic_iterator_t +xcb_input_device_state_data_resolution_resolution_max_end (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S); + +int +xcb_input_device_state_data_serialize (void **_buffer, + uint16_t control_id, + const xcb_input_device_state_data_t *_aux); + +int +xcb_input_device_state_data_unpack (const void *_buffer, + uint16_t control_id, + xcb_input_device_state_data_t *_aux); + +int +xcb_input_device_state_data_sizeof (const void *_buffer, + uint16_t control_id); + +int +xcb_input_device_state_sizeof (const void *_buffer); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_state_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_state_t) + */ +void +xcb_input_device_state_next (xcb_input_device_state_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_state_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_state_end (xcb_input_device_state_iterator_t i); + +int +xcb_input_get_device_control_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_get_device_control_cookie_t +xcb_input_get_device_control (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_get_device_control_cookie_t +xcb_input_get_device_control_unchecked (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id); + +xcb_input_device_state_t * +xcb_input_get_device_control_control (const xcb_input_get_device_control_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_get_device_control_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_get_device_control_reply_t * +xcb_input_get_device_control_reply (xcb_connection_t *c, + xcb_input_get_device_control_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_device_resolution_ctl_sizeof (const void *_buffer); + +uint32_t * +xcb_input_device_resolution_ctl_resolution_values (const xcb_input_device_resolution_ctl_t *R); + +int +xcb_input_device_resolution_ctl_resolution_values_length (const xcb_input_device_resolution_ctl_t *R); + +xcb_generic_iterator_t +xcb_input_device_resolution_ctl_resolution_values_end (const xcb_input_device_resolution_ctl_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_resolution_ctl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_resolution_ctl_t) + */ +void +xcb_input_device_resolution_ctl_next (xcb_input_device_resolution_ctl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_resolution_ctl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_resolution_ctl_end (xcb_input_device_resolution_ctl_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_abs_calib_ctl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_abs_calib_ctl_t) + */ +void +xcb_input_device_abs_calib_ctl_next (xcb_input_device_abs_calib_ctl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_abs_calib_ctl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_abs_calib_ctl_end (xcb_input_device_abs_calib_ctl_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_abs_area_ctrl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_abs_area_ctrl_t) + */ +void +xcb_input_device_abs_area_ctrl_next (xcb_input_device_abs_area_ctrl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_abs_area_ctrl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_abs_area_ctrl_end (xcb_input_device_abs_area_ctrl_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_core_ctrl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_core_ctrl_t) + */ +void +xcb_input_device_core_ctrl_next (xcb_input_device_core_ctrl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_core_ctrl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_core_ctrl_end (xcb_input_device_core_ctrl_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_enable_ctrl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_enable_ctrl_t) + */ +void +xcb_input_device_enable_ctrl_next (xcb_input_device_enable_ctrl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_enable_ctrl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_enable_ctrl_end (xcb_input_device_enable_ctrl_iterator_t i); + +uint32_t * +xcb_input_device_ctl_data_resolution_resolution_values (const xcb_input_device_ctl_data_t *S); + +int +xcb_input_device_ctl_data_resolution_resolution_values_length (const xcb_input_device_ctl_t *R, + const xcb_input_device_ctl_data_t *S); + +xcb_generic_iterator_t +xcb_input_device_ctl_data_resolution_resolution_values_end (const xcb_input_device_ctl_t *R, + const xcb_input_device_ctl_data_t *S); + +int +xcb_input_device_ctl_data_serialize (void **_buffer, + uint16_t control_id, + const xcb_input_device_ctl_data_t *_aux); + +int +xcb_input_device_ctl_data_unpack (const void *_buffer, + uint16_t control_id, + xcb_input_device_ctl_data_t *_aux); + +int +xcb_input_device_ctl_data_sizeof (const void *_buffer, + uint16_t control_id); + +int +xcb_input_device_ctl_sizeof (const void *_buffer); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_ctl_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_ctl_t) + */ +void +xcb_input_device_ctl_next (xcb_input_device_ctl_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_ctl_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_ctl_end (xcb_input_device_ctl_iterator_t i); + +int +xcb_input_change_device_control_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_change_device_control_cookie_t +xcb_input_change_device_control (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id, + xcb_input_device_ctl_t *control); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_change_device_control_cookie_t +xcb_input_change_device_control_unchecked (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id, + xcb_input_device_ctl_t *control); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_change_device_control_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_change_device_control_reply_t * +xcb_input_change_device_control_reply (xcb_connection_t *c, + xcb_input_change_device_control_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_list_device_properties_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_list_device_properties_cookie_t +xcb_input_list_device_properties (xcb_connection_t *c, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_list_device_properties_cookie_t +xcb_input_list_device_properties_unchecked (xcb_connection_t *c, + uint8_t device_id); + +xcb_atom_t * +xcb_input_list_device_properties_atoms (const xcb_input_list_device_properties_reply_t *R); + +int +xcb_input_list_device_properties_atoms_length (const xcb_input_list_device_properties_reply_t *R); + +xcb_generic_iterator_t +xcb_input_list_device_properties_atoms_end (const xcb_input_list_device_properties_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_list_device_properties_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_list_device_properties_reply_t * +xcb_input_list_device_properties_reply (xcb_connection_t *c, + xcb_input_list_device_properties_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +uint8_t * +xcb_input_change_device_property_items_data_8 (const xcb_input_change_device_property_items_t *S); + +int +xcb_input_change_device_property_items_data_8_length (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S); + +xcb_generic_iterator_t +xcb_input_change_device_property_items_data_8_end (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S); + +uint16_t * +xcb_input_change_device_property_items_data_16 (const xcb_input_change_device_property_items_t *S); + +int +xcb_input_change_device_property_items_data_16_length (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S); + +xcb_generic_iterator_t +xcb_input_change_device_property_items_data_16_end (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S); + +uint32_t * +xcb_input_change_device_property_items_data_32 (const xcb_input_change_device_property_items_t *S); + +int +xcb_input_change_device_property_items_data_32_length (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S); + +xcb_generic_iterator_t +xcb_input_change_device_property_items_data_32_end (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S); + +int +xcb_input_change_device_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_change_device_property_items_t *_aux); + +int +xcb_input_change_device_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_change_device_property_items_t *_aux); + +int +xcb_input_change_device_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format); + +int +xcb_input_change_device_property_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_change_device_property_checked (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const void *items); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_change_device_property (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const void *items); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_change_device_property_aux_checked (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const xcb_input_change_device_property_items_t *items); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_change_device_property_aux (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const xcb_input_change_device_property_items_t *items); + +void * +xcb_input_change_device_property_items (const xcb_input_change_device_property_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_delete_device_property_checked (xcb_connection_t *c, + xcb_atom_t property, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_delete_device_property (xcb_connection_t *c, + xcb_atom_t property, + uint8_t device_id); + +uint8_t * +xcb_input_get_device_property_items_data_8 (const xcb_input_get_device_property_items_t *S); + +int +xcb_input_get_device_property_items_data_8_length (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S); + +xcb_generic_iterator_t +xcb_input_get_device_property_items_data_8_end (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S); + +uint16_t * +xcb_input_get_device_property_items_data_16 (const xcb_input_get_device_property_items_t *S); + +int +xcb_input_get_device_property_items_data_16_length (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S); + +xcb_generic_iterator_t +xcb_input_get_device_property_items_data_16_end (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S); + +uint32_t * +xcb_input_get_device_property_items_data_32 (const xcb_input_get_device_property_items_t *S); + +int +xcb_input_get_device_property_items_data_32_length (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S); + +xcb_generic_iterator_t +xcb_input_get_device_property_items_data_32_end (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S); + +int +xcb_input_get_device_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_get_device_property_items_t *_aux); + +int +xcb_input_get_device_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_get_device_property_items_t *_aux); + +int +xcb_input_get_device_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format); + +int +xcb_input_get_device_property_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_get_device_property_cookie_t +xcb_input_get_device_property (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len, + uint8_t device_id, + uint8_t _delete); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_get_device_property_cookie_t +xcb_input_get_device_property_unchecked (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len, + uint8_t device_id, + uint8_t _delete); + +void * +xcb_input_get_device_property_items (const xcb_input_get_device_property_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_get_device_property_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_get_device_property_reply_t * +xcb_input_get_device_property_reply (xcb_connection_t *c, + xcb_input_get_device_property_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_group_info_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_group_info_t) + */ +void +xcb_input_group_info_next (xcb_input_group_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_group_info_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_group_info_end (xcb_input_group_info_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_modifier_info_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_modifier_info_t) + */ +void +xcb_input_modifier_info_next (xcb_input_modifier_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_modifier_info_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_modifier_info_end (xcb_input_modifier_info_iterator_t i); + +int +xcb_input_xi_query_pointer_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_xi_query_pointer_cookie_t +xcb_input_xi_query_pointer (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_xi_query_pointer_cookie_t +xcb_input_xi_query_pointer_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid); + +uint32_t * +xcb_input_xi_query_pointer_buttons (const xcb_input_xi_query_pointer_reply_t *R); + +int +xcb_input_xi_query_pointer_buttons_length (const xcb_input_xi_query_pointer_reply_t *R); + +xcb_generic_iterator_t +xcb_input_xi_query_pointer_buttons_end (const xcb_input_xi_query_pointer_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_xi_query_pointer_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_xi_query_pointer_reply_t * +xcb_input_xi_query_pointer_reply (xcb_connection_t *c, + xcb_input_xi_query_pointer_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_xi_warp_pointer_checked (xcb_connection_t *c, + xcb_window_t src_win, + xcb_window_t dst_win, + xcb_input_fp1616_t src_x, + xcb_input_fp1616_t src_y, + uint16_t src_width, + uint16_t src_height, + xcb_input_fp1616_t dst_x, + xcb_input_fp1616_t dst_y, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_xi_warp_pointer (xcb_connection_t *c, + xcb_window_t src_win, + xcb_window_t dst_win, + xcb_input_fp1616_t src_x, + xcb_input_fp1616_t src_y, + uint16_t src_width, + uint16_t src_height, + xcb_input_fp1616_t dst_x, + xcb_input_fp1616_t dst_y, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_xi_change_cursor_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_xi_change_cursor (xcb_connection_t *c, + xcb_window_t window, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid); + +int +xcb_input_add_master_sizeof (const void *_buffer); + +char * +xcb_input_add_master_name (const xcb_input_add_master_t *R); + +int +xcb_input_add_master_name_length (const xcb_input_add_master_t *R); + +xcb_generic_iterator_t +xcb_input_add_master_name_end (const xcb_input_add_master_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_add_master_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_add_master_t) + */ +void +xcb_input_add_master_next (xcb_input_add_master_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_add_master_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_add_master_end (xcb_input_add_master_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_remove_master_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_remove_master_t) + */ +void +xcb_input_remove_master_next (xcb_input_remove_master_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_remove_master_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_remove_master_end (xcb_input_remove_master_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_attach_slave_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_attach_slave_t) + */ +void +xcb_input_attach_slave_next (xcb_input_attach_slave_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_attach_slave_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_attach_slave_end (xcb_input_attach_slave_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_detach_slave_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_detach_slave_t) + */ +void +xcb_input_detach_slave_next (xcb_input_detach_slave_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_detach_slave_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_detach_slave_end (xcb_input_detach_slave_iterator_t i); + +char * +xcb_input_hierarchy_change_data_add_master_name (const xcb_input_hierarchy_change_data_t *S); + +int +xcb_input_hierarchy_change_data_add_master_name_length (const xcb_input_hierarchy_change_t *R, + const xcb_input_hierarchy_change_data_t *S); + +xcb_generic_iterator_t +xcb_input_hierarchy_change_data_add_master_name_end (const xcb_input_hierarchy_change_t *R, + const xcb_input_hierarchy_change_data_t *S); + +int +xcb_input_hierarchy_change_data_serialize (void **_buffer, + uint16_t type, + const xcb_input_hierarchy_change_data_t *_aux); + +int +xcb_input_hierarchy_change_data_unpack (const void *_buffer, + uint16_t type, + xcb_input_hierarchy_change_data_t *_aux); + +int +xcb_input_hierarchy_change_data_sizeof (const void *_buffer, + uint16_t type); + +int +xcb_input_hierarchy_change_sizeof (const void *_buffer); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_hierarchy_change_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_hierarchy_change_t) + */ +void +xcb_input_hierarchy_change_next (xcb_input_hierarchy_change_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_hierarchy_change_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_hierarchy_change_end (xcb_input_hierarchy_change_iterator_t i); + +int +xcb_input_xi_change_hierarchy_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_xi_change_hierarchy_checked (xcb_connection_t *c, + uint8_t num_changes, + const xcb_input_hierarchy_change_t *changes); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_xi_change_hierarchy (xcb_connection_t *c, + uint8_t num_changes, + const xcb_input_hierarchy_change_t *changes); + +int +xcb_input_xi_change_hierarchy_changes_length (const xcb_input_xi_change_hierarchy_request_t *R); + +xcb_input_hierarchy_change_iterator_t +xcb_input_xi_change_hierarchy_changes_iterator (const xcb_input_xi_change_hierarchy_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_xi_set_client_pointer_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_xi_set_client_pointer (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_xi_get_client_pointer_cookie_t +xcb_input_xi_get_client_pointer (xcb_connection_t *c, + xcb_window_t window); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_xi_get_client_pointer_cookie_t +xcb_input_xi_get_client_pointer_unchecked (xcb_connection_t *c, + xcb_window_t window); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_xi_get_client_pointer_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_xi_get_client_pointer_reply_t * +xcb_input_xi_get_client_pointer_reply (xcb_connection_t *c, + xcb_input_xi_get_client_pointer_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_event_mask_sizeof (const void *_buffer); + +uint32_t * +xcb_input_event_mask_mask (const xcb_input_event_mask_t *R); + +int +xcb_input_event_mask_mask_length (const xcb_input_event_mask_t *R); + +xcb_generic_iterator_t +xcb_input_event_mask_mask_end (const xcb_input_event_mask_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_event_mask_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_event_mask_t) + */ +void +xcb_input_event_mask_next (xcb_input_event_mask_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_event_mask_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_event_mask_end (xcb_input_event_mask_iterator_t i); + +int +xcb_input_xi_select_events_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_xi_select_events_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_mask, + const xcb_input_event_mask_t *masks); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_xi_select_events (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_mask, + const xcb_input_event_mask_t *masks); + +int +xcb_input_xi_select_events_masks_length (const xcb_input_xi_select_events_request_t *R); + +xcb_input_event_mask_iterator_t +xcb_input_xi_select_events_masks_iterator (const xcb_input_xi_select_events_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_xi_query_version_cookie_t +xcb_input_xi_query_version (xcb_connection_t *c, + uint16_t major_version, + uint16_t minor_version); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_xi_query_version_cookie_t +xcb_input_xi_query_version_unchecked (xcb_connection_t *c, + uint16_t major_version, + uint16_t minor_version); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_xi_query_version_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_xi_query_version_reply_t * +xcb_input_xi_query_version_reply (xcb_connection_t *c, + xcb_input_xi_query_version_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_button_class_sizeof (const void *_buffer); + +uint32_t * +xcb_input_button_class_state (const xcb_input_button_class_t *R); + +int +xcb_input_button_class_state_length (const xcb_input_button_class_t *R); + +xcb_generic_iterator_t +xcb_input_button_class_state_end (const xcb_input_button_class_t *R); + +xcb_atom_t * +xcb_input_button_class_labels (const xcb_input_button_class_t *R); + +int +xcb_input_button_class_labels_length (const xcb_input_button_class_t *R); + +xcb_generic_iterator_t +xcb_input_button_class_labels_end (const xcb_input_button_class_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_button_class_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_button_class_t) + */ +void +xcb_input_button_class_next (xcb_input_button_class_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_button_class_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_button_class_end (xcb_input_button_class_iterator_t i); + +int +xcb_input_key_class_sizeof (const void *_buffer); + +uint32_t * +xcb_input_key_class_keys (const xcb_input_key_class_t *R); + +int +xcb_input_key_class_keys_length (const xcb_input_key_class_t *R); + +xcb_generic_iterator_t +xcb_input_key_class_keys_end (const xcb_input_key_class_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_key_class_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_key_class_t) + */ +void +xcb_input_key_class_next (xcb_input_key_class_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_key_class_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_key_class_end (xcb_input_key_class_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_scroll_class_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_scroll_class_t) + */ +void +xcb_input_scroll_class_next (xcb_input_scroll_class_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_scroll_class_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_scroll_class_end (xcb_input_scroll_class_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_touch_class_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_touch_class_t) + */ +void +xcb_input_touch_class_next (xcb_input_touch_class_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_touch_class_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_touch_class_end (xcb_input_touch_class_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_valuator_class_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_valuator_class_t) + */ +void +xcb_input_valuator_class_next (xcb_input_valuator_class_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_valuator_class_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_valuator_class_end (xcb_input_valuator_class_iterator_t i); + +uint32_t * +xcb_input_device_class_data_key_keys (const xcb_input_device_class_data_t *S); + +int +xcb_input_device_class_data_key_keys_length (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S); + +xcb_generic_iterator_t +xcb_input_device_class_data_key_keys_end (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S); + +uint32_t * +xcb_input_device_class_data_button_state (const xcb_input_device_class_data_t *S); + +int +xcb_input_device_class_data_button_state_length (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S); + +xcb_generic_iterator_t +xcb_input_device_class_data_button_state_end (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S); + +xcb_atom_t * +xcb_input_device_class_data_button_labels (const xcb_input_device_class_data_t *S); + +int +xcb_input_device_class_data_button_labels_length (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S); + +xcb_generic_iterator_t +xcb_input_device_class_data_button_labels_end (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S); + +int +xcb_input_device_class_data_serialize (void **_buffer, + uint16_t type, + const xcb_input_device_class_data_t *_aux); + +int +xcb_input_device_class_data_unpack (const void *_buffer, + uint16_t type, + xcb_input_device_class_data_t *_aux); + +int +xcb_input_device_class_data_sizeof (const void *_buffer, + uint16_t type); + +int +xcb_input_device_class_sizeof (const void *_buffer); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_device_class_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_device_class_t) + */ +void +xcb_input_device_class_next (xcb_input_device_class_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_device_class_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_device_class_end (xcb_input_device_class_iterator_t i); + +int +xcb_input_xi_device_info_sizeof (const void *_buffer); + +char * +xcb_input_xi_device_info_name (const xcb_input_xi_device_info_t *R); + +int +xcb_input_xi_device_info_name_length (const xcb_input_xi_device_info_t *R); + +xcb_generic_iterator_t +xcb_input_xi_device_info_name_end (const xcb_input_xi_device_info_t *R); + +int +xcb_input_xi_device_info_classes_length (const xcb_input_xi_device_info_t *R); + +xcb_input_device_class_iterator_t +xcb_input_xi_device_info_classes_iterator (const xcb_input_xi_device_info_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_xi_device_info_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_xi_device_info_t) + */ +void +xcb_input_xi_device_info_next (xcb_input_xi_device_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_xi_device_info_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_xi_device_info_end (xcb_input_xi_device_info_iterator_t i); + +int +xcb_input_xi_query_device_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_xi_query_device_cookie_t +xcb_input_xi_query_device (xcb_connection_t *c, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_xi_query_device_cookie_t +xcb_input_xi_query_device_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid); + +int +xcb_input_xi_query_device_infos_length (const xcb_input_xi_query_device_reply_t *R); + +xcb_input_xi_device_info_iterator_t +xcb_input_xi_query_device_infos_iterator (const xcb_input_xi_query_device_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_xi_query_device_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_xi_query_device_reply_t * +xcb_input_xi_query_device_reply (xcb_connection_t *c, + xcb_input_xi_query_device_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_xi_set_focus_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_xi_set_focus (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_xi_get_focus_cookie_t +xcb_input_xi_get_focus (xcb_connection_t *c, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_xi_get_focus_cookie_t +xcb_input_xi_get_focus_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_xi_get_focus_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_xi_get_focus_reply_t * +xcb_input_xi_get_focus_reply (xcb_connection_t *c, + xcb_input_xi_get_focus_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_xi_grab_device_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_xi_grab_device_cookie_t +xcb_input_xi_grab_device (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t paired_device_mode, + uint8_t owner_events, + uint16_t mask_len, + const uint32_t *mask); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_xi_grab_device_cookie_t +xcb_input_xi_grab_device_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t paired_device_mode, + uint8_t owner_events, + uint16_t mask_len, + const uint32_t *mask); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_xi_grab_device_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_xi_grab_device_reply_t * +xcb_input_xi_grab_device_reply (xcb_connection_t *c, + xcb_input_xi_grab_device_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_xi_ungrab_device_checked (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_xi_ungrab_device (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_xi_allow_events_checked (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid, + uint8_t event_mode, + uint32_t touchid, + xcb_window_t grab_window); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_xi_allow_events (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid, + uint8_t event_mode, + uint32_t touchid, + xcb_window_t grab_window); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_grab_modifier_info_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_grab_modifier_info_t) + */ +void +xcb_input_grab_modifier_info_next (xcb_input_grab_modifier_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_grab_modifier_info_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_grab_modifier_info_end (xcb_input_grab_modifier_info_iterator_t i); + +int +xcb_input_xi_passive_grab_device_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_xi_passive_grab_device_cookie_t +xcb_input_xi_passive_grab_device (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_window_t grab_window, + xcb_cursor_t cursor, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint16_t mask_len, + uint8_t grab_type, + uint8_t grab_mode, + uint8_t paired_device_mode, + uint8_t owner_events, + const uint32_t *mask, + const uint32_t *modifiers); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_xi_passive_grab_device_cookie_t +xcb_input_xi_passive_grab_device_unchecked (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_window_t grab_window, + xcb_cursor_t cursor, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint16_t mask_len, + uint8_t grab_type, + uint8_t grab_mode, + uint8_t paired_device_mode, + uint8_t owner_events, + const uint32_t *mask, + const uint32_t *modifiers); + +xcb_input_grab_modifier_info_t * +xcb_input_xi_passive_grab_device_modifiers (const xcb_input_xi_passive_grab_device_reply_t *R); + +int +xcb_input_xi_passive_grab_device_modifiers_length (const xcb_input_xi_passive_grab_device_reply_t *R); + +xcb_input_grab_modifier_info_iterator_t +xcb_input_xi_passive_grab_device_modifiers_iterator (const xcb_input_xi_passive_grab_device_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_xi_passive_grab_device_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_xi_passive_grab_device_reply_t * +xcb_input_xi_passive_grab_device_reply (xcb_connection_t *c, + xcb_input_xi_passive_grab_device_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_xi_passive_ungrab_device_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_xi_passive_ungrab_device_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint8_t grab_type, + const uint32_t *modifiers); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_xi_passive_ungrab_device (xcb_connection_t *c, + xcb_window_t grab_window, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint8_t grab_type, + const uint32_t *modifiers); + +uint32_t * +xcb_input_xi_passive_ungrab_device_modifiers (const xcb_input_xi_passive_ungrab_device_request_t *R); + +int +xcb_input_xi_passive_ungrab_device_modifiers_length (const xcb_input_xi_passive_ungrab_device_request_t *R); + +xcb_generic_iterator_t +xcb_input_xi_passive_ungrab_device_modifiers_end (const xcb_input_xi_passive_ungrab_device_request_t *R); + +int +xcb_input_xi_list_properties_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_xi_list_properties_cookie_t +xcb_input_xi_list_properties (xcb_connection_t *c, + xcb_input_device_id_t deviceid); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_xi_list_properties_cookie_t +xcb_input_xi_list_properties_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid); + +xcb_atom_t * +xcb_input_xi_list_properties_properties (const xcb_input_xi_list_properties_reply_t *R); + +int +xcb_input_xi_list_properties_properties_length (const xcb_input_xi_list_properties_reply_t *R); + +xcb_generic_iterator_t +xcb_input_xi_list_properties_properties_end (const xcb_input_xi_list_properties_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_xi_list_properties_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_xi_list_properties_reply_t * +xcb_input_xi_list_properties_reply (xcb_connection_t *c, + xcb_input_xi_list_properties_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +uint8_t * +xcb_input_xi_change_property_items_data_8 (const xcb_input_xi_change_property_items_t *S); + +int +xcb_input_xi_change_property_items_data_8_length (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S); + +xcb_generic_iterator_t +xcb_input_xi_change_property_items_data_8_end (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S); + +uint16_t * +xcb_input_xi_change_property_items_data_16 (const xcb_input_xi_change_property_items_t *S); + +int +xcb_input_xi_change_property_items_data_16_length (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S); + +xcb_generic_iterator_t +xcb_input_xi_change_property_items_data_16_end (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S); + +uint32_t * +xcb_input_xi_change_property_items_data_32 (const xcb_input_xi_change_property_items_t *S); + +int +xcb_input_xi_change_property_items_data_32_length (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S); + +xcb_generic_iterator_t +xcb_input_xi_change_property_items_data_32_end (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S); + +int +xcb_input_xi_change_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_xi_change_property_items_t *_aux); + +int +xcb_input_xi_change_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_xi_change_property_items_t *_aux); + +int +xcb_input_xi_change_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format); + +int +xcb_input_xi_change_property_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_xi_change_property_checked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const void *items); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_xi_change_property (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const void *items); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_xi_change_property_aux_checked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const xcb_input_xi_change_property_items_t *items); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_xi_change_property_aux (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const xcb_input_xi_change_property_items_t *items); + +void * +xcb_input_xi_change_property_items (const xcb_input_xi_change_property_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_xi_delete_property_checked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + xcb_atom_t property); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_xi_delete_property (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + xcb_atom_t property); + +uint8_t * +xcb_input_xi_get_property_items_data_8 (const xcb_input_xi_get_property_items_t *S); + +int +xcb_input_xi_get_property_items_data_8_length (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S); + +xcb_generic_iterator_t +xcb_input_xi_get_property_items_data_8_end (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S); + +uint16_t * +xcb_input_xi_get_property_items_data_16 (const xcb_input_xi_get_property_items_t *S); + +int +xcb_input_xi_get_property_items_data_16_length (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S); + +xcb_generic_iterator_t +xcb_input_xi_get_property_items_data_16_end (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S); + +uint32_t * +xcb_input_xi_get_property_items_data_32 (const xcb_input_xi_get_property_items_t *S); + +int +xcb_input_xi_get_property_items_data_32_length (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S); + +xcb_generic_iterator_t +xcb_input_xi_get_property_items_data_32_end (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S); + +int +xcb_input_xi_get_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_xi_get_property_items_t *_aux); + +int +xcb_input_xi_get_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_xi_get_property_items_t *_aux); + +int +xcb_input_xi_get_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format); + +int +xcb_input_xi_get_property_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_xi_get_property_cookie_t +xcb_input_xi_get_property (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t _delete, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_xi_get_property_cookie_t +xcb_input_xi_get_property_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t _delete, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len); + +void * +xcb_input_xi_get_property_items (const xcb_input_xi_get_property_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_xi_get_property_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_xi_get_property_reply_t * +xcb_input_xi_get_property_reply (xcb_connection_t *c, + xcb_input_xi_get_property_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_xi_get_selected_events_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_input_xi_get_selected_events_cookie_t +xcb_input_xi_get_selected_events (xcb_connection_t *c, + xcb_window_t window); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_input_xi_get_selected_events_cookie_t +xcb_input_xi_get_selected_events_unchecked (xcb_connection_t *c, + xcb_window_t window); + +int +xcb_input_xi_get_selected_events_masks_length (const xcb_input_xi_get_selected_events_reply_t *R); + +xcb_input_event_mask_iterator_t +xcb_input_xi_get_selected_events_masks_iterator (const xcb_input_xi_get_selected_events_reply_t *R); + +/** + * Return the reply + * @param c The connection + * @param cookie The cookie + * @param e The xcb_generic_error_t supplied + * + * Returns the reply of the request asked by + * + * The parameter @p e supplied to this function must be NULL if + * xcb_input_xi_get_selected_events_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_input_xi_get_selected_events_reply_t * +xcb_input_xi_get_selected_events_reply (xcb_connection_t *c, + xcb_input_xi_get_selected_events_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_input_device_changed_sizeof (const void *_buffer); + +int +xcb_input_device_changed_classes_length (const xcb_input_device_changed_event_t *R); + +xcb_input_device_class_iterator_t +xcb_input_device_changed_classes_iterator (const xcb_input_device_changed_event_t *R); + +int +xcb_input_key_press_sizeof (const void *_buffer); + +uint32_t * +xcb_input_key_press_button_mask (const xcb_input_key_press_event_t *R); + +int +xcb_input_key_press_button_mask_length (const xcb_input_key_press_event_t *R); + +xcb_generic_iterator_t +xcb_input_key_press_button_mask_end (const xcb_input_key_press_event_t *R); + +uint32_t * +xcb_input_key_press_valuator_mask (const xcb_input_key_press_event_t *R); + +int +xcb_input_key_press_valuator_mask_length (const xcb_input_key_press_event_t *R); + +xcb_generic_iterator_t +xcb_input_key_press_valuator_mask_end (const xcb_input_key_press_event_t *R); + +xcb_input_fp3232_t * +xcb_input_key_press_axisvalues (const xcb_input_key_press_event_t *R); + +int +xcb_input_key_press_axisvalues_length (const xcb_input_key_press_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_key_press_axisvalues_iterator (const xcb_input_key_press_event_t *R); + +int +xcb_input_key_release_sizeof (const void *_buffer /**< */); + +int +xcb_input_button_press_sizeof (const void *_buffer); + +uint32_t * +xcb_input_button_press_button_mask (const xcb_input_button_press_event_t *R); + +int +xcb_input_button_press_button_mask_length (const xcb_input_button_press_event_t *R); + +xcb_generic_iterator_t +xcb_input_button_press_button_mask_end (const xcb_input_button_press_event_t *R); + +uint32_t * +xcb_input_button_press_valuator_mask (const xcb_input_button_press_event_t *R); + +int +xcb_input_button_press_valuator_mask_length (const xcb_input_button_press_event_t *R); + +xcb_generic_iterator_t +xcb_input_button_press_valuator_mask_end (const xcb_input_button_press_event_t *R); + +xcb_input_fp3232_t * +xcb_input_button_press_axisvalues (const xcb_input_button_press_event_t *R); + +int +xcb_input_button_press_axisvalues_length (const xcb_input_button_press_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_button_press_axisvalues_iterator (const xcb_input_button_press_event_t *R); + +int +xcb_input_button_release_sizeof (const void *_buffer /**< */); + +int +xcb_input_motion_sizeof (const void *_buffer /**< */); + +int +xcb_input_enter_sizeof (const void *_buffer); + +uint32_t * +xcb_input_enter_buttons (const xcb_input_enter_event_t *R); + +int +xcb_input_enter_buttons_length (const xcb_input_enter_event_t *R); + +xcb_generic_iterator_t +xcb_input_enter_buttons_end (const xcb_input_enter_event_t *R); + +int +xcb_input_leave_sizeof (const void *_buffer /**< */); + +int +xcb_input_focus_in_sizeof (const void *_buffer /**< */); + +int +xcb_input_focus_out_sizeof (const void *_buffer /**< */); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_input_hierarchy_info_iterator_t + * + * Get the next element in the iterator. The member rem is + * decreased by one. The member data points to the next + * element. The member index is increased by sizeof(xcb_input_hierarchy_info_t) + */ +void +xcb_input_hierarchy_info_next (xcb_input_hierarchy_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_input_hierarchy_info_iterator_t + * @return The iterator pointing to the last element + * + * Set the current element in the iterator to the last element. + * The member rem is set to 0. The member data points to the + * last element. + */ +xcb_generic_iterator_t +xcb_input_hierarchy_info_end (xcb_input_hierarchy_info_iterator_t i); + +int +xcb_input_hierarchy_sizeof (const void *_buffer); + +xcb_input_hierarchy_info_t * +xcb_input_hierarchy_infos (const xcb_input_hierarchy_event_t *R); + +int +xcb_input_hierarchy_infos_length (const xcb_input_hierarchy_event_t *R); + +xcb_input_hierarchy_info_iterator_t +xcb_input_hierarchy_infos_iterator (const xcb_input_hierarchy_event_t *R); + +int +xcb_input_raw_key_press_sizeof (const void *_buffer); + +uint32_t * +xcb_input_raw_key_press_valuator_mask (const xcb_input_raw_key_press_event_t *R); + +int +xcb_input_raw_key_press_valuator_mask_length (const xcb_input_raw_key_press_event_t *R); + +xcb_generic_iterator_t +xcb_input_raw_key_press_valuator_mask_end (const xcb_input_raw_key_press_event_t *R); + +xcb_input_fp3232_t * +xcb_input_raw_key_press_axisvalues (const xcb_input_raw_key_press_event_t *R); + +int +xcb_input_raw_key_press_axisvalues_length (const xcb_input_raw_key_press_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_raw_key_press_axisvalues_iterator (const xcb_input_raw_key_press_event_t *R); + +xcb_input_fp3232_t * +xcb_input_raw_key_press_axisvalues_raw (const xcb_input_raw_key_press_event_t *R); + +int +xcb_input_raw_key_press_axisvalues_raw_length (const xcb_input_raw_key_press_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_raw_key_press_axisvalues_raw_iterator (const xcb_input_raw_key_press_event_t *R); + +int +xcb_input_raw_key_release_sizeof (const void *_buffer /**< */); + +int +xcb_input_raw_button_press_sizeof (const void *_buffer); + +uint32_t * +xcb_input_raw_button_press_valuator_mask (const xcb_input_raw_button_press_event_t *R); + +int +xcb_input_raw_button_press_valuator_mask_length (const xcb_input_raw_button_press_event_t *R); + +xcb_generic_iterator_t +xcb_input_raw_button_press_valuator_mask_end (const xcb_input_raw_button_press_event_t *R); + +xcb_input_fp3232_t * +xcb_input_raw_button_press_axisvalues (const xcb_input_raw_button_press_event_t *R); + +int +xcb_input_raw_button_press_axisvalues_length (const xcb_input_raw_button_press_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_raw_button_press_axisvalues_iterator (const xcb_input_raw_button_press_event_t *R); + +xcb_input_fp3232_t * +xcb_input_raw_button_press_axisvalues_raw (const xcb_input_raw_button_press_event_t *R); + +int +xcb_input_raw_button_press_axisvalues_raw_length (const xcb_input_raw_button_press_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_raw_button_press_axisvalues_raw_iterator (const xcb_input_raw_button_press_event_t *R); + +int +xcb_input_raw_button_release_sizeof (const void *_buffer /**< */); + +int +xcb_input_raw_motion_sizeof (const void *_buffer /**< */); + +int +xcb_input_touch_begin_sizeof (const void *_buffer); + +uint32_t * +xcb_input_touch_begin_button_mask (const xcb_input_touch_begin_event_t *R); + +int +xcb_input_touch_begin_button_mask_length (const xcb_input_touch_begin_event_t *R); + +xcb_generic_iterator_t +xcb_input_touch_begin_button_mask_end (const xcb_input_touch_begin_event_t *R); + +uint32_t * +xcb_input_touch_begin_valuator_mask (const xcb_input_touch_begin_event_t *R); + +int +xcb_input_touch_begin_valuator_mask_length (const xcb_input_touch_begin_event_t *R); + +xcb_generic_iterator_t +xcb_input_touch_begin_valuator_mask_end (const xcb_input_touch_begin_event_t *R); + +xcb_input_fp3232_t * +xcb_input_touch_begin_axisvalues (const xcb_input_touch_begin_event_t *R); + +int +xcb_input_touch_begin_axisvalues_length (const xcb_input_touch_begin_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_touch_begin_axisvalues_iterator (const xcb_input_touch_begin_event_t *R); + +int +xcb_input_touch_update_sizeof (const void *_buffer /**< */); + +int +xcb_input_touch_end_sizeof (const void *_buffer /**< */); + +int +xcb_input_raw_touch_begin_sizeof (const void *_buffer); + +uint32_t * +xcb_input_raw_touch_begin_valuator_mask (const xcb_input_raw_touch_begin_event_t *R); + +int +xcb_input_raw_touch_begin_valuator_mask_length (const xcb_input_raw_touch_begin_event_t *R); + +xcb_generic_iterator_t +xcb_input_raw_touch_begin_valuator_mask_end (const xcb_input_raw_touch_begin_event_t *R); + +xcb_input_fp3232_t * +xcb_input_raw_touch_begin_axisvalues (const xcb_input_raw_touch_begin_event_t *R); + +int +xcb_input_raw_touch_begin_axisvalues_length (const xcb_input_raw_touch_begin_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_raw_touch_begin_axisvalues_iterator (const xcb_input_raw_touch_begin_event_t *R); + +xcb_input_fp3232_t * +xcb_input_raw_touch_begin_axisvalues_raw (const xcb_input_raw_touch_begin_event_t *R); + +int +xcb_input_raw_touch_begin_axisvalues_raw_length (const xcb_input_raw_touch_begin_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_raw_touch_begin_axisvalues_raw_iterator (const xcb_input_raw_touch_begin_event_t *R); + +int +xcb_input_raw_touch_update_sizeof (const void *_buffer /**< */); + +int +xcb_input_raw_touch_end_sizeof (const void *_buffer /**< */); + +#ifdef __cplusplus +} +#endif + +#endif + +/** + * @} + */ diff --git a/src/3rdparty/xcb/libxcb/randr.c b/src/3rdparty/xcb/libxcb/randr.c index 1956ee033e..0232af802f 100644 --- a/src/3rdparty/xcb/libxcb/randr.c +++ b/src/3rdparty/xcb/libxcb/randr.c @@ -3,10 +3,17 @@ * Edit at your peril. */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include <stdlib.h> #include <string.h> #include <assert.h> +#include <stddef.h> /* for offsetof() */ #include "xcbext.h" #include "randr.h" + +#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) #include "xproto.h" #include "render.h" @@ -164,6 +171,35 @@ xcb_randr_screen_size_end (xcb_randr_screen_size_iterator_t i /**< */) return ret; } +int +xcb_randr_refresh_rates_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_refresh_rates_t *_aux = (xcb_randr_refresh_rates_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_refresh_rates_t); + xcb_tmp += xcb_block_len; + /* rates */ + xcb_block_len += _aux->nRates * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -230,10 +266,11 @@ void xcb_randr_refresh_rates_next (xcb_randr_refresh_rates_iterator_t *i /**< */) { xcb_randr_refresh_rates_t *R = i->data; - xcb_generic_iterator_t child = xcb_randr_refresh_rates_rates_end(R); + xcb_generic_iterator_t child; + child.data = (xcb_randr_refresh_rates_t *)(((char *)R) + xcb_randr_refresh_rates_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; --i->rem; i->data = (xcb_randr_refresh_rates_t *) child.data; - i->index = child.index; } @@ -293,6 +330,7 @@ xcb_randr_query_version (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -332,6 +370,7 @@ xcb_randr_query_version_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -404,6 +443,7 @@ xcb_randr_set_screen_config (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -456,6 +496,7 @@ xcb_randr_set_screen_config_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -516,6 +557,7 @@ xcb_randr_select_input_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -556,10 +598,57 @@ xcb_randr_select_input (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_randr_get_screen_info_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_get_screen_info_reply_t *_aux = (xcb_randr_get_screen_info_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_randr_get_screen_info_reply_t); + xcb_tmp += xcb_block_len; + /* sizes */ + xcb_block_len += _aux->nSizes * sizeof(xcb_randr_screen_size_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_screen_size_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* rates */ + for(i=0; i<(_aux->nInfo - _aux->nSizes); i++) { + xcb_tmp_len = xcb_randr_refresh_rates_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_randr_refresh_rates_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -592,6 +681,7 @@ xcb_randr_get_screen_info (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -628,6 +718,7 @@ xcb_randr_get_screen_info_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -773,6 +864,7 @@ xcb_randr_get_screen_size_range (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -809,6 +901,7 @@ xcb_randr_get_screen_size_range_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -877,6 +970,7 @@ xcb_randr_set_screen_size_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -925,6 +1019,7 @@ xcb_randr_set_screen_size (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -967,6 +1062,71 @@ xcb_randr_mode_info_end (xcb_randr_mode_info_iterator_t i /**< */) return ret; } +int +xcb_randr_get_screen_resources_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_get_screen_resources_reply_t *_aux = (xcb_randr_get_screen_resources_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_get_screen_resources_reply_t); + xcb_tmp += xcb_block_len; + /* crtcs */ + xcb_block_len += _aux->num_crtcs * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_crtc_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* outputs */ + xcb_block_len += _aux->num_outputs * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_output_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* modes */ + xcb_block_len += _aux->num_modes * sizeof(xcb_randr_mode_info_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_mode_info_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* names */ + xcb_block_len += _aux->names_len * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -999,6 +1159,7 @@ xcb_randr_get_screen_resources (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1035,6 +1196,7 @@ xcb_randr_get_screen_resources_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1273,6 +1435,71 @@ xcb_randr_get_screen_resources_reply (xcb_connection_t * return (xcb_randr_get_screen_resources_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_randr_get_output_info_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_get_output_info_reply_t *_aux = (xcb_randr_get_output_info_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_get_output_info_reply_t); + xcb_tmp += xcb_block_len; + /* crtcs */ + xcb_block_len += _aux->num_crtcs * sizeof(xcb_randr_output_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_crtc_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* modes */ + xcb_block_len += _aux->num_modes * sizeof(xcb_randr_output_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_mode_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* clones */ + xcb_block_len += _aux->num_clones * sizeof(xcb_randr_output_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_output_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* name */ + xcb_block_len += _aux->name_len * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1308,6 +1535,7 @@ xcb_randr_get_output_info (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1347,6 +1575,7 @@ xcb_randr_get_output_info_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1585,6 +1814,35 @@ xcb_randr_get_output_info_reply (xcb_connection_t *c /**< */ return (xcb_randr_get_output_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_randr_list_output_properties_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_list_output_properties_reply_t *_aux = (xcb_randr_list_output_properties_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_list_output_properties_reply_t); + xcb_tmp += xcb_block_len; + /* atoms */ + xcb_block_len += _aux->num_atoms * sizeof(xcb_atom_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_atom_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1617,6 +1875,7 @@ xcb_randr_list_output_properties (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1653,6 +1912,7 @@ xcb_randr_list_output_properties_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1729,6 +1989,35 @@ xcb_randr_list_output_properties_reply (xcb_connection_t return (xcb_randr_list_output_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_randr_query_output_property_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_query_output_property_reply_t *_aux = (xcb_randr_query_output_property_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_query_output_property_reply_t); + xcb_tmp += xcb_block_len; + /* validValues */ + xcb_block_len += _aux->length * sizeof(int32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(int32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1764,6 +2053,7 @@ xcb_randr_query_output_property (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1803,6 +2093,7 @@ xcb_randr_query_output_property_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1879,6 +2170,35 @@ xcb_randr_query_output_property_reply (xcb_connection_t return (xcb_randr_query_output_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_randr_configure_output_property_sizeof (const void *_buffer /**< */, + uint32_t values_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_configure_output_property_request_t); + xcb_tmp += xcb_block_len; + /* values */ + xcb_block_len += values_len * sizeof(int32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(int32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1925,10 +2245,12 @@ xcb_randr_configure_output_property_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* int32_t values */ xcb_parts[4].iov_base = (char *) values; xcb_parts[4].iov_len = values_len * sizeof(int32_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1979,14 +2301,45 @@ xcb_randr_configure_output_property (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* int32_t values */ xcb_parts[4].iov_base = (char *) values; xcb_parts[4].iov_len = values_len * sizeof(int32_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_randr_change_output_property_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_change_output_property_request_t *_aux = (xcb_randr_change_output_property_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_change_output_property_request_t); + xcb_tmp += xcb_block_len; + /* data */ + xcb_block_len += ((_aux->num_units * _aux->format) / 8) * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2037,10 +2390,12 @@ xcb_randr_change_output_property_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* void data */ xcb_parts[4].iov_base = (char *) data; xcb_parts[4].iov_len = ((num_units * format) / 8) * sizeof(char); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2095,10 +2450,12 @@ xcb_randr_change_output_property (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* void data */ xcb_parts[4].iov_base = (char *) data; xcb_parts[4].iov_len = ((num_units * format) / 8) * sizeof(char); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2138,6 +2495,7 @@ xcb_randr_delete_output_property_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2177,10 +2535,40 @@ xcb_randr_delete_output_property (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_randr_get_output_property_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_get_output_property_reply_t *_aux = (xcb_randr_get_output_property_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_get_output_property_reply_t); + xcb_tmp += xcb_block_len; + /* data */ + xcb_block_len += (_aux->num_items * (_aux->format / 8)) * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2232,6 +2620,7 @@ xcb_randr_get_output_property (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2287,6 +2676,7 @@ xcb_randr_get_output_property_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2363,6 +2753,35 @@ xcb_randr_get_output_property_reply (xcb_connection_t *c return (xcb_randr_get_output_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_randr_create_mode_sizeof (const void *_buffer /**< */, + uint32_t name_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_create_mode_request_t); + xcb_tmp += xcb_block_len; + /* name */ + xcb_block_len += name_len * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2402,10 +2821,12 @@ xcb_randr_create_mode (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char name */ xcb_parts[4].iov_base = (char *) name; xcb_parts[4].iov_len = name_len * sizeof(char); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2449,10 +2870,12 @@ xcb_randr_create_mode_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char name */ xcb_parts[4].iov_base = (char *) name; xcb_parts[4].iov_len = name_len * sizeof(char); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2509,6 +2932,7 @@ xcb_randr_destroy_mode_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2545,6 +2969,7 @@ xcb_randr_destroy_mode (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2584,6 +3009,7 @@ xcb_randr_add_output_mode_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2623,6 +3049,7 @@ xcb_randr_add_output_mode (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2662,6 +3089,7 @@ xcb_randr_delete_output_mode_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2701,10 +3129,52 @@ xcb_randr_delete_output_mode (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_randr_get_crtc_info_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_get_crtc_info_reply_t *_aux = (xcb_randr_get_crtc_info_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_get_crtc_info_reply_t); + xcb_tmp += xcb_block_len; + /* outputs */ + xcb_block_len += _aux->num_outputs * sizeof(xcb_randr_output_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_output_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* possible */ + xcb_block_len += _aux->num_possible_outputs * sizeof(xcb_randr_output_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_output_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2740,6 +3210,7 @@ xcb_randr_get_crtc_info (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2779,6 +3250,7 @@ xcb_randr_get_crtc_info_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2909,6 +3381,35 @@ xcb_randr_get_crtc_info_reply (xcb_connection_t *c /**< */, return (xcb_randr_get_crtc_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_randr_set_crtc_config_sizeof (const void *_buffer /**< */, + uint32_t outputs_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_set_crtc_config_request_t); + xcb_tmp += xcb_block_len; + /* outputs */ + xcb_block_len += outputs_len * sizeof(xcb_randr_output_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_output_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2964,10 +3465,12 @@ xcb_randr_set_crtc_config (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_randr_output_t outputs */ xcb_parts[4].iov_base = (char *) outputs; xcb_parts[4].iov_len = outputs_len * sizeof(xcb_timestamp_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3027,10 +3530,12 @@ xcb_randr_set_crtc_config_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_randr_output_t outputs */ xcb_parts[4].iov_base = (char *) outputs; xcb_parts[4].iov_len = outputs_len * sizeof(xcb_timestamp_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3087,6 +3592,7 @@ xcb_randr_get_crtc_gamma_size (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3123,6 +3629,7 @@ xcb_randr_get_crtc_gamma_size_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3147,6 +3654,59 @@ xcb_randr_get_crtc_gamma_size_reply (xcb_connection_t *c return (xcb_randr_get_crtc_gamma_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_randr_get_crtc_gamma_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_get_crtc_gamma_reply_t *_aux = (xcb_randr_get_crtc_gamma_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_get_crtc_gamma_reply_t); + xcb_tmp += xcb_block_len; + /* red */ + xcb_block_len += _aux->size * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* green */ + xcb_block_len += _aux->size * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* blue */ + xcb_block_len += _aux->size * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -3179,6 +3739,7 @@ xcb_randr_get_crtc_gamma (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3215,6 +3776,7 @@ xcb_randr_get_crtc_gamma_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3399,6 +3961,59 @@ xcb_randr_get_crtc_gamma_reply (xcb_connection_t *c /**< */, return (xcb_randr_get_crtc_gamma_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_randr_set_crtc_gamma_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_set_crtc_gamma_request_t *_aux = (xcb_randr_set_crtc_gamma_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_set_crtc_gamma_request_t); + xcb_tmp += xcb_block_len; + /* red */ + xcb_block_len += _aux->size * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* green */ + xcb_block_len += _aux->size * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* blue */ + xcb_block_len += _aux->size * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -3441,18 +4056,22 @@ xcb_randr_set_crtc_gamma_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint16_t red */ xcb_parts[4].iov_base = (char *) red; xcb_parts[4].iov_len = size * sizeof(uint16_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* uint16_t green */ xcb_parts[6].iov_base = (char *) green; xcb_parts[6].iov_len = size * sizeof(uint16_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + /* uint16_t blue */ xcb_parts[8].iov_base = (char *) blue; xcb_parts[8].iov_len = size * sizeof(uint16_t); xcb_parts[9].iov_base = 0; xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3499,22 +4118,91 @@ xcb_randr_set_crtc_gamma (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint16_t red */ xcb_parts[4].iov_base = (char *) red; xcb_parts[4].iov_len = size * sizeof(uint16_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* uint16_t green */ xcb_parts[6].iov_base = (char *) green; xcb_parts[6].iov_len = size * sizeof(uint16_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + /* uint16_t blue */ xcb_parts[8].iov_base = (char *) blue; xcb_parts[8].iov_len = size * sizeof(uint16_t); xcb_parts[9].iov_base = 0; xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_randr_get_screen_resources_current_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_get_screen_resources_current_reply_t *_aux = (xcb_randr_get_screen_resources_current_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_get_screen_resources_current_reply_t); + xcb_tmp += xcb_block_len; + /* crtcs */ + xcb_block_len += _aux->num_crtcs * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_crtc_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* outputs */ + xcb_block_len += _aux->num_outputs * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_output_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* modes */ + xcb_block_len += _aux->num_modes * sizeof(xcb_randr_mode_info_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_mode_info_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* names */ + xcb_block_len += _aux->names_len * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -3547,6 +4235,7 @@ xcb_randr_get_screen_resources_current (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3583,6 +4272,7 @@ xcb_randr_get_screen_resources_current_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3821,6 +4511,48 @@ xcb_randr_get_screen_resources_current_reply (xcb_connection_t return (xcb_randr_get_screen_resources_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_randr_set_crtc_transform_sizeof (const void *_buffer /**< */, + uint32_t filter_params_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_set_crtc_transform_request_t *_aux = (xcb_randr_set_crtc_transform_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_set_crtc_transform_request_t); + xcb_tmp += xcb_block_len; + /* filter_name */ + xcb_block_len += _aux->filter_len * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* filter_params */ + xcb_block_len += filter_params_len * sizeof(xcb_render_fixed_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_fixed_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -3866,14 +4598,17 @@ xcb_randr_set_crtc_transform_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char filter_name */ xcb_parts[4].iov_base = (char *) filter_name; xcb_parts[4].iov_len = filter_len * sizeof(char); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* xcb_render_fixed_t filter_params */ xcb_parts[6].iov_base = (char *) filter_params; xcb_parts[6].iov_len = filter_params_len * sizeof(xcb_render_fixed_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3923,18 +4658,86 @@ xcb_randr_set_crtc_transform (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char filter_name */ xcb_parts[4].iov_base = (char *) filter_name; xcb_parts[4].iov_len = filter_len * sizeof(char); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* xcb_render_fixed_t filter_params */ xcb_parts[6].iov_base = (char *) filter_params; xcb_parts[6].iov_len = filter_params_len * sizeof(xcb_render_fixed_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_randr_get_crtc_transform_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_get_crtc_transform_reply_t *_aux = (xcb_randr_get_crtc_transform_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_randr_get_crtc_transform_reply_t); + xcb_tmp += xcb_block_len; + /* pending_filter_name */ + xcb_block_len += _aux->pending_len * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* pending_params */ + xcb_block_len += _aux->pending_nparams * sizeof(xcb_render_fixed_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_fixed_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* current_filter_name */ + xcb_block_len += _aux->current_len * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* current_params */ + xcb_block_len += _aux->current_nparams * sizeof(xcb_render_fixed_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_fixed_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -3967,6 +4770,7 @@ xcb_randr_get_crtc_transform (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -4003,6 +4807,7 @@ xcb_randr_get_crtc_transform_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -4273,6 +5078,7 @@ xcb_randr_get_panning (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -4309,6 +5115,7 @@ xcb_randr_get_panning_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -4404,6 +5211,7 @@ xcb_randr_set_panning (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -4479,6 +5287,7 @@ xcb_randr_set_panning_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -4538,6 +5347,7 @@ xcb_randr_set_output_primary_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -4577,6 +5387,7 @@ xcb_randr_set_output_primary (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -4613,6 +5424,7 @@ xcb_randr_get_output_primary (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -4649,6 +5461,7 @@ xcb_randr_get_output_primary_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } diff --git a/src/3rdparty/xcb/libxcb/render.c b/src/3rdparty/xcb/libxcb/render.c index b251f8814c..7e5379cfcf 100644 --- a/src/3rdparty/xcb/libxcb/render.c +++ b/src/3rdparty/xcb/libxcb/render.c @@ -3,10 +3,17 @@ * Edit at your peril. */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include <stdlib.h> #include <string.h> #include <assert.h> +#include <stddef.h> /* for offsetof() */ #include "xcbext.h" #include "render.h" + +#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) #include "xproto.h" xcb_extension_t xcb_render_id = { "RENDER", 0 }; @@ -315,6 +322,35 @@ xcb_render_pictvisual_end (xcb_render_pictvisual_iterator_t i /**< */) return ret; } +int +xcb_render_pictdepth_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_render_pictdepth_t *_aux = (xcb_render_pictdepth_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_pictdepth_t); + xcb_tmp += xcb_block_len; + /* visuals */ + xcb_block_len += _aux->num_visuals * sizeof(xcb_render_pictvisual_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_pictvisual_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -381,10 +417,11 @@ void xcb_render_pictdepth_next (xcb_render_pictdepth_iterator_t *i /**< */) { xcb_render_pictdepth_t *R = i->data; - xcb_generic_iterator_t child = xcb_render_pictvisual_end(xcb_render_pictdepth_visuals_iterator(R)); + xcb_generic_iterator_t child; + child.data = (xcb_render_pictdepth_t *)(((char *)R) + xcb_render_pictdepth_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; --i->rem; i->data = (xcb_render_pictdepth_t *) child.data; - i->index = child.index; } @@ -409,6 +446,40 @@ xcb_render_pictdepth_end (xcb_render_pictdepth_iterator_t i /**< */) return ret; } +int +xcb_render_pictscreen_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_render_pictscreen_t *_aux = (xcb_render_pictscreen_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_render_pictscreen_t); + xcb_tmp += xcb_block_len; + /* depths */ + for(i=0; i<_aux->num_depths; i++) { + xcb_tmp_len = xcb_render_pictdepth_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_render_pictdepth_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -459,10 +530,11 @@ void xcb_render_pictscreen_next (xcb_render_pictscreen_iterator_t *i /**< */) { xcb_render_pictscreen_t *R = i->data; - xcb_generic_iterator_t child = xcb_render_pictdepth_end(xcb_render_pictscreen_depths_iterator(R)); + xcb_generic_iterator_t child; + child.data = (xcb_render_pictscreen_t *)(((char *)R) + xcb_render_pictscreen_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; --i->rem; i->data = (xcb_render_pictscreen_t *) child.data; - i->index = child.index; } @@ -788,6 +860,7 @@ xcb_render_query_version (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -827,6 +900,7 @@ xcb_render_query_version_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -851,6 +925,64 @@ xcb_render_query_version_reply (xcb_connection_t *c /**< */, return (xcb_render_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_render_query_pict_formats_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_render_query_pict_formats_reply_t *_aux = (xcb_render_query_pict_formats_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_render_query_pict_formats_reply_t); + xcb_tmp += xcb_block_len; + /* formats */ + xcb_block_len += _aux->num_formats * sizeof(xcb_render_pictforminfo_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_pictforminfo_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* screens */ + for(i=0; i<_aux->num_screens; i++) { + xcb_tmp_len = xcb_render_pictscreen_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_render_pictscreen_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* subpixels */ + xcb_block_len += _aux->num_subpixel * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -880,6 +1012,7 @@ xcb_render_query_pict_formats (xcb_connection_t *c /**< */) xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -913,6 +1046,7 @@ xcb_render_query_pict_formats_unchecked (xcb_connection_t *c /**< */) xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1080,6 +1214,35 @@ xcb_render_query_pict_formats_reply (xcb_connection_t *c return (xcb_render_query_pict_formats_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_render_query_pict_index_values_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_render_query_pict_index_values_reply_t *_aux = (xcb_render_query_pict_index_values_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_query_pict_index_values_reply_t); + xcb_tmp += xcb_block_len; + /* values */ + xcb_block_len += _aux->num_values * sizeof(xcb_render_indexvalue_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_indexvalue_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1112,6 +1275,7 @@ xcb_render_query_pict_index_values (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1148,6 +1312,7 @@ xcb_render_query_pict_index_values_unchecked (xcb_connection_t *c /**< * xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1224,6 +1389,35 @@ xcb_render_query_pict_index_values_reply (xcb_connection_t return (xcb_render_query_pict_index_values_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_render_create_picture_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_render_create_picture_request_t *_aux = (xcb_render_create_picture_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_create_picture_request_t); + xcb_tmp += xcb_block_len; + /* value_list */ + xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1267,10 +1461,12 @@ xcb_render_create_picture_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t value_list */ xcb_parts[4].iov_base = (char *) value_list; xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1318,14 +1514,45 @@ xcb_render_create_picture (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t value_list */ xcb_parts[4].iov_base = (char *) value_list; xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_change_picture_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_render_change_picture_request_t *_aux = (xcb_render_change_picture_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_change_picture_request_t); + xcb_tmp += xcb_block_len; + /* value_list */ + xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1363,10 +1590,12 @@ xcb_render_change_picture_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t value_list */ xcb_parts[4].iov_base = (char *) value_list; xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1408,14 +1637,45 @@ xcb_render_change_picture (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t value_list */ xcb_parts[4].iov_base = (char *) value_list; xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_set_picture_clip_rectangles_sizeof (const void *_buffer /**< */, + uint32_t rectangles_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_set_picture_clip_rectangles_request_t); + xcb_tmp += xcb_block_len; + /* rectangles */ + xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_rectangle_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1458,10 +1718,12 @@ xcb_render_set_picture_clip_rectangles_checked (xcb_connection_t *c /**< * xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rectangles */ xcb_parts[4].iov_base = (char *) rectangles; xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1508,10 +1770,12 @@ xcb_render_set_picture_clip_rectangles (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rectangles */ xcb_parts[4].iov_base = (char *) rectangles; xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1548,6 +1812,7 @@ xcb_render_free_picture_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1584,6 +1849,7 @@ xcb_render_free_picture (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1654,6 +1920,7 @@ xcb_render_composite_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1724,10 +1991,40 @@ xcb_render_composite (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_trapezoids_sizeof (const void *_buffer /**< */, + uint32_t traps_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_trapezoids_request_t); + xcb_tmp += xcb_block_len; + /* traps */ + xcb_block_len += traps_len * sizeof(xcb_render_trapezoid_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_trapezoid_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1780,10 +2077,12 @@ xcb_render_trapezoids_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_trapezoid_t traps */ xcb_parts[4].iov_base = (char *) traps; xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trapezoid_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1840,14 +2139,45 @@ xcb_render_trapezoids (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_trapezoid_t traps */ xcb_parts[4].iov_base = (char *) traps; xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trapezoid_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_triangles_sizeof (const void *_buffer /**< */, + uint32_t triangles_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_triangles_request_t); + xcb_tmp += xcb_block_len; + /* triangles */ + xcb_block_len += triangles_len * sizeof(xcb_render_triangle_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_triangle_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1900,10 +2230,12 @@ xcb_render_triangles_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_triangle_t triangles */ xcb_parts[4].iov_base = (char *) triangles; xcb_parts[4].iov_len = triangles_len * sizeof(xcb_render_triangle_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1960,14 +2292,45 @@ xcb_render_triangles (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_triangle_t triangles */ xcb_parts[4].iov_base = (char *) triangles; xcb_parts[4].iov_len = triangles_len * sizeof(xcb_render_triangle_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_tri_strip_sizeof (const void *_buffer /**< */, + uint32_t points_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_tri_strip_request_t); + xcb_tmp += xcb_block_len; + /* points */ + xcb_block_len += points_len * sizeof(xcb_render_pointfix_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_pointfix_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2020,10 +2383,12 @@ xcb_render_tri_strip_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_pointfix_t points */ xcb_parts[4].iov_base = (char *) points; xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2080,14 +2445,45 @@ xcb_render_tri_strip (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_pointfix_t points */ xcb_parts[4].iov_base = (char *) points; xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_tri_fan_sizeof (const void *_buffer /**< */, + uint32_t points_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_tri_fan_request_t); + xcb_tmp += xcb_block_len; + /* points */ + xcb_block_len += points_len * sizeof(xcb_render_pointfix_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_pointfix_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2140,10 +2536,12 @@ xcb_render_tri_fan_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_pointfix_t points */ xcb_parts[4].iov_base = (char *) points; xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2200,10 +2598,12 @@ xcb_render_tri_fan (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_pointfix_t points */ xcb_parts[4].iov_base = (char *) points; xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2243,6 +2643,7 @@ xcb_render_create_glyph_set_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2282,6 +2683,7 @@ xcb_render_create_glyph_set (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2321,6 +2723,7 @@ xcb_render_reference_glyph_set_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2360,6 +2763,7 @@ xcb_render_reference_glyph_set (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2396,6 +2800,7 @@ xcb_render_free_glyph_set_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2432,10 +2837,65 @@ xcb_render_free_glyph_set (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_add_glyphs_sizeof (const void *_buffer /**< */, + uint32_t data_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_render_add_glyphs_request_t *_aux = (xcb_render_add_glyphs_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_add_glyphs_request_t); + xcb_tmp += xcb_block_len; + /* glyphids */ + xcb_block_len += _aux->glyphs_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* glyphs */ + xcb_block_len += _aux->glyphs_len * sizeof(xcb_render_glyphinfo_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_glyphinfo_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* data */ + xcb_block_len += data_len * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2479,18 +2939,22 @@ xcb_render_add_glyphs_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t glyphids */ xcb_parts[4].iov_base = (char *) glyphids; xcb_parts[4].iov_len = glyphs_len * sizeof(uint32_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* xcb_render_glyphinfo_t glyphs */ xcb_parts[6].iov_base = (char *) glyphs; xcb_parts[6].iov_len = glyphs_len * sizeof(xcb_render_glyphinfo_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + /* uint8_t data */ xcb_parts[8].iov_base = (char *) data; xcb_parts[8].iov_len = data_len * sizeof(uint8_t); xcb_parts[9].iov_base = 0; xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2538,22 +3002,55 @@ xcb_render_add_glyphs (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t glyphids */ xcb_parts[4].iov_base = (char *) glyphids; xcb_parts[4].iov_len = glyphs_len * sizeof(uint32_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* xcb_render_glyphinfo_t glyphs */ xcb_parts[6].iov_base = (char *) glyphs; xcb_parts[6].iov_len = glyphs_len * sizeof(xcb_render_glyphinfo_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + /* uint8_t data */ xcb_parts[8].iov_base = (char *) data; xcb_parts[8].iov_len = data_len * sizeof(uint8_t); xcb_parts[9].iov_base = 0; xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_free_glyphs_sizeof (const void *_buffer /**< */, + uint32_t glyphs_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_free_glyphs_request_t); + xcb_tmp += xcb_block_len; + /* glyphs */ + xcb_block_len += glyphs_len * sizeof(xcb_render_glyph_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_glyph_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2590,10 +3087,12 @@ xcb_render_free_glyphs_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_glyph_t glyphs */ xcb_parts[4].iov_base = (char *) glyphs; xcb_parts[4].iov_len = glyphs_len * sizeof(xcb_render_glyph_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2634,14 +3133,45 @@ xcb_render_free_glyphs (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_glyph_t glyphs */ xcb_parts[4].iov_base = (char *) glyphs; xcb_parts[4].iov_len = glyphs_len * sizeof(xcb_render_glyph_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_composite_glyphs_8_sizeof (const void *_buffer /**< */, + uint32_t glyphcmds_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_composite_glyphs_8_request_t); + xcb_tmp += xcb_block_len; + /* glyphcmds */ + xcb_block_len += glyphcmds_len * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2697,10 +3227,12 @@ xcb_render_composite_glyphs_8_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint8_t glyphcmds */ xcb_parts[4].iov_base = (char *) glyphcmds; xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2760,14 +3292,45 @@ xcb_render_composite_glyphs_8 (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint8_t glyphcmds */ xcb_parts[4].iov_base = (char *) glyphcmds; xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_composite_glyphs_16_sizeof (const void *_buffer /**< */, + uint32_t glyphcmds_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_composite_glyphs_16_request_t); + xcb_tmp += xcb_block_len; + /* glyphcmds */ + xcb_block_len += glyphcmds_len * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2823,10 +3386,12 @@ xcb_render_composite_glyphs_16_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint8_t glyphcmds */ xcb_parts[4].iov_base = (char *) glyphcmds; xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2886,14 +3451,45 @@ xcb_render_composite_glyphs_16 (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint8_t glyphcmds */ xcb_parts[4].iov_base = (char *) glyphcmds; xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_composite_glyphs_32_sizeof (const void *_buffer /**< */, + uint32_t glyphcmds_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_composite_glyphs_32_request_t); + xcb_tmp += xcb_block_len; + /* glyphcmds */ + xcb_block_len += glyphcmds_len * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2949,10 +3545,12 @@ xcb_render_composite_glyphs_32_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint8_t glyphcmds */ xcb_parts[4].iov_base = (char *) glyphcmds; xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3012,14 +3610,45 @@ xcb_render_composite_glyphs_32 (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint8_t glyphcmds */ xcb_parts[4].iov_base = (char *) glyphcmds; xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_fill_rectangles_sizeof (const void *_buffer /**< */, + uint32_t rects_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_fill_rectangles_request_t); + xcb_tmp += xcb_block_len; + /* rects */ + xcb_block_len += rects_len * sizeof(xcb_rectangle_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_rectangle_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -3063,10 +3692,12 @@ xcb_render_fill_rectangles_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rects */ xcb_parts[4].iov_base = (char *) rects; xcb_parts[4].iov_len = rects_len * sizeof(xcb_rectangle_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3114,10 +3745,12 @@ xcb_render_fill_rectangles (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rects */ xcb_parts[4].iov_base = (char *) rects; xcb_parts[4].iov_len = rects_len * sizeof(xcb_rectangle_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3163,6 +3796,7 @@ xcb_render_create_cursor_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3208,6 +3842,7 @@ xcb_render_create_cursor (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3285,6 +3920,7 @@ xcb_render_set_picture_transform_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3324,10 +3960,57 @@ xcb_render_set_picture_transform (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_query_filters_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_render_query_filters_reply_t *_aux = (xcb_render_query_filters_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_render_query_filters_reply_t); + xcb_tmp += xcb_block_len; + /* aliases */ + xcb_block_len += _aux->num_aliases * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* filters */ + for(i=0; i<_aux->num_filters; i++) { + xcb_tmp_len = xcb_str_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_str_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -3360,6 +4043,7 @@ xcb_render_query_filters (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3396,6 +4080,7 @@ xcb_render_query_filters_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3509,6 +4194,48 @@ xcb_render_query_filters_reply (xcb_connection_t *c /**< */, return (xcb_render_query_filters_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_render_set_picture_filter_sizeof (const void *_buffer /**< */, + uint32_t values_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_render_set_picture_filter_request_t *_aux = (xcb_render_set_picture_filter_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_set_picture_filter_request_t); + xcb_tmp += xcb_block_len; + /* filter */ + xcb_block_len += _aux->filter_len * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* values */ + xcb_block_len += values_len * sizeof(xcb_render_fixed_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_fixed_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -3551,14 +4278,17 @@ xcb_render_set_picture_filter_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char filter */ xcb_parts[4].iov_base = (char *) filter; xcb_parts[4].iov_len = filter_len * sizeof(char); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* xcb_render_fixed_t values */ xcb_parts[6].iov_base = (char *) values; xcb_parts[6].iov_len = values_len * sizeof(xcb_render_fixed_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3605,14 +4335,17 @@ xcb_render_set_picture_filter (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char filter */ xcb_parts[4].iov_base = (char *) filter; xcb_parts[4].iov_len = filter_len * sizeof(char); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* xcb_render_fixed_t values */ xcb_parts[6].iov_base = (char *) values; xcb_parts[6].iov_len = values_len * sizeof(xcb_render_fixed_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3655,6 +4388,35 @@ xcb_render_animcursorelt_end (xcb_render_animcursorelt_iterator_t i /**< */) return ret; } +int +xcb_render_create_anim_cursor_sizeof (const void *_buffer /**< */, + uint32_t cursors_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_create_anim_cursor_request_t); + xcb_tmp += xcb_block_len; + /* cursors */ + xcb_block_len += cursors_len * sizeof(xcb_render_animcursorelt_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_animcursorelt_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -3691,10 +4453,12 @@ xcb_render_create_anim_cursor_checked (xcb_connection_t *c /**< xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_animcursorelt_t cursors */ xcb_parts[4].iov_base = (char *) cursors; xcb_parts[4].iov_len = cursors_len * sizeof(xcb_render_animcursorelt_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3735,10 +4499,12 @@ xcb_render_create_anim_cursor (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_animcursorelt_t cursors */ xcb_parts[4].iov_base = (char *) cursors; xcb_parts[4].iov_len = cursors_len * sizeof(xcb_render_animcursorelt_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3819,6 +4585,35 @@ xcb_render_trap_end (xcb_render_trap_iterator_t i /**< */) return ret; } +int +xcb_render_add_traps_sizeof (const void *_buffer /**< */, + uint32_t traps_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_add_traps_request_t); + xcb_tmp += xcb_block_len; + /* traps */ + xcb_block_len += traps_len * sizeof(xcb_render_trap_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_trap_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -3861,10 +4656,12 @@ xcb_render_add_traps_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_trap_t traps */ xcb_parts[4].iov_base = (char *) traps; xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trap_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3911,10 +4708,12 @@ xcb_render_add_traps (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_trap_t traps */ xcb_parts[4].iov_base = (char *) traps; xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trap_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3954,6 +4753,7 @@ xcb_render_create_solid_fill_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -3993,10 +4793,52 @@ xcb_render_create_solid_fill (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_create_linear_gradient_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_render_create_linear_gradient_request_t *_aux = (xcb_render_create_linear_gradient_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_create_linear_gradient_request_t); + xcb_tmp += xcb_block_len; + /* stops */ + xcb_block_len += _aux->num_stops * sizeof(xcb_render_fixed_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_fixed_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* colors */ + xcb_block_len += _aux->num_stops * sizeof(xcb_render_color_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_color_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -4042,14 +4884,17 @@ xcb_render_create_linear_gradient_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_fixed_t stops */ xcb_parts[4].iov_base = (char *) stops; xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* xcb_render_color_t colors */ xcb_parts[6].iov_base = (char *) colors; xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -4099,18 +4944,62 @@ xcb_render_create_linear_gradient (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_fixed_t stops */ xcb_parts[4].iov_base = (char *) stops; xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* xcb_render_color_t colors */ xcb_parts[6].iov_base = (char *) colors; xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_create_radial_gradient_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_render_create_radial_gradient_request_t *_aux = (xcb_render_create_radial_gradient_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_create_radial_gradient_request_t); + xcb_tmp += xcb_block_len; + /* stops */ + xcb_block_len += _aux->num_stops * sizeof(xcb_render_fixed_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_fixed_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* colors */ + xcb_block_len += _aux->num_stops * sizeof(xcb_render_color_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_color_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -4162,14 +5051,17 @@ xcb_render_create_radial_gradient_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_fixed_t stops */ xcb_parts[4].iov_base = (char *) stops; xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* xcb_render_color_t colors */ xcb_parts[6].iov_base = (char *) colors; xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -4225,18 +5117,62 @@ xcb_render_create_radial_gradient (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_fixed_t stops */ xcb_parts[4].iov_base = (char *) stops; xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* xcb_render_color_t colors */ xcb_parts[6].iov_base = (char *) colors; xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_render_create_conical_gradient_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_render_create_conical_gradient_request_t *_aux = (xcb_render_create_conical_gradient_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_render_create_conical_gradient_request_t); + xcb_tmp += xcb_block_len; + /* stops */ + xcb_block_len += _aux->num_stops * sizeof(xcb_render_fixed_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_fixed_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* colors */ + xcb_block_len += _aux->num_stops * sizeof(xcb_render_color_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_render_color_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -4282,14 +5218,17 @@ xcb_render_create_conical_gradient_checked (xcb_connection_t *c /**< */ xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_fixed_t stops */ xcb_parts[4].iov_base = (char *) stops; xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* xcb_render_color_t colors */ xcb_parts[6].iov_base = (char *) colors; xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -4339,14 +5278,17 @@ xcb_render_create_conical_gradient (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_fixed_t stops */ xcb_parts[4].iov_base = (char *) stops; xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* xcb_render_color_t colors */ xcb_parts[6].iov_base = (char *) colors; xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } diff --git a/src/3rdparty/xcb/libxcb/shape.c b/src/3rdparty/xcb/libxcb/shape.c index 948522581e..98621c4983 100644 --- a/src/3rdparty/xcb/libxcb/shape.c +++ b/src/3rdparty/xcb/libxcb/shape.c @@ -3,10 +3,17 @@ * Edit at your peril. */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include <stdlib.h> #include <string.h> #include <assert.h> +#include <stddef.h> /* for offsetof() */ #include "xcbext.h" #include "shape.h" + +#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) #include "xproto.h" xcb_extension_t xcb_shape_id = { "SHAPE", 0 }; @@ -116,6 +123,7 @@ xcb_shape_query_version (xcb_connection_t *c /**< */) xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -149,6 +157,7 @@ xcb_shape_query_version_unchecked (xcb_connection_t *c /**< */) xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -173,6 +182,35 @@ xcb_shape_query_version_reply (xcb_connection_t *c /**< */, return (xcb_shape_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_shape_rectangles_sizeof (const void *_buffer /**< */, + uint32_t rectangles_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_shape_rectangles_request_t); + xcb_tmp += xcb_block_len; + /* rectangles */ + xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_rectangle_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -225,10 +263,12 @@ xcb_shape_rectangles_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rectangles */ xcb_parts[4].iov_base = (char *) rectangles; xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -285,10 +325,12 @@ xcb_shape_rectangles (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rectangles */ xcb_parts[4].iov_base = (char *) rectangles; xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -341,6 +383,7 @@ xcb_shape_mask_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -393,6 +436,7 @@ xcb_shape_mask (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -448,6 +492,7 @@ xcb_shape_combine_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -503,6 +548,7 @@ xcb_shape_combine (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -549,6 +595,7 @@ xcb_shape_offset_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -595,6 +642,7 @@ xcb_shape_offset (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -631,6 +679,7 @@ xcb_shape_query_extents (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -667,6 +716,7 @@ xcb_shape_query_extents_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -727,6 +777,7 @@ xcb_shape_select_input_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -767,6 +818,7 @@ xcb_shape_select_input (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -803,6 +855,7 @@ xcb_shape_input_selected (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -839,6 +892,7 @@ xcb_shape_input_selected_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -863,6 +917,35 @@ xcb_shape_input_selected_reply (xcb_connection_t *c /**< */, return (xcb_shape_input_selected_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_shape_get_rectangles_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_shape_get_rectangles_reply_t *_aux = (xcb_shape_get_rectangles_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_shape_get_rectangles_reply_t); + xcb_tmp += xcb_block_len; + /* rectangles */ + xcb_block_len += _aux->rectangles_len * sizeof(xcb_rectangle_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_rectangle_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -899,6 +982,7 @@ xcb_shape_get_rectangles (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -939,6 +1023,7 @@ xcb_shape_get_rectangles_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } diff --git a/src/3rdparty/xcb/libxcb/shm.c b/src/3rdparty/xcb/libxcb/shm.c index c1637a8654..0a1c238732 100644 --- a/src/3rdparty/xcb/libxcb/shm.c +++ b/src/3rdparty/xcb/libxcb/shm.c @@ -3,10 +3,17 @@ * Edit at your peril. */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include <stdlib.h> #include <string.h> #include <assert.h> +#include <stddef.h> /* for offsetof() */ #include "xcbext.h" #include "shm.h" + +#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) #include "xproto.h" xcb_extension_t xcb_shm_id = { "MIT-SHM", 0 }; @@ -78,6 +85,7 @@ xcb_shm_query_version (xcb_connection_t *c /**< */) xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -111,6 +119,7 @@ xcb_shm_query_version_unchecked (xcb_connection_t *c /**< */) xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -174,6 +183,7 @@ xcb_shm_attach_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -217,6 +227,7 @@ xcb_shm_attach (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -253,6 +264,7 @@ xcb_shm_detach_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -289,6 +301,7 @@ xcb_shm_detach (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -368,6 +381,7 @@ xcb_shm_put_image_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -447,6 +461,7 @@ xcb_shm_put_image (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -508,6 +523,7 @@ xcb_shm_get_image (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -569,6 +585,7 @@ xcb_shm_get_image_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -644,6 +661,7 @@ xcb_shm_create_pixmap_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -699,6 +717,7 @@ xcb_shm_create_pixmap (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } diff --git a/src/3rdparty/xcb/libxcb/support_libxcb_versions_where_xcb_sumof_not_available.patch b/src/3rdparty/xcb/libxcb/support_libxcb_versions_where_xcb_sumof_not_available.patch deleted file mode 100644 index a73e633e73..0000000000 --- a/src/3rdparty/xcb/libxcb/support_libxcb_versions_where_xcb_sumof_not_available.patch +++ /dev/null @@ -1,273 +0,0 @@ -diff --git a/src/3rdparty/xcb/libxcb/support_libxcb_versions_where_xcb_sumof_not_available.patch b/src/3rdparty/xcb/libxcb/support_libxcb_versions_where_xcb_sumof_not_available.patch -index f63719d..e69de29 100644 ---- a/src/3rdparty/xcb/libxcb/support_libxcb_versions_where_xcb_sumof_not_available.patch -+++ b/src/3rdparty/xcb/libxcb/support_libxcb_versions_where_xcb_sumof_not_available.patch -@@ -1,134 +0,0 @@ --diff --git a/src/3rdparty/xcb/libxcb/xkb.c b/src/3rdparty/xcb/libxcb/xkb.c --index d55bd76..2e3a24a 100644 ----- a/src/3rdparty/xcb/libxcb/xkb.c --+++ b/src/3rdparty/xcb/libxcb/xkb.c --@@ -18,6 +18,15 @@ -- -- xcb_extension_t xcb_xkb_id = { "XKEYBOARD", 0 }; -- --+int qt_xcb_sumof(uint8_t *list, int len) --+{ --+ int i, s = 0; --+ for(i=0; i<len; i++) { --+ s += *list; --+ list++; --+ } --+ return s; --+} -- -- /***************************************************************************** -- ** --@@ -9025,7 +9034,7 @@ int -- xcb_xkb_get_names_value_list_kt_level_names_length (const xcb_xkb_get_names_reply_t *R /**< */, -- const xcb_xkb_get_names_value_list_t *S /**< */) -- { --- return xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); --+ return (/* valueList */ S->nLevelsPerType, R->nTypes); -- } -- -- --@@ -9043,7 +9052,7 @@ xcb_xkb_get_names_value_list_kt_level_names_end (const xcb_xkb_get_names_reply_t -- const xcb_xkb_get_names_value_list_t *S /**< */) -- { -- xcb_generic_iterator_t i; --- i.data = /* valueList */ S->ktLevelNames + xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); --+ i.data = /* valueList */ S->ktLevelNames + qt_xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); -- i.rem = 0; -- i.index = (char *) i.data - (char *) S; -- return i; --@@ -9508,8 +9517,8 @@ xcb_xkb_get_names_value_list_serialize (void **_ -- xcb_block_len = 0; -- /* ktLevelNames */ -- xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames; --- xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); --- xcb_parts[xcb_parts_idx].iov_len = xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); --+ xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); --+ xcb_parts[xcb_parts_idx].iov_len = qt_xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); -- xcb_parts_idx++; -- xcb_align_to = ALIGNOF(xcb_atom_t); -- } --@@ -9762,7 +9771,7 @@ xcb_xkb_get_names_value_list_unpack (const void *_buffer / -- xcb_block_len = 0; -- /* ktLevelNames */ -- _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp; --- xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); --+ xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); -- xcb_tmp += xcb_block_len; -- xcb_align_to = ALIGNOF(xcb_atom_t); -- } --@@ -10139,7 +10148,7 @@ int -- xcb_xkb_set_names_values_kt_level_names_length (const xcb_xkb_set_names_request_t *R /**< */, -- const xcb_xkb_set_names_values_t *S /**< */) -- { --- return xcb_sumof(/* values */ S->nLevelsPerType, R->nKTLevels); --+ return qt_xcb_sumof(/* values */ S->nLevelsPerType, R->nKTLevels); -- } -- -- --@@ -10157,7 +10166,7 @@ xcb_xkb_set_names_values_kt_level_names_end (const xcb_xkb_set_names_request_t * -- const xcb_xkb_set_names_values_t *S /**< */) -- { -- xcb_generic_iterator_t i; --- i.data = /* values */ S->ktLevelNames + xcb_sumof(/* values */ S->nLevelsPerType, R->nKTLevels); --+ i.data = /* values */ S->ktLevelNames + qt_xcb_sumof(/* values */ S->nLevelsPerType, R->nKTLevels); -- i.rem = 0; -- i.index = (char *) i.data - (char *) S; -- return i; --@@ -10607,8 +10616,8 @@ xcb_xkb_set_names_values_serialize (void **_buffer -- xcb_block_len = 0; -- /* ktLevelNames */ -- xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames; --- xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); --- xcb_parts[xcb_parts_idx].iov_len = xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); --+ xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); --+ xcb_parts[xcb_parts_idx].iov_len = qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); -- xcb_parts_idx++; -- xcb_align_to = ALIGNOF(xcb_atom_t); -- } --@@ -10849,7 +10858,7 @@ xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, -- xcb_block_len = 0; -- /* ktLevelNames */ -- _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp; --- xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); --+ xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); -- xcb_tmp += xcb_block_len; -- xcb_align_to = ALIGNOF(xcb_atom_t); -- } --@@ -12872,7 +12881,7 @@ int -- xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, -- const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) -- { --- return xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nKTLevels); --+ return qt_xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nKTLevels); -- } -- -- --@@ -12890,7 +12899,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_end (const x -- const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) -- { -- xcb_generic_iterator_t i; --- i.data = /* replies */ S->key_names.valueList.ktLevelNames + xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nKTLevels); --+ i.data = /* replies */ S->key_names.valueList.ktLevelNames + qt_xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nKTLevels); -- i.rem = 0; -- i.index = (char *) i.data - (char *) S; -- return i; --@@ -13340,8 +13349,8 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void -- xcb_block_len = 0; -- /* ktLevelNames */ -- xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames; --- xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); --- xcb_parts[xcb_parts_idx].iov_len = xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); --+ xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); --+ xcb_parts[xcb_parts_idx].iov_len = qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); -- xcb_parts_idx++; -- xcb_align_to = ALIGNOF(xcb_atom_t); -- } --@@ -13582,7 +13591,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void -- xcb_block_len = 0; -- /* ktLevelNames */ -- _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp; --- xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); --+ xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); -- xcb_tmp += xcb_block_len; -- xcb_align_to = ALIGNOF(xcb_atom_t); -- } -diff --git a/src/3rdparty/xcb/libxcb/xkb.c b/src/3rdparty/xcb/libxcb/xkb.c -index d55bd76..ff025f6 100644 ---- a/src/3rdparty/xcb/libxcb/xkb.c -+++ b/src/3rdparty/xcb/libxcb/xkb.c -@@ -18,6 +18,15 @@ - - xcb_extension_t xcb_xkb_id = { "XKEYBOARD", 0 }; - -+int qt_xcb_sumof(uint8_t *list, int len) -+{ -+ int i, s = 0; -+ for(i=0; i<len; i++) { -+ s += *list; -+ list++; -+ } -+ return s; -+} - - /***************************************************************************** - ** -@@ -9025,7 +9034,7 @@ int - xcb_xkb_get_names_value_list_kt_level_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) - { -- return xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); -+ return qt_xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); - } - - -@@ -9043,7 +9052,7 @@ xcb_xkb_get_names_value_list_kt_level_names_end (const xcb_xkb_get_names_reply_t - const xcb_xkb_get_names_value_list_t *S /**< */) - { - xcb_generic_iterator_t i; -- i.data = /* valueList */ S->ktLevelNames + xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); -+ i.data = /* valueList */ S->ktLevelNames + qt_xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); - i.rem = 0; - i.index = (char *) i.data - (char *) S; - return i; -@@ -9508,8 +9517,8 @@ xcb_xkb_get_names_value_list_serialize (void **_ - xcb_block_len = 0; - /* ktLevelNames */ - xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames; -- xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); -- xcb_parts[xcb_parts_idx].iov_len = xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); -+ xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); -+ xcb_parts[xcb_parts_idx].iov_len = qt_xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); - xcb_parts_idx++; - xcb_align_to = ALIGNOF(xcb_atom_t); - } -@@ -9762,7 +9771,7 @@ xcb_xkb_get_names_value_list_unpack (const void *_buffer / - xcb_block_len = 0; - /* ktLevelNames */ - _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp; -- xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); -+ xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(xcb_atom_t); - } -@@ -10139,7 +10148,7 @@ int - xcb_xkb_set_names_values_kt_level_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) - { -- return xcb_sumof(/* values */ S->nLevelsPerType, R->nKTLevels); -+ return qt_xcb_sumof(/* values */ S->nLevelsPerType, R->nKTLevels); - } - - -@@ -10157,7 +10166,7 @@ xcb_xkb_set_names_values_kt_level_names_end (const xcb_xkb_set_names_request_t * - const xcb_xkb_set_names_values_t *S /**< */) - { - xcb_generic_iterator_t i; -- i.data = /* values */ S->ktLevelNames + xcb_sumof(/* values */ S->nLevelsPerType, R->nKTLevels); -+ i.data = /* values */ S->ktLevelNames + qt_xcb_sumof(/* values */ S->nLevelsPerType, R->nKTLevels); - i.rem = 0; - i.index = (char *) i.data - (char *) S; - return i; -@@ -10607,8 +10616,8 @@ xcb_xkb_set_names_values_serialize (void **_buffer - xcb_block_len = 0; - /* ktLevelNames */ - xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames; -- xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); -- xcb_parts[xcb_parts_idx].iov_len = xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); -+ xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); -+ xcb_parts[xcb_parts_idx].iov_len = qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); - xcb_parts_idx++; - xcb_align_to = ALIGNOF(xcb_atom_t); - } -@@ -10849,7 +10858,7 @@ xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, - xcb_block_len = 0; - /* ktLevelNames */ - _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp; -- xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); -+ xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(xcb_atom_t); - } -@@ -12872,7 +12881,7 @@ int - xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) - { -- return xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nKTLevels); -+ return qt_xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nKTLevels); - } - - -@@ -12890,7 +12899,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_end (const x - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) - { - xcb_generic_iterator_t i; -- i.data = /* replies */ S->key_names.valueList.ktLevelNames + xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nKTLevels); -+ i.data = /* replies */ S->key_names.valueList.ktLevelNames + qt_xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nKTLevels); - i.rem = 0; - i.index = (char *) i.data - (char *) S; - return i; -@@ -13340,8 +13349,8 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void - xcb_block_len = 0; - /* ktLevelNames */ - xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames; -- xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); -- xcb_parts[xcb_parts_idx].iov_len = xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); -+ xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); -+ xcb_parts[xcb_parts_idx].iov_len = qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); - xcb_parts_idx++; - xcb_align_to = ALIGNOF(xcb_atom_t); - } -@@ -13582,7 +13591,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void - xcb_block_len = 0; - /* ktLevelNames */ - _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp; -- xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); -+ xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(xcb_atom_t); - } diff --git a/src/3rdparty/xcb/libxcb/sync.c b/src/3rdparty/xcb/libxcb/sync.c index 408a263d2b..1f352756d8 100644 --- a/src/3rdparty/xcb/libxcb/sync.c +++ b/src/3rdparty/xcb/libxcb/sync.c @@ -3,10 +3,17 @@ * Edit at your peril. */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include <stdlib.h> #include <string.h> #include <assert.h> +#include <stddef.h> /* for offsetof() */ #include "xcbext.h" #include "sync.h" + +#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) #include "xproto.h" xcb_extension_t xcb_sync_id = { "SYNC", 0 }; @@ -90,6 +97,44 @@ xcb_sync_counter_end (xcb_sync_counter_iterator_t i /**< */) /***************************************************************************** ** + ** void xcb_sync_fence_next + ** + ** @param xcb_sync_fence_iterator_t *i + ** @returns void + ** + *****************************************************************************/ + +void +xcb_sync_fence_next (xcb_sync_fence_iterator_t *i /**< */) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_sync_fence_t); +} + + +/***************************************************************************** + ** + ** xcb_generic_iterator_t xcb_sync_fence_end + ** + ** @param xcb_sync_fence_iterator_t i + ** @returns xcb_generic_iterator_t + ** + *****************************************************************************/ + +xcb_generic_iterator_t +xcb_sync_fence_end (xcb_sync_fence_iterator_t i /**< */) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + + +/***************************************************************************** + ** ** void xcb_sync_int64_next ** ** @param xcb_sync_int64_iterator_t *i @@ -125,6 +170,35 @@ xcb_sync_int64_end (xcb_sync_int64_iterator_t i /**< */) return ret; } +int +xcb_sync_systemcounter_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_sync_systemcounter_t *_aux = (xcb_sync_systemcounter_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_sync_systemcounter_t); + xcb_tmp += xcb_block_len; + /* name */ + xcb_block_len += _aux->name_len * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -191,10 +265,11 @@ void xcb_sync_systemcounter_next (xcb_sync_systemcounter_iterator_t *i /**< */) { xcb_sync_systemcounter_t *R = i->data; - xcb_generic_iterator_t child = xcb_sync_systemcounter_name_end(R); + xcb_generic_iterator_t child; + child.data = (xcb_sync_systemcounter_t *)(((char *)R) + xcb_sync_systemcounter_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; --i->rem; i->data = (xcb_sync_systemcounter_t *) child.data; - i->index = child.index; } @@ -330,6 +405,7 @@ xcb_sync_initialize (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -369,6 +445,7 @@ xcb_sync_initialize_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -393,6 +470,40 @@ xcb_sync_initialize_reply (xcb_connection_t *c /**< */, return (xcb_sync_initialize_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_sync_list_system_counters_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_sync_list_system_counters_reply_t *_aux = (xcb_sync_list_system_counters_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_sync_list_system_counters_reply_t); + xcb_tmp += xcb_block_len; + /* counters */ + for(i=0; i<_aux->counters_len; i++) { + xcb_tmp_len = xcb_sync_systemcounter_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_sync_systemcounter_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -422,6 +533,7 @@ xcb_sync_list_system_counters (xcb_connection_t *c /**< */) xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -455,6 +567,7 @@ xcb_sync_list_system_counters_unchecked (xcb_connection_t *c /**< */) xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -550,6 +663,7 @@ xcb_sync_create_counter_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -589,6 +703,7 @@ xcb_sync_create_counter (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -625,6 +740,7 @@ xcb_sync_destroy_counter_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -661,6 +777,7 @@ xcb_sync_destroy_counter (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -697,6 +814,7 @@ xcb_sync_query_counter (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -733,6 +851,7 @@ xcb_sync_query_counter_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -757,6 +876,35 @@ xcb_sync_query_counter_reply (xcb_connection_t *c /**< */, return (xcb_sync_query_counter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_sync_await_sizeof (const void *_buffer /**< */, + uint32_t wait_list_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_sync_await_request_t); + xcb_tmp += xcb_block_len; + /* wait_list */ + xcb_block_len += wait_list_len * sizeof(xcb_sync_waitcondition_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_sync_waitcondition_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -790,10 +938,12 @@ xcb_sync_await_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_sync_waitcondition_t wait_list */ xcb_parts[4].iov_base = (char *) wait_list; xcb_parts[4].iov_len = wait_list_len * sizeof(xcb_sync_waitcondition_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -831,10 +981,12 @@ xcb_sync_await (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_sync_waitcondition_t wait_list */ xcb_parts[4].iov_base = (char *) wait_list; xcb_parts[4].iov_len = wait_list_len * sizeof(xcb_sync_waitcondition_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -874,6 +1026,7 @@ xcb_sync_change_counter_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -913,6 +1066,7 @@ xcb_sync_change_counter (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -952,6 +1106,7 @@ xcb_sync_set_counter_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -991,10 +1146,40 @@ xcb_sync_set_counter (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_sync_create_alarm_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_sync_create_alarm_request_t *_aux = (xcb_sync_create_alarm_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_sync_create_alarm_request_t); + xcb_tmp += xcb_block_len; + /* value_list */ + xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1032,10 +1217,12 @@ xcb_sync_create_alarm_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t value_list */ xcb_parts[4].iov_base = (char *) value_list; xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1077,14 +1264,45 @@ xcb_sync_create_alarm (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t value_list */ xcb_parts[4].iov_base = (char *) value_list; xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_sync_change_alarm_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_sync_change_alarm_request_t *_aux = (xcb_sync_change_alarm_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_sync_change_alarm_request_t); + xcb_tmp += xcb_block_len; + /* value_list */ + xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1122,10 +1340,12 @@ xcb_sync_change_alarm_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t value_list */ xcb_parts[4].iov_base = (char *) value_list; xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1167,10 +1387,12 @@ xcb_sync_change_alarm (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t value_list */ xcb_parts[4].iov_base = (char *) value_list; xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1207,6 +1429,7 @@ xcb_sync_destroy_alarm_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1243,6 +1466,7 @@ xcb_sync_destroy_alarm (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1279,6 +1503,7 @@ xcb_sync_query_alarm (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1315,6 +1540,7 @@ xcb_sync_query_alarm_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1374,6 +1600,7 @@ xcb_sync_set_priority_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1413,6 +1640,7 @@ xcb_sync_set_priority (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1449,6 +1677,7 @@ xcb_sync_get_priority (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1485,6 +1714,7 @@ xcb_sync_get_priority_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1509,3 +1739,520 @@ xcb_sync_get_priority_reply (xcb_connection_t *c /**< */, return (xcb_sync_get_priority_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_create_fence_checked + ** + ** @param xcb_connection_t *c + ** @param xcb_drawable_t drawable + ** @param xcb_sync_fence_t fence + ** @param uint8_t initially_triggered + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_create_fence_checked (xcb_connection_t *c /**< */, + xcb_drawable_t drawable /**< */, + xcb_sync_fence_t fence /**< */, + uint8_t initially_triggered /**< */) +{ + static const xcb_protocol_request_t xcb_req = { + /* count */ 2, + /* ext */ &xcb_sync_id, + /* opcode */ XCB_SYNC_CREATE_FENCE, + /* isvoid */ 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_sync_create_fence_request_t xcb_out; + + xcb_out.drawable = drawable; + xcb_out.fence = fence; + xcb_out.initially_triggered = initially_triggered; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_create_fence + ** + ** @param xcb_connection_t *c + ** @param xcb_drawable_t drawable + ** @param xcb_sync_fence_t fence + ** @param uint8_t initially_triggered + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_create_fence (xcb_connection_t *c /**< */, + xcb_drawable_t drawable /**< */, + xcb_sync_fence_t fence /**< */, + uint8_t initially_triggered /**< */) +{ + static const xcb_protocol_request_t xcb_req = { + /* count */ 2, + /* ext */ &xcb_sync_id, + /* opcode */ XCB_SYNC_CREATE_FENCE, + /* isvoid */ 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_sync_create_fence_request_t xcb_out; + + xcb_out.drawable = drawable; + xcb_out.fence = fence; + xcb_out.initially_triggered = initially_triggered; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_trigger_fence_checked + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_trigger_fence_checked (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */) +{ + static const xcb_protocol_request_t xcb_req = { + /* count */ 2, + /* ext */ &xcb_sync_id, + /* opcode */ XCB_SYNC_TRIGGER_FENCE, + /* isvoid */ 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_sync_trigger_fence_request_t xcb_out; + + xcb_out.fence = fence; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_trigger_fence + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_trigger_fence (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */) +{ + static const xcb_protocol_request_t xcb_req = { + /* count */ 2, + /* ext */ &xcb_sync_id, + /* opcode */ XCB_SYNC_TRIGGER_FENCE, + /* isvoid */ 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_sync_trigger_fence_request_t xcb_out; + + xcb_out.fence = fence; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_reset_fence_checked + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_reset_fence_checked (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */) +{ + static const xcb_protocol_request_t xcb_req = { + /* count */ 2, + /* ext */ &xcb_sync_id, + /* opcode */ XCB_SYNC_RESET_FENCE, + /* isvoid */ 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_sync_reset_fence_request_t xcb_out; + + xcb_out.fence = fence; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_reset_fence + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_reset_fence (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */) +{ + static const xcb_protocol_request_t xcb_req = { + /* count */ 2, + /* ext */ &xcb_sync_id, + /* opcode */ XCB_SYNC_RESET_FENCE, + /* isvoid */ 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_sync_reset_fence_request_t xcb_out; + + xcb_out.fence = fence; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_destroy_fence_checked + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_destroy_fence_checked (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */) +{ + static const xcb_protocol_request_t xcb_req = { + /* count */ 2, + /* ext */ &xcb_sync_id, + /* opcode */ XCB_SYNC_DESTROY_FENCE, + /* isvoid */ 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_sync_destroy_fence_request_t xcb_out; + + xcb_out.fence = fence; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_destroy_fence + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_destroy_fence (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */) +{ + static const xcb_protocol_request_t xcb_req = { + /* count */ 2, + /* ext */ &xcb_sync_id, + /* opcode */ XCB_SYNC_DESTROY_FENCE, + /* isvoid */ 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_sync_destroy_fence_request_t xcb_out; + + xcb_out.fence = fence; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + + +/***************************************************************************** + ** + ** xcb_sync_query_fence_cookie_t xcb_sync_query_fence + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_sync_query_fence_cookie_t + ** + *****************************************************************************/ + +xcb_sync_query_fence_cookie_t +xcb_sync_query_fence (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */) +{ + static const xcb_protocol_request_t xcb_req = { + /* count */ 2, + /* ext */ &xcb_sync_id, + /* opcode */ XCB_SYNC_QUERY_FENCE, + /* isvoid */ 0 + }; + + struct iovec xcb_parts[4]; + xcb_sync_query_fence_cookie_t xcb_ret; + xcb_sync_query_fence_request_t xcb_out; + + xcb_out.fence = fence; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + + +/***************************************************************************** + ** + ** xcb_sync_query_fence_cookie_t xcb_sync_query_fence_unchecked + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_fence_t fence + ** @returns xcb_sync_query_fence_cookie_t + ** + *****************************************************************************/ + +xcb_sync_query_fence_cookie_t +xcb_sync_query_fence_unchecked (xcb_connection_t *c /**< */, + xcb_sync_fence_t fence /**< */) +{ + static const xcb_protocol_request_t xcb_req = { + /* count */ 2, + /* ext */ &xcb_sync_id, + /* opcode */ XCB_SYNC_QUERY_FENCE, + /* isvoid */ 0 + }; + + struct iovec xcb_parts[4]; + xcb_sync_query_fence_cookie_t xcb_ret; + xcb_sync_query_fence_request_t xcb_out; + + xcb_out.fence = fence; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + + +/***************************************************************************** + ** + ** xcb_sync_query_fence_reply_t * xcb_sync_query_fence_reply + ** + ** @param xcb_connection_t *c + ** @param xcb_sync_query_fence_cookie_t cookie + ** @param xcb_generic_error_t **e + ** @returns xcb_sync_query_fence_reply_t * + ** + *****************************************************************************/ + +xcb_sync_query_fence_reply_t * +xcb_sync_query_fence_reply (xcb_connection_t *c /**< */, + xcb_sync_query_fence_cookie_t cookie /**< */, + xcb_generic_error_t **e /**< */) +{ + return (xcb_sync_query_fence_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_sync_await_fence_sizeof (const void *_buffer /**< */, + uint32_t fence_list_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_sync_await_fence_request_t); + xcb_tmp += xcb_block_len; + /* fence_list */ + xcb_block_len += fence_list_len * sizeof(xcb_sync_fence_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_sync_fence_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_await_fence_checked + ** + ** @param xcb_connection_t *c + ** @param uint32_t fence_list_len + ** @param const xcb_sync_fence_t *fence_list + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_await_fence_checked (xcb_connection_t *c /**< */, + uint32_t fence_list_len /**< */, + const xcb_sync_fence_t *fence_list /**< */) +{ + static const xcb_protocol_request_t xcb_req = { + /* count */ 4, + /* ext */ &xcb_sync_id, + /* opcode */ XCB_SYNC_AWAIT_FENCE, + /* isvoid */ 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_sync_await_fence_request_t xcb_out; + + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_sync_fence_t fence_list */ + xcb_parts[4].iov_base = (char *) fence_list; + xcb_parts[4].iov_len = fence_list_len * sizeof(xcb_sync_fence_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + + +/***************************************************************************** + ** + ** xcb_void_cookie_t xcb_sync_await_fence + ** + ** @param xcb_connection_t *c + ** @param uint32_t fence_list_len + ** @param const xcb_sync_fence_t *fence_list + ** @returns xcb_void_cookie_t + ** + *****************************************************************************/ + +xcb_void_cookie_t +xcb_sync_await_fence (xcb_connection_t *c /**< */, + uint32_t fence_list_len /**< */, + const xcb_sync_fence_t *fence_list /**< */) +{ + static const xcb_protocol_request_t xcb_req = { + /* count */ 4, + /* ext */ &xcb_sync_id, + /* opcode */ XCB_SYNC_AWAIT_FENCE, + /* isvoid */ 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_sync_await_fence_request_t xcb_out; + + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_sync_fence_t fence_list */ + xcb_parts[4].iov_base = (char *) fence_list; + xcb_parts[4].iov_len = fence_list_len * sizeof(xcb_sync_fence_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + diff --git a/src/3rdparty/xcb/libxcb/xfixes.c b/src/3rdparty/xcb/libxcb/xfixes.c index 541918ce16..4c0dc84b64 100644 --- a/src/3rdparty/xcb/libxcb/xfixes.c +++ b/src/3rdparty/xcb/libxcb/xfixes.c @@ -3,10 +3,17 @@ * Edit at your peril. */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include <stdlib.h> #include <string.h> #include <assert.h> +#include <stddef.h> /* for offsetof() */ #include "xcbext.h" #include "xfixes.h" + +#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) #include "xproto.h" #include "render.h" #include "shape.h" @@ -48,6 +55,7 @@ xcb_xfixes_query_version (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -87,6 +95,7 @@ xcb_xfixes_query_version_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -153,6 +162,7 @@ xcb_xfixes_change_save_set_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -199,6 +209,7 @@ xcb_xfixes_change_save_set (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -241,6 +252,7 @@ xcb_xfixes_select_selection_input_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -283,6 +295,7 @@ xcb_xfixes_select_selection_input (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -322,6 +335,7 @@ xcb_xfixes_select_cursor_input_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -361,10 +375,40 @@ xcb_xfixes_select_cursor_input (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_xfixes_get_cursor_image_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_get_cursor_image_reply_t *_aux = (xcb_xfixes_get_cursor_image_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_xfixes_get_cursor_image_reply_t); + xcb_tmp += xcb_block_len; + /* cursor_image */ + xcb_block_len += (_aux->width * _aux->height) * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -394,6 +438,7 @@ xcb_xfixes_get_cursor_image (xcb_connection_t *c /**< */) xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -427,6 +472,7 @@ xcb_xfixes_get_cursor_image_unchecked (xcb_connection_t *c /**< */) xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -541,6 +587,35 @@ xcb_xfixes_region_end (xcb_xfixes_region_iterator_t i /**< */) return ret; } +int +xcb_xfixes_create_region_sizeof (const void *_buffer /**< */, + uint32_t rectangles_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_xfixes_create_region_request_t); + xcb_tmp += xcb_block_len; + /* rectangles */ + xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_rectangle_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -577,10 +652,12 @@ xcb_xfixes_create_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rectangles */ xcb_parts[4].iov_base = (char *) rectangles; xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -621,10 +698,12 @@ xcb_xfixes_create_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rectangles */ xcb_parts[4].iov_base = (char *) rectangles; xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -664,6 +743,7 @@ xcb_xfixes_create_region_from_bitmap_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -703,6 +783,7 @@ xcb_xfixes_create_region_from_bitmap (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -746,6 +827,7 @@ xcb_xfixes_create_region_from_window_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -789,6 +871,7 @@ xcb_xfixes_create_region_from_window (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -828,6 +911,7 @@ xcb_xfixes_create_region_from_gc_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -867,6 +951,7 @@ xcb_xfixes_create_region_from_gc (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -906,6 +991,7 @@ xcb_xfixes_create_region_from_picture_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -945,6 +1031,7 @@ xcb_xfixes_create_region_from_picture (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -981,6 +1068,7 @@ xcb_xfixes_destroy_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1017,10 +1105,40 @@ xcb_xfixes_destroy_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_xfixes_set_region_sizeof (const void *_buffer /**< */, + uint32_t rectangles_len /**< */) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_xfixes_set_region_request_t); + xcb_tmp += xcb_block_len; + /* rectangles */ + xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_rectangle_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1057,10 +1175,12 @@ xcb_xfixes_set_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rectangles */ xcb_parts[4].iov_base = (char *) rectangles; xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1101,10 +1221,12 @@ xcb_xfixes_set_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rectangles */ xcb_parts[4].iov_base = (char *) rectangles; xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1144,6 +1266,7 @@ xcb_xfixes_copy_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1183,6 +1306,7 @@ xcb_xfixes_copy_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1225,6 +1349,7 @@ xcb_xfixes_union_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1267,6 +1392,7 @@ xcb_xfixes_union_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1309,6 +1435,7 @@ xcb_xfixes_intersect_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1351,6 +1478,7 @@ xcb_xfixes_intersect_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1393,6 +1521,7 @@ xcb_xfixes_subtract_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1435,6 +1564,7 @@ xcb_xfixes_subtract_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1477,6 +1607,7 @@ xcb_xfixes_invert_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1519,6 +1650,7 @@ xcb_xfixes_invert_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1561,6 +1693,7 @@ xcb_xfixes_translate_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1603,6 +1736,7 @@ xcb_xfixes_translate_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1642,6 +1776,7 @@ xcb_xfixes_region_extents_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1681,10 +1816,40 @@ xcb_xfixes_region_extents (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_xfixes_fetch_region_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_fetch_region_reply_t *_aux = (xcb_xfixes_fetch_region_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_xfixes_fetch_region_reply_t); + xcb_tmp += xcb_block_len; + /* rectangles */ + xcb_block_len += (_aux->length / 2) * sizeof(xcb_rectangle_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_rectangle_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -1717,6 +1882,7 @@ xcb_xfixes_fetch_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1753,6 +1919,7 @@ xcb_xfixes_fetch_region_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1870,6 +2037,7 @@ xcb_xfixes_set_gc_clip_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1915,6 +2083,7 @@ xcb_xfixes_set_gc_clip_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -1964,6 +2133,7 @@ xcb_xfixes_set_window_shape_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2013,6 +2183,7 @@ xcb_xfixes_set_window_shape_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2058,6 +2229,7 @@ xcb_xfixes_set_picture_clip_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2103,10 +2275,40 @@ xcb_xfixes_set_picture_clip_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_xfixes_set_cursor_name_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_set_cursor_name_request_t *_aux = (xcb_xfixes_set_cursor_name_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_xfixes_set_cursor_name_request_t); + xcb_tmp += xcb_block_len; + /* name */ + xcb_block_len += _aux->nbytes * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2145,10 +2347,12 @@ xcb_xfixes_set_cursor_name_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char name */ xcb_parts[4].iov_base = (char *) name; xcb_parts[4].iov_len = nbytes * sizeof(char); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2191,14 +2395,45 @@ xcb_xfixes_set_cursor_name (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char name */ xcb_parts[4].iov_base = (char *) name; xcb_parts[4].iov_len = nbytes * sizeof(char); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_xfixes_get_cursor_name_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_get_cursor_name_reply_t *_aux = (xcb_xfixes_get_cursor_name_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_xfixes_get_cursor_name_reply_t); + xcb_tmp += xcb_block_len; + /* name */ + xcb_block_len += _aux->nbytes * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2231,6 +2466,7 @@ xcb_xfixes_get_cursor_name (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2267,6 +2503,7 @@ xcb_xfixes_get_cursor_name_unchecked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2343,6 +2580,47 @@ xcb_xfixes_get_cursor_name_reply (xcb_connection_t *c /**< return (xcb_xfixes_get_cursor_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_xfixes_get_cursor_image_and_name_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_get_cursor_image_and_name_reply_t *_aux = (xcb_xfixes_get_cursor_image_and_name_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_xfixes_get_cursor_image_and_name_reply_t); + xcb_tmp += xcb_block_len; + /* name */ + xcb_block_len += _aux->nbytes * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* cursor_image */ + xcb_block_len += (_aux->width * _aux->height) * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2372,6 +2650,7 @@ xcb_xfixes_get_cursor_image_and_name (xcb_connection_t *c /**< */) xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2405,6 +2684,7 @@ xcb_xfixes_get_cursor_image_and_name_unchecked (xcb_connection_t *c /**< */) xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2570,6 +2850,7 @@ xcb_xfixes_change_cursor_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2609,10 +2890,40 @@ xcb_xfixes_change_cursor (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +int +xcb_xfixes_change_cursor_by_name_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_change_cursor_by_name_request_t *_aux = (xcb_xfixes_change_cursor_by_name_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_xfixes_change_cursor_by_name_request_t); + xcb_tmp += xcb_block_len; + /* name */ + xcb_block_len += _aux->nbytes * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** @@ -2651,10 +2962,12 @@ xcb_xfixes_change_cursor_by_name_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char name */ xcb_parts[4].iov_base = (char *) name; xcb_parts[4].iov_len = nbytes * sizeof(char); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2697,10 +3010,12 @@ xcb_xfixes_change_cursor_by_name (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char name */ xcb_parts[4].iov_base = (char *) name; xcb_parts[4].iov_len = nbytes * sizeof(char); xcb_parts[5].iov_base = 0; xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2752,6 +3067,7 @@ xcb_xfixes_expand_region_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2803,6 +3119,7 @@ xcb_xfixes_expand_region (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2839,6 +3156,7 @@ xcb_xfixes_hide_cursor_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2875,6 +3193,7 @@ xcb_xfixes_hide_cursor (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2911,6 +3230,7 @@ xcb_xfixes_show_cursor_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -2947,6 +3267,7 @@ xcb_xfixes_show_cursor (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } diff --git a/src/3rdparty/xcb/libxcb/xinerama.c b/src/3rdparty/xcb/libxcb/xinerama.c index 05b6b73707..e660be267b 100644 --- a/src/3rdparty/xcb/libxcb/xinerama.c +++ b/src/3rdparty/xcb/libxcb/xinerama.c @@ -3,10 +3,17 @@ * Edit at your peril. */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include <stdlib.h> #include <string.h> #include <assert.h> +#include <stddef.h> /* for offsetof() */ #include "xcbext.h" #include "xinerama.h" + +#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) #include "xproto.h" xcb_extension_t xcb_xinerama_id = { "XINERAMA", 0 }; @@ -15,12 +22,12 @@ xcb_extension_t xcb_xinerama_id = { "XINERAMA", 0 }; /***************************************************************************** ** ** void xcb_xinerama_screen_info_next - ** + ** ** @param xcb_xinerama_screen_info_iterator_t *i ** @returns void ** *****************************************************************************/ - + void xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i /**< */) { @@ -33,12 +40,12 @@ xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i /**< */) /***************************************************************************** ** ** xcb_generic_iterator_t xcb_xinerama_screen_info_end - ** + ** ** @param xcb_xinerama_screen_info_iterator_t i ** @returns xcb_generic_iterator_t ** *****************************************************************************/ - + xcb_generic_iterator_t xcb_xinerama_screen_info_end (xcb_xinerama_screen_info_iterator_t i /**< */) { @@ -53,14 +60,14 @@ xcb_xinerama_screen_info_end (xcb_xinerama_screen_info_iterator_t i /**< */) /***************************************************************************** ** ** xcb_xinerama_query_version_cookie_t xcb_xinerama_query_version - ** + ** ** @param xcb_connection_t *c ** @param uint8_t major ** @param uint8_t minor ** @returns xcb_xinerama_query_version_cookie_t ** *****************************************************************************/ - + xcb_xinerama_query_version_cookie_t xcb_xinerama_query_version (xcb_connection_t *c /**< */, uint8_t major /**< */, @@ -72,18 +79,19 @@ xcb_xinerama_query_version (xcb_connection_t *c /**< */, /* opcode */ XCB_XINERAMA_QUERY_VERSION, /* isvoid */ 0 }; - + struct iovec xcb_parts[4]; xcb_xinerama_query_version_cookie_t xcb_ret; xcb_xinerama_query_version_request_t xcb_out; - + xcb_out.major = major; xcb_out.minor = minor; - + xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -92,14 +100,14 @@ xcb_xinerama_query_version (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_query_version_cookie_t xcb_xinerama_query_version_unchecked - ** + ** ** @param xcb_connection_t *c ** @param uint8_t major ** @param uint8_t minor ** @returns xcb_xinerama_query_version_cookie_t ** *****************************************************************************/ - + xcb_xinerama_query_version_cookie_t xcb_xinerama_query_version_unchecked (xcb_connection_t *c /**< */, uint8_t major /**< */, @@ -111,18 +119,19 @@ xcb_xinerama_query_version_unchecked (xcb_connection_t *c /**< */, /* opcode */ XCB_XINERAMA_QUERY_VERSION, /* isvoid */ 0 }; - + struct iovec xcb_parts[4]; xcb_xinerama_query_version_cookie_t xcb_ret; xcb_xinerama_query_version_request_t xcb_out; - + xcb_out.major = major; xcb_out.minor = minor; - + xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -131,14 +140,14 @@ xcb_xinerama_query_version_unchecked (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_query_version_reply_t * xcb_xinerama_query_version_reply - ** + ** ** @param xcb_connection_t *c ** @param xcb_xinerama_query_version_cookie_t cookie ** @param xcb_generic_error_t **e ** @returns xcb_xinerama_query_version_reply_t * ** *****************************************************************************/ - + xcb_xinerama_query_version_reply_t * xcb_xinerama_query_version_reply (xcb_connection_t *c /**< */, xcb_xinerama_query_version_cookie_t cookie /**< */, @@ -151,13 +160,13 @@ xcb_xinerama_query_version_reply (xcb_connection_t *c /**< /***************************************************************************** ** ** xcb_xinerama_get_state_cookie_t xcb_xinerama_get_state - ** + ** ** @param xcb_connection_t *c ** @param xcb_window_t window ** @returns xcb_xinerama_get_state_cookie_t ** *****************************************************************************/ - + xcb_xinerama_get_state_cookie_t xcb_xinerama_get_state (xcb_connection_t *c /**< */, xcb_window_t window /**< */) @@ -168,17 +177,18 @@ xcb_xinerama_get_state (xcb_connection_t *c /**< */, /* opcode */ XCB_XINERAMA_GET_STATE, /* isvoid */ 0 }; - + struct iovec xcb_parts[4]; xcb_xinerama_get_state_cookie_t xcb_ret; xcb_xinerama_get_state_request_t xcb_out; - + xcb_out.window = window; - + xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -187,13 +197,13 @@ xcb_xinerama_get_state (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_state_cookie_t xcb_xinerama_get_state_unchecked - ** + ** ** @param xcb_connection_t *c ** @param xcb_window_t window ** @returns xcb_xinerama_get_state_cookie_t ** *****************************************************************************/ - + xcb_xinerama_get_state_cookie_t xcb_xinerama_get_state_unchecked (xcb_connection_t *c /**< */, xcb_window_t window /**< */) @@ -204,17 +214,18 @@ xcb_xinerama_get_state_unchecked (xcb_connection_t *c /**< */, /* opcode */ XCB_XINERAMA_GET_STATE, /* isvoid */ 0 }; - + struct iovec xcb_parts[4]; xcb_xinerama_get_state_cookie_t xcb_ret; xcb_xinerama_get_state_request_t xcb_out; - + xcb_out.window = window; - + xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -223,14 +234,14 @@ xcb_xinerama_get_state_unchecked (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_state_reply_t * xcb_xinerama_get_state_reply - ** + ** ** @param xcb_connection_t *c ** @param xcb_xinerama_get_state_cookie_t cookie ** @param xcb_generic_error_t **e ** @returns xcb_xinerama_get_state_reply_t * ** *****************************************************************************/ - + xcb_xinerama_get_state_reply_t * xcb_xinerama_get_state_reply (xcb_connection_t *c /**< */, xcb_xinerama_get_state_cookie_t cookie /**< */, @@ -243,13 +254,13 @@ xcb_xinerama_get_state_reply (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_screen_count_cookie_t xcb_xinerama_get_screen_count - ** + ** ** @param xcb_connection_t *c ** @param xcb_window_t window ** @returns xcb_xinerama_get_screen_count_cookie_t ** *****************************************************************************/ - + xcb_xinerama_get_screen_count_cookie_t xcb_xinerama_get_screen_count (xcb_connection_t *c /**< */, xcb_window_t window /**< */) @@ -260,17 +271,18 @@ xcb_xinerama_get_screen_count (xcb_connection_t *c /**< */, /* opcode */ XCB_XINERAMA_GET_SCREEN_COUNT, /* isvoid */ 0 }; - + struct iovec xcb_parts[4]; xcb_xinerama_get_screen_count_cookie_t xcb_ret; xcb_xinerama_get_screen_count_request_t xcb_out; - + xcb_out.window = window; - + xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -279,13 +291,13 @@ xcb_xinerama_get_screen_count (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_screen_count_cookie_t xcb_xinerama_get_screen_count_unchecked - ** + ** ** @param xcb_connection_t *c ** @param xcb_window_t window ** @returns xcb_xinerama_get_screen_count_cookie_t ** *****************************************************************************/ - + xcb_xinerama_get_screen_count_cookie_t xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c /**< */, xcb_window_t window /**< */) @@ -296,17 +308,18 @@ xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c /**< */, /* opcode */ XCB_XINERAMA_GET_SCREEN_COUNT, /* isvoid */ 0 }; - + struct iovec xcb_parts[4]; xcb_xinerama_get_screen_count_cookie_t xcb_ret; xcb_xinerama_get_screen_count_request_t xcb_out; - + xcb_out.window = window; - + xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -315,14 +328,14 @@ xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_screen_count_reply_t * xcb_xinerama_get_screen_count_reply - ** + ** ** @param xcb_connection_t *c ** @param xcb_xinerama_get_screen_count_cookie_t cookie ** @param xcb_generic_error_t **e ** @returns xcb_xinerama_get_screen_count_reply_t * ** *****************************************************************************/ - + xcb_xinerama_get_screen_count_reply_t * xcb_xinerama_get_screen_count_reply (xcb_connection_t *c /**< */, xcb_xinerama_get_screen_count_cookie_t cookie /**< */, @@ -335,14 +348,14 @@ xcb_xinerama_get_screen_count_reply (xcb_connection_t *c /***************************************************************************** ** ** xcb_xinerama_get_screen_size_cookie_t xcb_xinerama_get_screen_size - ** + ** ** @param xcb_connection_t *c ** @param xcb_window_t window ** @param uint32_t screen ** @returns xcb_xinerama_get_screen_size_cookie_t ** *****************************************************************************/ - + xcb_xinerama_get_screen_size_cookie_t xcb_xinerama_get_screen_size (xcb_connection_t *c /**< */, xcb_window_t window /**< */, @@ -354,18 +367,19 @@ xcb_xinerama_get_screen_size (xcb_connection_t *c /**< */, /* opcode */ XCB_XINERAMA_GET_SCREEN_SIZE, /* isvoid */ 0 }; - + struct iovec xcb_parts[4]; xcb_xinerama_get_screen_size_cookie_t xcb_ret; xcb_xinerama_get_screen_size_request_t xcb_out; - + xcb_out.window = window; xcb_out.screen = screen; - + xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -374,14 +388,14 @@ xcb_xinerama_get_screen_size (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_screen_size_cookie_t xcb_xinerama_get_screen_size_unchecked - ** + ** ** @param xcb_connection_t *c ** @param xcb_window_t window ** @param uint32_t screen ** @returns xcb_xinerama_get_screen_size_cookie_t ** *****************************************************************************/ - + xcb_xinerama_get_screen_size_cookie_t xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c /**< */, xcb_window_t window /**< */, @@ -393,18 +407,19 @@ xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c /**< */, /* opcode */ XCB_XINERAMA_GET_SCREEN_SIZE, /* isvoid */ 0 }; - + struct iovec xcb_parts[4]; xcb_xinerama_get_screen_size_cookie_t xcb_ret; xcb_xinerama_get_screen_size_request_t xcb_out; - + xcb_out.window = window; xcb_out.screen = screen; - + xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -413,14 +428,14 @@ xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c /**< */, /***************************************************************************** ** ** xcb_xinerama_get_screen_size_reply_t * xcb_xinerama_get_screen_size_reply - ** + ** ** @param xcb_connection_t *c ** @param xcb_xinerama_get_screen_size_cookie_t cookie ** @param xcb_generic_error_t **e ** @returns xcb_xinerama_get_screen_size_reply_t * ** *****************************************************************************/ - + xcb_xinerama_get_screen_size_reply_t * xcb_xinerama_get_screen_size_reply (xcb_connection_t *c /**< */, xcb_xinerama_get_screen_size_cookie_t cookie /**< */, @@ -433,12 +448,12 @@ xcb_xinerama_get_screen_size_reply (xcb_connection_t *c / /***************************************************************************** ** ** xcb_xinerama_is_active_cookie_t xcb_xinerama_is_active - ** + ** ** @param xcb_connection_t *c ** @returns xcb_xinerama_is_active_cookie_t ** *****************************************************************************/ - + xcb_xinerama_is_active_cookie_t xcb_xinerama_is_active (xcb_connection_t *c /**< */) { @@ -448,16 +463,17 @@ xcb_xinerama_is_active (xcb_connection_t *c /**< */) /* opcode */ XCB_XINERAMA_IS_ACTIVE, /* isvoid */ 0 }; - + struct iovec xcb_parts[4]; xcb_xinerama_is_active_cookie_t xcb_ret; xcb_xinerama_is_active_request_t xcb_out; - - + + xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -466,12 +482,12 @@ xcb_xinerama_is_active (xcb_connection_t *c /**< */) /***************************************************************************** ** ** xcb_xinerama_is_active_cookie_t xcb_xinerama_is_active_unchecked - ** + ** ** @param xcb_connection_t *c ** @returns xcb_xinerama_is_active_cookie_t ** *****************************************************************************/ - + xcb_xinerama_is_active_cookie_t xcb_xinerama_is_active_unchecked (xcb_connection_t *c /**< */) { @@ -481,16 +497,17 @@ xcb_xinerama_is_active_unchecked (xcb_connection_t *c /**< */) /* opcode */ XCB_XINERAMA_IS_ACTIVE, /* isvoid */ 0 }; - + struct iovec xcb_parts[4]; xcb_xinerama_is_active_cookie_t xcb_ret; xcb_xinerama_is_active_request_t xcb_out; - - + + xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -499,14 +516,14 @@ xcb_xinerama_is_active_unchecked (xcb_connection_t *c /**< */) /***************************************************************************** ** ** xcb_xinerama_is_active_reply_t * xcb_xinerama_is_active_reply - ** + ** ** @param xcb_connection_t *c ** @param xcb_xinerama_is_active_cookie_t cookie ** @param xcb_generic_error_t **e ** @returns xcb_xinerama_is_active_reply_t * ** *****************************************************************************/ - + xcb_xinerama_is_active_reply_t * xcb_xinerama_is_active_reply (xcb_connection_t *c /**< */, xcb_xinerama_is_active_cookie_t cookie /**< */, @@ -515,16 +532,45 @@ xcb_xinerama_is_active_reply (xcb_connection_t *c /**< */, return (xcb_xinerama_is_active_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } +int +xcb_xinerama_query_screens_sizeof (const void *_buffer /**< */) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xinerama_query_screens_reply_t *_aux = (xcb_xinerama_query_screens_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to; + + + xcb_block_len += sizeof(xcb_xinerama_query_screens_reply_t); + xcb_tmp += xcb_block_len; + /* screen_info */ + xcb_block_len += _aux->number * sizeof(xcb_xinerama_screen_info_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_xinerama_screen_info_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + /***************************************************************************** ** ** xcb_xinerama_query_screens_cookie_t xcb_xinerama_query_screens - ** + ** ** @param xcb_connection_t *c ** @returns xcb_xinerama_query_screens_cookie_t ** *****************************************************************************/ - + xcb_xinerama_query_screens_cookie_t xcb_xinerama_query_screens (xcb_connection_t *c /**< */) { @@ -534,16 +580,17 @@ xcb_xinerama_query_screens (xcb_connection_t *c /**< */) /* opcode */ XCB_XINERAMA_QUERY_SCREENS, /* isvoid */ 0 }; - + struct iovec xcb_parts[4]; xcb_xinerama_query_screens_cookie_t xcb_ret; xcb_xinerama_query_screens_request_t xcb_out; - - + + xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -552,12 +599,12 @@ xcb_xinerama_query_screens (xcb_connection_t *c /**< */) /***************************************************************************** ** ** xcb_xinerama_query_screens_cookie_t xcb_xinerama_query_screens_unchecked - ** + ** ** @param xcb_connection_t *c ** @returns xcb_xinerama_query_screens_cookie_t ** *****************************************************************************/ - + xcb_xinerama_query_screens_cookie_t xcb_xinerama_query_screens_unchecked (xcb_connection_t *c /**< */) { @@ -567,16 +614,17 @@ xcb_xinerama_query_screens_unchecked (xcb_connection_t *c /**< */) /* opcode */ XCB_XINERAMA_QUERY_SCREENS, /* isvoid */ 0 }; - + struct iovec xcb_parts[4]; xcb_xinerama_query_screens_cookie_t xcb_ret; xcb_xinerama_query_screens_request_t xcb_out; - - + + xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } @@ -585,12 +633,12 @@ xcb_xinerama_query_screens_unchecked (xcb_connection_t *c /**< */) /***************************************************************************** ** ** xcb_xinerama_screen_info_t * xcb_xinerama_query_screens_screen_info - ** + ** ** @param const xcb_xinerama_query_screens_reply_t *R ** @returns xcb_xinerama_screen_info_t * ** *****************************************************************************/ - + xcb_xinerama_screen_info_t * xcb_xinerama_query_screens_screen_info (const xcb_xinerama_query_screens_reply_t *R /**< */) { @@ -601,12 +649,12 @@ xcb_xinerama_query_screens_screen_info (const xcb_xinerama_query_screens_reply_t /***************************************************************************** ** ** int xcb_xinerama_query_screens_screen_info_length - ** + ** ** @param const xcb_xinerama_query_screens_reply_t *R ** @returns int ** *****************************************************************************/ - + int xcb_xinerama_query_screens_screen_info_length (const xcb_xinerama_query_screens_reply_t *R /**< */) { @@ -617,12 +665,12 @@ xcb_xinerama_query_screens_screen_info_length (const xcb_xinerama_query_screens_ /***************************************************************************** ** ** xcb_xinerama_screen_info_iterator_t xcb_xinerama_query_screens_screen_info_iterator - ** + ** ** @param const xcb_xinerama_query_screens_reply_t *R ** @returns xcb_xinerama_screen_info_iterator_t ** *****************************************************************************/ - + xcb_xinerama_screen_info_iterator_t xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screens_reply_t *R /**< */) { @@ -637,14 +685,14 @@ xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screen /***************************************************************************** ** ** xcb_xinerama_query_screens_reply_t * xcb_xinerama_query_screens_reply - ** + ** ** @param xcb_connection_t *c ** @param xcb_xinerama_query_screens_cookie_t cookie ** @param xcb_generic_error_t **e ** @returns xcb_xinerama_query_screens_reply_t * ** *****************************************************************************/ - + xcb_xinerama_query_screens_reply_t * xcb_xinerama_query_screens_reply (xcb_connection_t *c /**< */, xcb_xinerama_query_screens_cookie_t cookie /**< */, diff --git a/src/3rdparty/xcb/libxcb/xinput.c b/src/3rdparty/xcb/libxcb/xinput.c new file mode 100644 index 0000000000..0edfde656c --- /dev/null +++ b/src/3rdparty/xcb/libxcb/xinput.c @@ -0,0 +1,14156 @@ +/* + * This file generated automatically from xinput.xml by c_client.py. + * Edit at your peril. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include <stdlib.h> +#include <string.h> +#include <assert.h> +#include <stddef.h> /* for offsetof() */ +#include "xcbext.h" +#include "xinput.h" + +#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) +#include "xfixes.h" + +xcb_extension_t xcb_input_id = { "XInputExtension", 0 }; + +void +xcb_input_event_class_next (xcb_input_event_class_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_event_class_t); +} + +xcb_generic_iterator_t +xcb_input_event_class_end (xcb_input_event_class_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_key_code_next (xcb_input_key_code_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_key_code_t); +} + +xcb_generic_iterator_t +xcb_input_key_code_end (xcb_input_key_code_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_device_id_next (xcb_input_device_id_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_device_id_t); +} + +xcb_generic_iterator_t +xcb_input_device_id_end (xcb_input_device_id_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_fp1616_next (xcb_input_fp1616_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_fp1616_t); +} + +xcb_generic_iterator_t +xcb_input_fp1616_end (xcb_input_fp1616_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_fp3232_next (xcb_input_fp3232_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_fp3232_t); +} + +xcb_generic_iterator_t +xcb_input_fp3232_end (xcb_input_fp3232_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +int +xcb_input_get_extension_version_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_get_extension_version_request_t *_aux = (xcb_input_get_extension_version_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_get_extension_version_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* name */ + xcb_block_len += _aux->name_len * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_get_extension_version_cookie_t +xcb_input_get_extension_version (xcb_connection_t *c, + uint16_t name_len, + const char *name) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_EXTENSION_VERSION, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_get_extension_version_cookie_t xcb_ret; + xcb_input_get_extension_version_request_t xcb_out; + + xcb_out.name_len = name_len; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char name */ + xcb_parts[4].iov_base = (char *) name; + xcb_parts[4].iov_len = name_len * sizeof(char); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_extension_version_cookie_t +xcb_input_get_extension_version_unchecked (xcb_connection_t *c, + uint16_t name_len, + const char *name) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_EXTENSION_VERSION, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_get_extension_version_cookie_t xcb_ret; + xcb_input_get_extension_version_request_t xcb_out; + + xcb_out.name_len = name_len; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char name */ + xcb_parts[4].iov_base = (char *) name; + xcb_parts[4].iov_len = name_len * sizeof(char); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_extension_version_reply_t * +xcb_input_get_extension_version_reply (xcb_connection_t *c, + xcb_input_get_extension_version_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_get_extension_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +void +xcb_input_device_info_next (xcb_input_device_info_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_device_info_t); +} + +xcb_generic_iterator_t +xcb_input_device_info_end (xcb_input_device_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_key_info_next (xcb_input_key_info_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_key_info_t); +} + +xcb_generic_iterator_t +xcb_input_key_info_end (xcb_input_key_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_button_info_next (xcb_input_button_info_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_button_info_t); +} + +xcb_generic_iterator_t +xcb_input_button_info_end (xcb_input_button_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_axis_info_next (xcb_input_axis_info_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_axis_info_t); +} + +xcb_generic_iterator_t +xcb_input_axis_info_end (xcb_input_axis_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +int +xcb_input_valuator_info_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_valuator_info_t *_aux = (xcb_input_valuator_info_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_valuator_info_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* axes */ + xcb_block_len += _aux->axes_len * sizeof(xcb_input_axis_info_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_axis_info_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_axis_info_t * +xcb_input_valuator_info_axes (const xcb_input_valuator_info_t *R) +{ + return (xcb_input_axis_info_t *) (R + 1); +} + +int +xcb_input_valuator_info_axes_length (const xcb_input_valuator_info_t *R) +{ + return R->axes_len; +} + +xcb_input_axis_info_iterator_t +xcb_input_valuator_info_axes_iterator (const xcb_input_valuator_info_t *R) +{ + xcb_input_axis_info_iterator_t i; + i.data = (xcb_input_axis_info_t *) (R + 1); + i.rem = R->axes_len; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_valuator_info_next (xcb_input_valuator_info_iterator_t *i) +{ + xcb_input_valuator_info_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_valuator_info_t *)(((char *)R) + xcb_input_valuator_info_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_valuator_info_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_valuator_info_end (xcb_input_valuator_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_valuator_info_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +xcb_input_axis_info_t * +xcb_input_input_info_info_valuator_axes (const xcb_input_input_info_info_t *S) +{ + return S->valuator.axes; +} + +int +xcb_input_input_info_info_valuator_axes_length (const xcb_input_input_info_t *R, + const xcb_input_input_info_info_t *S) +{ + return S->valuator.axes_len; +} + +xcb_input_axis_info_iterator_t +xcb_input_input_info_info_valuator_axes_iterator (const xcb_input_input_info_t *R, + const xcb_input_input_info_info_t *S) +{ + xcb_input_axis_info_iterator_t i; + i.data = S->valuator.axes; + i.rem = S->valuator.axes_len; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_input_info_info_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_input_info_info_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 2; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[11]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(class_id == XCB_INPUT_INPUT_CLASS_KEY) { + /* xcb_input_input_info_info_t.key.min_keycode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.min_keycode; + xcb_block_len += sizeof(xcb_input_key_code_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_key_code_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_key_code_t); + /* xcb_input_input_info_info_t.key.max_keycode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.max_keycode; + xcb_block_len += sizeof(xcb_input_key_code_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_key_code_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_key_code_t); + /* xcb_input_input_info_info_t.key.num_keys */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.num_keys; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_input_info_info_t.key.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) { + /* xcb_input_input_info_info_t.button.num_buttons */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->button.num_buttons; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) { + /* xcb_input_input_info_info_t.valuator.axes_len */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.axes_len; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_info_info_t.valuator.mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.mode; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_info_info_t.valuator.motion_size */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.motion_size; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* axes */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->valuator.axes; + xcb_block_len += _aux->valuator.axes_len * sizeof(xcb_input_axis_info_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->valuator.axes_len * sizeof(xcb_input_axis_info_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_axis_info_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; i<xcb_parts_idx; i++) { + if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) + memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); + if (0 != xcb_parts[i].iov_len) + xcb_tmp += xcb_parts[i].iov_len; + } + + return xcb_buffer_len; +} + +int +xcb_input_input_info_info_unpack (const void *_buffer, + uint8_t class_id, + xcb_input_input_info_info_t *_aux) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 2; + + + if(class_id == XCB_INPUT_INPUT_CLASS_KEY) { + /* xcb_input_input_info_info_t.key.min_keycode */ + _aux->key.min_keycode = *(xcb_input_key_code_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_key_code_t); + xcb_tmp += sizeof(xcb_input_key_code_t); + xcb_align_to = ALIGNOF(xcb_input_key_code_t); + /* xcb_input_input_info_info_t.key.max_keycode */ + _aux->key.max_keycode = *(xcb_input_key_code_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_key_code_t); + xcb_tmp += sizeof(xcb_input_key_code_t); + xcb_align_to = ALIGNOF(xcb_input_key_code_t); + /* xcb_input_input_info_info_t.key.num_keys */ + _aux->key.num_keys = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_input_info_info_t.key.pad0 */ + _aux->key.pad0[0] = *(uint8_t *)xcb_tmp; + _aux->key.pad0[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) { + /* xcb_input_input_info_info_t.button.num_buttons */ + _aux->button.num_buttons = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) { + /* xcb_input_input_info_info_t.valuator.axes_len */ + _aux->valuator.axes_len = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_info_info_t.valuator.mode */ + _aux->valuator.mode = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_info_info_t.valuator.motion_size */ + _aux->valuator.motion_size = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* axes */ + _aux->valuator.axes = (xcb_input_axis_info_t *)xcb_tmp; + xcb_block_len += _aux->valuator.axes_len * sizeof(xcb_input_axis_info_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_axis_info_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + return xcb_buffer_len; +} + +int +xcb_input_input_info_info_sizeof (const void *_buffer, + uint8_t class_id) +{ + xcb_input_input_info_info_t _aux; + return xcb_input_input_info_info_unpack(_buffer, class_id, &_aux); +} + +int +xcb_input_input_info_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_input_info_t *_aux = (xcb_input_input_info_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_input_info_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* info */ + xcb_block_len += xcb_input_input_info_info_sizeof(xcb_tmp, _aux->class_id); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +void * +xcb_input_input_info_info (const xcb_input_input_info_t *R) +{ + return (void *) (R + 1); +} + +void +xcb_input_input_info_next (xcb_input_input_info_iterator_t *i) +{ + xcb_input_input_info_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_input_info_t *)(((char *)R) + xcb_input_input_info_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_input_info_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_input_info_end (xcb_input_input_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_input_info_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_device_name_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_device_name_t *_aux = (xcb_input_device_name_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_device_name_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* string */ + xcb_block_len += _aux->len * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +char * +xcb_input_device_name_string (const xcb_input_device_name_t *R) +{ + return (char *) (R + 1); +} + +int +xcb_input_device_name_string_length (const xcb_input_device_name_t *R) +{ + return R->len; +} + +xcb_generic_iterator_t +xcb_input_device_name_string_end (const xcb_input_device_name_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_device_name_next (xcb_input_device_name_iterator_t *i) +{ + xcb_input_device_name_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_device_name_t *)(((char *)R) + xcb_input_device_name_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_device_name_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_device_name_end (xcb_input_device_name_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_device_name_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_list_input_devices_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_list_input_devices_reply_t *_aux = (xcb_input_list_input_devices_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const xcb_input_device_info_t* xcb_pre_tmp_4; /* sumof list ptr */ + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_input_list_input_devices_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* devices */ + xcb_block_len += _aux->devices_len * sizeof(xcb_input_device_info_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_device_info_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* infos */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->devices_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_list_input_devices_devices(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += xcb_pre_tmp_4->num_class_info; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + for(i=0; i<xcb_pre_tmp_3; i++) { + xcb_tmp_len = xcb_input_input_info_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_input_input_info_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* names */ + for(i=0; i<_aux->devices_len; i++) { + xcb_tmp_len = xcb_str_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_str_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_list_input_devices_cookie_t +xcb_input_list_input_devices (xcb_connection_t *c) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_LIST_INPUT_DEVICES, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_list_input_devices_cookie_t xcb_ret; + xcb_input_list_input_devices_request_t xcb_out; + + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_list_input_devices_cookie_t +xcb_input_list_input_devices_unchecked (xcb_connection_t *c) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_LIST_INPUT_DEVICES, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_list_input_devices_cookie_t xcb_ret; + xcb_input_list_input_devices_request_t xcb_out; + + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_device_info_t * +xcb_input_list_input_devices_devices (const xcb_input_list_input_devices_reply_t *R) +{ + return (xcb_input_device_info_t *) (R + 1); +} + +int +xcb_input_list_input_devices_devices_length (const xcb_input_list_input_devices_reply_t *R) +{ + return R->devices_len; +} + +xcb_input_device_info_iterator_t +xcb_input_list_input_devices_devices_iterator (const xcb_input_list_input_devices_reply_t *R) +{ + xcb_input_device_info_iterator_t i; + i.data = (xcb_input_device_info_t *) (R + 1); + i.rem = R->devices_len; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_list_input_devices_infos_length (const xcb_input_list_input_devices_reply_t *R) +{ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const xcb_input_device_info_t* xcb_pre_tmp_8; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_5 = R->devices_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_list_input_devices_devices(R); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + xcb_pre_tmp_7 += xcb_pre_tmp_8->num_class_info; + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + return xcb_pre_tmp_7; +} + +xcb_input_input_info_iterator_t +xcb_input_list_input_devices_infos_iterator (const xcb_input_list_input_devices_reply_t *R) +{ + xcb_input_input_info_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_device_info_end(xcb_input_list_input_devices_devices_iterator(R)); + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const xcb_input_device_info_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->devices_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_list_input_devices_devices(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + xcb_pre_tmp_11 += xcb_pre_tmp_12->num_class_info; + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + i.data = (xcb_input_input_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_input_info_t, prev.index)); + i.rem = xcb_pre_tmp_11; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_list_input_devices_names_length (const xcb_input_list_input_devices_reply_t *R) +{ + return R->devices_len; +} + +xcb_str_iterator_t +xcb_input_list_input_devices_names_iterator (const xcb_input_list_input_devices_reply_t *R) +{ + xcb_str_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_input_info_end(xcb_input_list_input_devices_infos_iterator(R)); + i.data = (xcb_str_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_str_t, prev.index)); + i.rem = R->devices_len; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_list_input_devices_reply_t * +xcb_input_list_input_devices_reply (xcb_connection_t *c, + xcb_input_list_input_devices_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_list_input_devices_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +void +xcb_input_event_type_base_next (xcb_input_event_type_base_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_event_type_base_t); +} + +xcb_generic_iterator_t +xcb_input_event_type_base_end (xcb_input_event_type_base_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_input_class_info_next (xcb_input_input_class_info_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_input_class_info_t); +} + +xcb_generic_iterator_t +xcb_input_input_class_info_end (xcb_input_input_class_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +int +xcb_input_open_device_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_open_device_reply_t *_aux = (xcb_input_open_device_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_open_device_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* class_info */ + xcb_block_len += _aux->num_classes * sizeof(xcb_input_input_class_info_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_input_class_info_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_open_device_cookie_t +xcb_input_open_device (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_OPEN_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_open_device_cookie_t xcb_ret; + xcb_input_open_device_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_open_device_cookie_t +xcb_input_open_device_unchecked (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_OPEN_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_open_device_cookie_t xcb_ret; + xcb_input_open_device_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_input_class_info_t * +xcb_input_open_device_class_info (const xcb_input_open_device_reply_t *R) +{ + return (xcb_input_input_class_info_t *) (R + 1); +} + +int +xcb_input_open_device_class_info_length (const xcb_input_open_device_reply_t *R) +{ + return R->num_classes; +} + +xcb_input_input_class_info_iterator_t +xcb_input_open_device_class_info_iterator (const xcb_input_open_device_reply_t *R) +{ + xcb_input_input_class_info_iterator_t i; + i.data = (xcb_input_input_class_info_t *) (R + 1); + i.rem = R->num_classes; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_open_device_reply_t * +xcb_input_open_device_reply (xcb_connection_t *c, + xcb_input_open_device_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_open_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_void_cookie_t +xcb_input_close_device_checked (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CLOSE_DEVICE, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_close_device_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_close_device (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CLOSE_DEVICE, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_close_device_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_set_device_mode_cookie_t +xcb_input_set_device_mode (xcb_connection_t *c, + uint8_t device_id, + uint8_t mode) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_MODE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_set_device_mode_cookie_t xcb_ret; + xcb_input_set_device_mode_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.mode = mode; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_set_device_mode_cookie_t +xcb_input_set_device_mode_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t mode) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_MODE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_set_device_mode_cookie_t xcb_ret; + xcb_input_set_device_mode_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.mode = mode; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_set_device_mode_reply_t * +xcb_input_set_device_mode_reply (xcb_connection_t *c, + xcb_input_set_device_mode_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_set_device_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_select_extension_event_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_select_extension_event_request_t *_aux = (xcb_input_select_extension_event_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_select_extension_event_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* classes */ + xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_event_class_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_input_select_extension_event_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + const xcb_input_event_class_t *classes) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SELECT_EXTENSION_EVENT, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_select_extension_event_request_t xcb_out; + + xcb_out.window = window; + xcb_out.num_classes = num_classes; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_event_class_t classes */ + xcb_parts[4].iov_base = (char *) classes; + xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_select_extension_event (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + const xcb_input_event_class_t *classes) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SELECT_EXTENSION_EVENT, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_select_extension_event_request_t xcb_out; + + xcb_out.window = window; + xcb_out.num_classes = num_classes; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_event_class_t classes */ + xcb_parts[4].iov_base = (char *) classes; + xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_event_class_t * +xcb_input_select_extension_event_classes (const xcb_input_select_extension_event_request_t *R) +{ + return (xcb_input_event_class_t *) (R + 1); +} + +int +xcb_input_select_extension_event_classes_length (const xcb_input_select_extension_event_request_t *R) +{ + return R->num_classes; +} + +xcb_generic_iterator_t +xcb_input_select_extension_event_classes_end (const xcb_input_select_extension_event_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_get_selected_extension_events_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_get_selected_extension_events_reply_t *_aux = (xcb_input_get_selected_extension_events_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_get_selected_extension_events_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* this_classes */ + xcb_block_len += _aux->num_this_classes * sizeof(xcb_input_event_class_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_event_class_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* all_classes */ + xcb_block_len += _aux->num_all_classes * sizeof(xcb_input_event_class_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_event_class_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_get_selected_extension_events_cookie_t +xcb_input_get_selected_extension_events (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_selected_extension_events_cookie_t xcb_ret; + xcb_input_get_selected_extension_events_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_selected_extension_events_cookie_t +xcb_input_get_selected_extension_events_unchecked (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_selected_extension_events_cookie_t xcb_ret; + xcb_input_get_selected_extension_events_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_event_class_t * +xcb_input_get_selected_extension_events_this_classes (const xcb_input_get_selected_extension_events_reply_t *R) +{ + return (xcb_input_event_class_t *) (R + 1); +} + +int +xcb_input_get_selected_extension_events_this_classes_length (const xcb_input_get_selected_extension_events_reply_t *R) +{ + return R->num_this_classes; +} + +xcb_generic_iterator_t +xcb_input_get_selected_extension_events_this_classes_end (const xcb_input_get_selected_extension_events_reply_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_this_classes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_event_class_t * +xcb_input_get_selected_extension_events_all_classes (const xcb_input_get_selected_extension_events_reply_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_get_selected_extension_events_this_classes_end(R); + return (xcb_input_event_class_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index) + 0); +} + +int +xcb_input_get_selected_extension_events_all_classes_length (const xcb_input_get_selected_extension_events_reply_t *R) +{ + return R->num_all_classes; +} + +xcb_generic_iterator_t +xcb_input_get_selected_extension_events_all_classes_end (const xcb_input_get_selected_extension_events_reply_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_get_selected_extension_events_this_classes_end(R); + i.data = ((xcb_input_event_class_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index))) + (R->num_all_classes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_get_selected_extension_events_reply_t * +xcb_input_get_selected_extension_events_reply (xcb_connection_t *c, + xcb_input_get_selected_extension_events_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_get_selected_extension_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_change_device_dont_propagate_list_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_change_device_dont_propagate_list_request_t *_aux = (xcb_input_change_device_dont_propagate_list_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_change_device_dont_propagate_list_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* classes */ + xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_event_class_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_input_change_device_dont_propagate_list_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + uint8_t mode, + const xcb_input_event_class_t *classes) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_change_device_dont_propagate_list_request_t xcb_out; + + xcb_out.window = window; + xcb_out.num_classes = num_classes; + xcb_out.mode = mode; + xcb_out.pad0 = 0; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_event_class_t classes */ + xcb_parts[4].iov_base = (char *) classes; + xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_change_device_dont_propagate_list (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + uint8_t mode, + const xcb_input_event_class_t *classes) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_change_device_dont_propagate_list_request_t xcb_out; + + xcb_out.window = window; + xcb_out.num_classes = num_classes; + xcb_out.mode = mode; + xcb_out.pad0 = 0; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_event_class_t classes */ + xcb_parts[4].iov_base = (char *) classes; + xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_event_class_t * +xcb_input_change_device_dont_propagate_list_classes (const xcb_input_change_device_dont_propagate_list_request_t *R) +{ + return (xcb_input_event_class_t *) (R + 1); +} + +int +xcb_input_change_device_dont_propagate_list_classes_length (const xcb_input_change_device_dont_propagate_list_request_t *R) +{ + return R->num_classes; +} + +xcb_generic_iterator_t +xcb_input_change_device_dont_propagate_list_classes_end (const xcb_input_change_device_dont_propagate_list_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_get_device_dont_propagate_list_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_get_device_dont_propagate_list_reply_t *_aux = (xcb_input_get_device_dont_propagate_list_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_get_device_dont_propagate_list_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* classes */ + xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_event_class_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_get_device_dont_propagate_list_cookie_t +xcb_input_get_device_dont_propagate_list (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_dont_propagate_list_cookie_t xcb_ret; + xcb_input_get_device_dont_propagate_list_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_device_dont_propagate_list_cookie_t +xcb_input_get_device_dont_propagate_list_unchecked (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_dont_propagate_list_cookie_t xcb_ret; + xcb_input_get_device_dont_propagate_list_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_event_class_t * +xcb_input_get_device_dont_propagate_list_classes (const xcb_input_get_device_dont_propagate_list_reply_t *R) +{ + return (xcb_input_event_class_t *) (R + 1); +} + +int +xcb_input_get_device_dont_propagate_list_classes_length (const xcb_input_get_device_dont_propagate_list_reply_t *R) +{ + return R->num_classes; +} + +xcb_generic_iterator_t +xcb_input_get_device_dont_propagate_list_classes_end (const xcb_input_get_device_dont_propagate_list_reply_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_get_device_dont_propagate_list_reply_t * +xcb_input_get_device_dont_propagate_list_reply (xcb_connection_t *c, + xcb_input_get_device_dont_propagate_list_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_get_device_dont_propagate_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_device_time_coord_sizeof (const void *_buffer, + uint8_t num_axes) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_device_time_coord_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* axisvalues */ + xcb_block_len += num_axes * sizeof(int32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(int32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +int32_t * +xcb_input_device_time_coord_axisvalues (const xcb_input_device_time_coord_t *R) +{ + return (int32_t *) (R + 1); +} + +int +xcb_input_device_time_coord_axisvalues_length (const xcb_input_device_time_coord_t *R, + uint8_t num_axes) +{ + return num_axes; +} + +xcb_generic_iterator_t +xcb_input_device_time_coord_axisvalues_end (const xcb_input_device_time_coord_t *R, + uint8_t num_axes) +{ + xcb_generic_iterator_t i; + i.data = ((int32_t *) (R + 1)) + (num_axes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_device_time_coord_next (xcb_input_device_time_coord_iterator_t *i) +{ + xcb_input_device_time_coord_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_device_time_coord_t *)(((char *)R) + xcb_input_device_time_coord_sizeof(R, i->num_axes)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_device_time_coord_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_device_time_coord_end (xcb_input_device_time_coord_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_device_time_coord_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_get_device_motion_events_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_get_device_motion_events_reply_t *_aux = (xcb_input_get_device_motion_events_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_input_get_device_motion_events_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* events */ + for(i=0; i<_aux->num_events; i++) { + xcb_tmp_len = xcb_input_device_time_coord_sizeof(xcb_tmp, _aux->num_axes); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_input_device_time_coord_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_get_device_motion_events_cookie_t +xcb_input_get_device_motion_events (xcb_connection_t *c, + xcb_timestamp_t start, + xcb_timestamp_t stop, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_MOTION_EVENTS, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_motion_events_cookie_t xcb_ret; + xcb_input_get_device_motion_events_request_t xcb_out; + + xcb_out.start = start; + xcb_out.stop = stop; + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_device_motion_events_cookie_t +xcb_input_get_device_motion_events_unchecked (xcb_connection_t *c, + xcb_timestamp_t start, + xcb_timestamp_t stop, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_MOTION_EVENTS, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_motion_events_cookie_t xcb_ret; + xcb_input_get_device_motion_events_request_t xcb_out; + + xcb_out.start = start; + xcb_out.stop = stop; + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_input_get_device_motion_events_events_length (const xcb_input_get_device_motion_events_reply_t *R) +{ + return R->num_events; +} + +xcb_input_device_time_coord_iterator_t +xcb_input_get_device_motion_events_events_iterator (const xcb_input_get_device_motion_events_reply_t *R) +{ + xcb_input_device_time_coord_iterator_t i; + i.data = (xcb_input_device_time_coord_t *) (R + 1); + i.rem = R->num_events; + i.index = (char *) i.data - (char *) R; + i.num_axes = R->num_axes; + return i; +} + +xcb_input_get_device_motion_events_reply_t * +xcb_input_get_device_motion_events_reply (xcb_connection_t *c, + xcb_input_get_device_motion_events_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_get_device_motion_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_input_change_keyboard_device_cookie_t +xcb_input_change_keyboard_device (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_KEYBOARD_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_change_keyboard_device_cookie_t xcb_ret; + xcb_input_change_keyboard_device_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_change_keyboard_device_cookie_t +xcb_input_change_keyboard_device_unchecked (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_KEYBOARD_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_change_keyboard_device_cookie_t xcb_ret; + xcb_input_change_keyboard_device_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_change_keyboard_device_reply_t * +xcb_input_change_keyboard_device_reply (xcb_connection_t *c, + xcb_input_change_keyboard_device_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_change_keyboard_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_input_change_pointer_device_cookie_t +xcb_input_change_pointer_device (xcb_connection_t *c, + uint8_t x_axis, + uint8_t y_axis, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_POINTER_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_change_pointer_device_cookie_t xcb_ret; + xcb_input_change_pointer_device_request_t xcb_out; + + xcb_out.x_axis = x_axis; + xcb_out.y_axis = y_axis; + xcb_out.device_id = device_id; + xcb_out.pad0 = 0; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_change_pointer_device_cookie_t +xcb_input_change_pointer_device_unchecked (xcb_connection_t *c, + uint8_t x_axis, + uint8_t y_axis, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_POINTER_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_change_pointer_device_cookie_t xcb_ret; + xcb_input_change_pointer_device_request_t xcb_out; + + xcb_out.x_axis = x_axis; + xcb_out.y_axis = y_axis; + xcb_out.device_id = device_id; + xcb_out.pad0 = 0; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_change_pointer_device_reply_t * +xcb_input_change_pointer_device_reply (xcb_connection_t *c, + xcb_input_change_pointer_device_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_change_pointer_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_grab_device_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_grab_device_request_t *_aux = (xcb_input_grab_device_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_grab_device_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* classes */ + xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_event_class_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_grab_device_cookie_t +xcb_input_grab_device (xcb_connection_t *c, + xcb_window_t grab_window, + xcb_timestamp_t time, + uint16_t num_classes, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + uint8_t device_id, + const xcb_input_event_class_t *classes) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GRAB_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_grab_device_cookie_t xcb_ret; + xcb_input_grab_device_request_t xcb_out; + + xcb_out.grab_window = grab_window; + xcb_out.time = time; + xcb_out.num_classes = num_classes; + xcb_out.this_device_mode = this_device_mode; + xcb_out.other_device_mode = other_device_mode; + xcb_out.owner_events = owner_events; + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_event_class_t classes */ + xcb_parts[4].iov_base = (char *) classes; + xcb_parts[4].iov_len = num_classes * sizeof(uint32_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_grab_device_cookie_t +xcb_input_grab_device_unchecked (xcb_connection_t *c, + xcb_window_t grab_window, + xcb_timestamp_t time, + uint16_t num_classes, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + uint8_t device_id, + const xcb_input_event_class_t *classes) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GRAB_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_grab_device_cookie_t xcb_ret; + xcb_input_grab_device_request_t xcb_out; + + xcb_out.grab_window = grab_window; + xcb_out.time = time; + xcb_out.num_classes = num_classes; + xcb_out.this_device_mode = this_device_mode; + xcb_out.other_device_mode = other_device_mode; + xcb_out.owner_events = owner_events; + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_event_class_t classes */ + xcb_parts[4].iov_base = (char *) classes; + xcb_parts[4].iov_len = num_classes * sizeof(uint32_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_grab_device_reply_t * +xcb_input_grab_device_reply (xcb_connection_t *c, + xcb_input_grab_device_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_void_cookie_t +xcb_input_ungrab_device_checked (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_UNGRAB_DEVICE, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_ungrab_device_request_t xcb_out; + + xcb_out.time = time; + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_ungrab_device (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_UNGRAB_DEVICE, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_ungrab_device_request_t xcb_out; + + xcb_out.time = time; + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_input_grab_device_key_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_grab_device_key_request_t *_aux = (xcb_input_grab_device_key_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_grab_device_key_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* classes */ + xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_event_class_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_input_grab_device_key_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t num_classes, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t grabbed_device, + uint8_t key, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + const xcb_input_event_class_t *classes) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GRAB_DEVICE_KEY, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_grab_device_key_request_t xcb_out; + + xcb_out.grab_window = grab_window; + xcb_out.num_classes = num_classes; + xcb_out.modifiers = modifiers; + xcb_out.modifier_device = modifier_device; + xcb_out.grabbed_device = grabbed_device; + xcb_out.key = key; + xcb_out.this_device_mode = this_device_mode; + xcb_out.other_device_mode = other_device_mode; + xcb_out.owner_events = owner_events; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_event_class_t classes */ + xcb_parts[4].iov_base = (char *) classes; + xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_grab_device_key (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t num_classes, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t grabbed_device, + uint8_t key, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + const xcb_input_event_class_t *classes) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GRAB_DEVICE_KEY, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_grab_device_key_request_t xcb_out; + + xcb_out.grab_window = grab_window; + xcb_out.num_classes = num_classes; + xcb_out.modifiers = modifiers; + xcb_out.modifier_device = modifier_device; + xcb_out.grabbed_device = grabbed_device; + xcb_out.key = key; + xcb_out.this_device_mode = this_device_mode; + xcb_out.other_device_mode = other_device_mode; + xcb_out.owner_events = owner_events; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_event_class_t classes */ + xcb_parts[4].iov_base = (char *) classes; + xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_event_class_t * +xcb_input_grab_device_key_classes (const xcb_input_grab_device_key_request_t *R) +{ + return (xcb_input_event_class_t *) (R + 1); +} + +int +xcb_input_grab_device_key_classes_length (const xcb_input_grab_device_key_request_t *R) +{ + return R->num_classes; +} + +xcb_generic_iterator_t +xcb_input_grab_device_key_classes_end (const xcb_input_grab_device_key_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_void_cookie_t +xcb_input_ungrab_device_key_checked (xcb_connection_t *c, + xcb_window_t grabWindow, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t key, + uint8_t grabbed_device) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_UNGRAB_DEVICE_KEY, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_ungrab_device_key_request_t xcb_out; + + xcb_out.grabWindow = grabWindow; + xcb_out.modifiers = modifiers; + xcb_out.modifier_device = modifier_device; + xcb_out.key = key; + xcb_out.grabbed_device = grabbed_device; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_ungrab_device_key (xcb_connection_t *c, + xcb_window_t grabWindow, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t key, + uint8_t grabbed_device) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_UNGRAB_DEVICE_KEY, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_ungrab_device_key_request_t xcb_out; + + xcb_out.grabWindow = grabWindow; + xcb_out.modifiers = modifiers; + xcb_out.modifier_device = modifier_device; + xcb_out.key = key; + xcb_out.grabbed_device = grabbed_device; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_input_grab_device_button_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_grab_device_button_request_t *_aux = (xcb_input_grab_device_button_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_grab_device_button_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* classes */ + xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_event_class_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_input_grab_device_button_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint8_t grabbed_device, + uint8_t modifier_device, + uint16_t num_classes, + uint16_t modifiers, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t button, + uint8_t owner_events, + const xcb_input_event_class_t *classes) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GRAB_DEVICE_BUTTON, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_grab_device_button_request_t xcb_out; + + xcb_out.grab_window = grab_window; + xcb_out.grabbed_device = grabbed_device; + xcb_out.modifier_device = modifier_device; + xcb_out.num_classes = num_classes; + xcb_out.modifiers = modifiers; + xcb_out.this_device_mode = this_device_mode; + xcb_out.other_device_mode = other_device_mode; + xcb_out.button = button; + xcb_out.owner_events = owner_events; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_event_class_t classes */ + xcb_parts[4].iov_base = (char *) classes; + xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_grab_device_button (xcb_connection_t *c, + xcb_window_t grab_window, + uint8_t grabbed_device, + uint8_t modifier_device, + uint16_t num_classes, + uint16_t modifiers, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t button, + uint8_t owner_events, + const xcb_input_event_class_t *classes) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GRAB_DEVICE_BUTTON, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_grab_device_button_request_t xcb_out; + + xcb_out.grab_window = grab_window; + xcb_out.grabbed_device = grabbed_device; + xcb_out.modifier_device = modifier_device; + xcb_out.num_classes = num_classes; + xcb_out.modifiers = modifiers; + xcb_out.this_device_mode = this_device_mode; + xcb_out.other_device_mode = other_device_mode; + xcb_out.button = button; + xcb_out.owner_events = owner_events; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_event_class_t classes */ + xcb_parts[4].iov_base = (char *) classes; + xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_event_class_t * +xcb_input_grab_device_button_classes (const xcb_input_grab_device_button_request_t *R) +{ + return (xcb_input_event_class_t *) (R + 1); +} + +int +xcb_input_grab_device_button_classes_length (const xcb_input_grab_device_button_request_t *R) +{ + return R->num_classes; +} + +xcb_generic_iterator_t +xcb_input_grab_device_button_classes_end (const xcb_input_grab_device_button_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_void_cookie_t +xcb_input_ungrab_device_button_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t button, + uint8_t grabbed_device) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_UNGRAB_DEVICE_BUTTON, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_ungrab_device_button_request_t xcb_out; + + xcb_out.grab_window = grab_window; + xcb_out.modifiers = modifiers; + xcb_out.modifier_device = modifier_device; + xcb_out.button = button; + xcb_out.grabbed_device = grabbed_device; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_ungrab_device_button (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t button, + uint8_t grabbed_device) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_UNGRAB_DEVICE_BUTTON, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_ungrab_device_button_request_t xcb_out; + + xcb_out.grab_window = grab_window; + xcb_out.modifiers = modifiers; + xcb_out.modifier_device = modifier_device; + xcb_out.button = button; + xcb_out.grabbed_device = grabbed_device; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_allow_device_events_checked (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t mode, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_ALLOW_DEVICE_EVENTS, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_allow_device_events_request_t xcb_out; + + xcb_out.time = time; + xcb_out.mode = mode; + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_allow_device_events (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t mode, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_ALLOW_DEVICE_EVENTS, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_allow_device_events_request_t xcb_out; + + xcb_out.time = time; + xcb_out.mode = mode; + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_device_focus_cookie_t +xcb_input_get_device_focus (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_FOCUS, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_focus_cookie_t xcb_ret; + xcb_input_get_device_focus_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_device_focus_cookie_t +xcb_input_get_device_focus_unchecked (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_FOCUS, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_focus_cookie_t xcb_ret; + xcb_input_get_device_focus_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_device_focus_reply_t * +xcb_input_get_device_focus_reply (xcb_connection_t *c, + xcb_input_get_device_focus_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_get_device_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_void_cookie_t +xcb_input_set_device_focus_checked (xcb_connection_t *c, + xcb_window_t focus, + xcb_timestamp_t time, + uint8_t revert_to, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_FOCUS, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_set_device_focus_request_t xcb_out; + + xcb_out.focus = focus; + xcb_out.time = time; + xcb_out.revert_to = revert_to; + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_set_device_focus (xcb_connection_t *c, + xcb_window_t focus, + xcb_timestamp_t time, + uint8_t revert_to, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_FOCUS, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_set_device_focus_request_t xcb_out; + + xcb_out.focus = focus; + xcb_out.time = time; + xcb_out.revert_to = revert_to; + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +void +xcb_input_kbd_feedback_state_next (xcb_input_kbd_feedback_state_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_kbd_feedback_state_t); +} + +xcb_generic_iterator_t +xcb_input_kbd_feedback_state_end (xcb_input_kbd_feedback_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_ptr_feedback_state_next (xcb_input_ptr_feedback_state_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_ptr_feedback_state_t); +} + +xcb_generic_iterator_t +xcb_input_ptr_feedback_state_end (xcb_input_ptr_feedback_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_integer_feedback_state_next (xcb_input_integer_feedback_state_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_integer_feedback_state_t); +} + +xcb_generic_iterator_t +xcb_input_integer_feedback_state_end (xcb_input_integer_feedback_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +int +xcb_input_string_feedback_state_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_string_feedback_state_t *_aux = (xcb_input_string_feedback_state_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_string_feedback_state_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* keysyms */ + xcb_block_len += _aux->num_keysyms * sizeof(xcb_keysym_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_keysym_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_keysym_t * +xcb_input_string_feedback_state_keysyms (const xcb_input_string_feedback_state_t *R) +{ + return (xcb_keysym_t *) (R + 1); +} + +int +xcb_input_string_feedback_state_keysyms_length (const xcb_input_string_feedback_state_t *R) +{ + return R->num_keysyms; +} + +xcb_generic_iterator_t +xcb_input_string_feedback_state_keysyms_end (const xcb_input_string_feedback_state_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_keysym_t *) (R + 1)) + (R->num_keysyms); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_string_feedback_state_next (xcb_input_string_feedback_state_iterator_t *i) +{ + xcb_input_string_feedback_state_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_string_feedback_state_t *)(((char *)R) + xcb_input_string_feedback_state_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_string_feedback_state_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_string_feedback_state_end (xcb_input_string_feedback_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_string_feedback_state_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +void +xcb_input_bell_feedback_state_next (xcb_input_bell_feedback_state_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_bell_feedback_state_t); +} + +xcb_generic_iterator_t +xcb_input_bell_feedback_state_end (xcb_input_bell_feedback_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_led_feedback_state_next (xcb_input_led_feedback_state_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_led_feedback_state_t); +} + +xcb_generic_iterator_t +xcb_input_led_feedback_state_end (xcb_input_led_feedback_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +xcb_keysym_t * +xcb_input_feedback_state_data_string_keysyms (const xcb_input_feedback_state_data_t *S) +{ + return S->string.keysyms; +} + +int +xcb_input_feedback_state_data_string_keysyms_length (const xcb_input_feedback_state_t *R, + const xcb_input_feedback_state_data_t *S) +{ + return S->string.num_keysyms; +} + +xcb_generic_iterator_t +xcb_input_feedback_state_data_string_keysyms_end (const xcb_input_feedback_state_t *R, + const xcb_input_feedback_state_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->string.keysyms + S->string.num_keysyms; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_feedback_state_data_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_feedback_state_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[27]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) { + /* xcb_input_feedback_state_data_t.keyboard.pitch */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.pitch; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.keyboard.duration */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.duration; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.keyboard.led_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.keyboard.led_values */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_values; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.keyboard.global_auto_repeat */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.global_auto_repeat; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.click */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.click; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.percent */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.percent; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.auto_repeats */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyboard.auto_repeats; + xcb_block_len += 32; + xcb_parts[xcb_parts_idx].iov_len = 32; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) { + /* xcb_input_feedback_state_data_t.pointer.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.pointer.accel_num */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.accel_num; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.pointer.accel_denom */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.accel_denom; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.pointer.threshold */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.threshold; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) { + /* xcb_input_feedback_state_data_t.string.max_symbols */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->string.max_symbols; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.string.num_keysyms */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->string.num_keysyms; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* keysyms */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->string.keysyms; + xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->string.num_keysyms * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_keysym_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) { + /* xcb_input_feedback_state_data_t.integer.resolution */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.resolution; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.integer.min_value */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.min_value; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_feedback_state_data_t.integer.max_value */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.max_value; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) { + /* xcb_input_feedback_state_data_t.led.led_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.led.led_values */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_values; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) { + /* xcb_input_feedback_state_data_t.bell.percent */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.percent; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.bell.pad2 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*3; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.bell.pitch */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.pitch; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.bell.duration */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.duration; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; i<xcb_parts_idx; i++) { + if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) + memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); + if (0 != xcb_parts[i].iov_len) + xcb_tmp += xcb_parts[i].iov_len; + } + + return xcb_buffer_len; +} + +int +xcb_input_feedback_state_data_unpack (const void *_buffer, + uint8_t class_id, + xcb_input_feedback_state_data_t *_aux) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + + if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) { + /* xcb_input_feedback_state_data_t.keyboard.pitch */ + _aux->keyboard.pitch = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.keyboard.duration */ + _aux->keyboard.duration = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.keyboard.led_mask */ + _aux->keyboard.led_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.keyboard.led_values */ + _aux->keyboard.led_values = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.keyboard.global_auto_repeat */ + _aux->keyboard.global_auto_repeat = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.click */ + _aux->keyboard.click = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.percent */ + _aux->keyboard.percent = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.pad0 */ + _aux->keyboard.pad0 = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.auto_repeats */ + memcpy(_aux->keyboard.auto_repeats, xcb_tmp, sizeof(uint8_t) * 32); + xcb_block_len += sizeof(uint8_t) * 32; + xcb_tmp += sizeof(uint8_t) * 32; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) { + /* xcb_input_feedback_state_data_t.pointer.pad1 */ + _aux->pointer.pad1[0] = *(uint8_t *)xcb_tmp; + _aux->pointer.pad1[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.pointer.accel_num */ + _aux->pointer.accel_num = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.pointer.accel_denom */ + _aux->pointer.accel_denom = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.pointer.threshold */ + _aux->pointer.threshold = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) { + /* xcb_input_feedback_state_data_t.string.max_symbols */ + _aux->string.max_symbols = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.string.num_keysyms */ + _aux->string.num_keysyms = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* keysyms */ + _aux->string.keysyms = (xcb_keysym_t *)xcb_tmp; + xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_keysym_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) { + /* xcb_input_feedback_state_data_t.integer.resolution */ + _aux->integer.resolution = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.integer.min_value */ + _aux->integer.min_value = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_feedback_state_data_t.integer.max_value */ + _aux->integer.max_value = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) { + /* xcb_input_feedback_state_data_t.led.led_mask */ + _aux->led.led_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.led.led_values */ + _aux->led.led_values = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) { + /* xcb_input_feedback_state_data_t.bell.percent */ + _aux->bell.percent = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.bell.pad2 */ + _aux->bell.pad2[0] = *(uint8_t *)xcb_tmp; + _aux->bell.pad2[1] = *(uint8_t *)xcb_tmp; + _aux->bell.pad2[2] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 3; + xcb_tmp += sizeof(uint8_t) * 3; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.bell.pitch */ + _aux->bell.pitch = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.bell.duration */ + _aux->bell.duration = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + return xcb_buffer_len; +} + +int +xcb_input_feedback_state_data_sizeof (const void *_buffer, + uint8_t class_id) +{ + xcb_input_feedback_state_data_t _aux; + return xcb_input_feedback_state_data_unpack(_buffer, class_id, &_aux); +} + +int +xcb_input_feedback_state_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_feedback_state_t *_aux = (xcb_input_feedback_state_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_feedback_state_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* data */ + xcb_block_len += xcb_input_feedback_state_data_sizeof(xcb_tmp, _aux->class_id); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +void * +xcb_input_feedback_state_data (const xcb_input_feedback_state_t *R) +{ + return (void *) (R + 1); +} + +void +xcb_input_feedback_state_next (xcb_input_feedback_state_iterator_t *i) +{ + xcb_input_feedback_state_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_feedback_state_t *)(((char *)R) + xcb_input_feedback_state_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_feedback_state_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_feedback_state_end (xcb_input_feedback_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_feedback_state_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_get_feedback_control_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_get_feedback_control_reply_t *_aux = (xcb_input_get_feedback_control_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_input_get_feedback_control_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* feedbacks */ + for(i=0; i<_aux->num_feedbacks; i++) { + xcb_tmp_len = xcb_input_feedback_state_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_input_feedback_state_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_get_feedback_control_cookie_t +xcb_input_get_feedback_control (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_FEEDBACK_CONTROL, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_feedback_control_cookie_t xcb_ret; + xcb_input_get_feedback_control_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_feedback_control_cookie_t +xcb_input_get_feedback_control_unchecked (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_FEEDBACK_CONTROL, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_feedback_control_cookie_t xcb_ret; + xcb_input_get_feedback_control_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_input_get_feedback_control_feedbacks_length (const xcb_input_get_feedback_control_reply_t *R) +{ + return R->num_feedbacks; +} + +xcb_input_feedback_state_iterator_t +xcb_input_get_feedback_control_feedbacks_iterator (const xcb_input_get_feedback_control_reply_t *R) +{ + xcb_input_feedback_state_iterator_t i; + i.data = (xcb_input_feedback_state_t *) (R + 1); + i.rem = R->num_feedbacks; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_get_feedback_control_reply_t * +xcb_input_get_feedback_control_reply (xcb_connection_t *c, + xcb_input_get_feedback_control_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_get_feedback_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +void +xcb_input_kbd_feedback_ctl_next (xcb_input_kbd_feedback_ctl_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_kbd_feedback_ctl_t); +} + +xcb_generic_iterator_t +xcb_input_kbd_feedback_ctl_end (xcb_input_kbd_feedback_ctl_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_ptr_feedback_ctl_next (xcb_input_ptr_feedback_ctl_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_ptr_feedback_ctl_t); +} + +xcb_generic_iterator_t +xcb_input_ptr_feedback_ctl_end (xcb_input_ptr_feedback_ctl_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_integer_feedback_ctl_next (xcb_input_integer_feedback_ctl_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_integer_feedback_ctl_t); +} + +xcb_generic_iterator_t +xcb_input_integer_feedback_ctl_end (xcb_input_integer_feedback_ctl_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +int +xcb_input_string_feedback_ctl_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_string_feedback_ctl_t *_aux = (xcb_input_string_feedback_ctl_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_string_feedback_ctl_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* keysyms */ + xcb_block_len += _aux->num_keysyms * sizeof(xcb_keysym_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_keysym_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_keysym_t * +xcb_input_string_feedback_ctl_keysyms (const xcb_input_string_feedback_ctl_t *R) +{ + return (xcb_keysym_t *) (R + 1); +} + +int +xcb_input_string_feedback_ctl_keysyms_length (const xcb_input_string_feedback_ctl_t *R) +{ + return R->num_keysyms; +} + +xcb_generic_iterator_t +xcb_input_string_feedback_ctl_keysyms_end (const xcb_input_string_feedback_ctl_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_keysym_t *) (R + 1)) + (R->num_keysyms); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_string_feedback_ctl_next (xcb_input_string_feedback_ctl_iterator_t *i) +{ + xcb_input_string_feedback_ctl_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_string_feedback_ctl_t *)(((char *)R) + xcb_input_string_feedback_ctl_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_string_feedback_ctl_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_string_feedback_ctl_end (xcb_input_string_feedback_ctl_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_string_feedback_ctl_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +void +xcb_input_bell_feedback_ctl_next (xcb_input_bell_feedback_ctl_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_bell_feedback_ctl_t); +} + +xcb_generic_iterator_t +xcb_input_bell_feedback_ctl_end (xcb_input_bell_feedback_ctl_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_led_feedback_ctl_next (xcb_input_led_feedback_ctl_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_led_feedback_ctl_t); +} + +xcb_generic_iterator_t +xcb_input_led_feedback_ctl_end (xcb_input_led_feedback_ctl_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +xcb_keysym_t * +xcb_input_feedback_ctl_data_string_keysyms (const xcb_input_feedback_ctl_data_t *S) +{ + return S->string.keysyms; +} + +int +xcb_input_feedback_ctl_data_string_keysyms_length (const xcb_input_feedback_ctl_t *R, + const xcb_input_feedback_ctl_data_t *S) +{ + return S->string.num_keysyms; +} + +xcb_generic_iterator_t +xcb_input_feedback_ctl_data_string_keysyms_end (const xcb_input_feedback_ctl_t *R, + const xcb_input_feedback_ctl_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->string.keysyms + S->string.num_keysyms; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_feedback_ctl_data_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_feedback_ctl_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[24]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) { + /* xcb_input_feedback_ctl_data_t.keyboard.key */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.key; + xcb_block_len += sizeof(xcb_input_key_code_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_key_code_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_key_code_t); + /* xcb_input_feedback_ctl_data_t.keyboard.auto_repeat_mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.auto_repeat_mode; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.keyboard.key_click_percent */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.key_click_percent; + xcb_block_len += sizeof(int8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int8_t); + /* xcb_input_feedback_ctl_data_t.keyboard.bell_percent */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.bell_percent; + xcb_block_len += sizeof(int8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int8_t); + /* xcb_input_feedback_ctl_data_t.keyboard.bell_pitch */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.bell_pitch; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.keyboard.bell_duration */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.bell_duration; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.keyboard.led_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_ctl_data_t.keyboard.led_values */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_values; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) { + /* xcb_input_feedback_ctl_data_t.pointer.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.pointer.num */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.num; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.pointer.denom */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.denom; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.pointer.threshold */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.threshold; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) { + /* xcb_input_feedback_ctl_data_t.string.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.string.num_keysyms */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->string.num_keysyms; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* keysyms */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->string.keysyms; + xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->string.num_keysyms * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_keysym_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) { + /* xcb_input_feedback_ctl_data_t.integer.int_to_display */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.int_to_display; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) { + /* xcb_input_feedback_ctl_data_t.led.led_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_ctl_data_t.led.led_values */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_values; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) { + /* xcb_input_feedback_ctl_data_t.bell.percent */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.percent; + xcb_block_len += sizeof(int8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int8_t); + /* xcb_input_feedback_ctl_data_t.bell.pad2 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*3; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.bell.pitch */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.pitch; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.bell.duration */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.duration; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; i<xcb_parts_idx; i++) { + if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) + memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); + if (0 != xcb_parts[i].iov_len) + xcb_tmp += xcb_parts[i].iov_len; + } + + return xcb_buffer_len; +} + +int +xcb_input_feedback_ctl_data_unpack (const void *_buffer, + uint8_t class_id, + xcb_input_feedback_ctl_data_t *_aux) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + + if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) { + /* xcb_input_feedback_ctl_data_t.keyboard.key */ + _aux->keyboard.key = *(xcb_input_key_code_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_key_code_t); + xcb_tmp += sizeof(xcb_input_key_code_t); + xcb_align_to = ALIGNOF(xcb_input_key_code_t); + /* xcb_input_feedback_ctl_data_t.keyboard.auto_repeat_mode */ + _aux->keyboard.auto_repeat_mode = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.keyboard.key_click_percent */ + _aux->keyboard.key_click_percent = *(int8_t *)xcb_tmp; + xcb_block_len += sizeof(int8_t); + xcb_tmp += sizeof(int8_t); + xcb_align_to = ALIGNOF(int8_t); + /* xcb_input_feedback_ctl_data_t.keyboard.bell_percent */ + _aux->keyboard.bell_percent = *(int8_t *)xcb_tmp; + xcb_block_len += sizeof(int8_t); + xcb_tmp += sizeof(int8_t); + xcb_align_to = ALIGNOF(int8_t); + /* xcb_input_feedback_ctl_data_t.keyboard.bell_pitch */ + _aux->keyboard.bell_pitch = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.keyboard.bell_duration */ + _aux->keyboard.bell_duration = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.keyboard.led_mask */ + _aux->keyboard.led_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_ctl_data_t.keyboard.led_values */ + _aux->keyboard.led_values = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) { + /* xcb_input_feedback_ctl_data_t.pointer.pad0 */ + _aux->pointer.pad0[0] = *(uint8_t *)xcb_tmp; + _aux->pointer.pad0[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.pointer.num */ + _aux->pointer.num = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.pointer.denom */ + _aux->pointer.denom = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.pointer.threshold */ + _aux->pointer.threshold = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) { + /* xcb_input_feedback_ctl_data_t.string.pad1 */ + _aux->string.pad1[0] = *(uint8_t *)xcb_tmp; + _aux->string.pad1[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.string.num_keysyms */ + _aux->string.num_keysyms = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* keysyms */ + _aux->string.keysyms = (xcb_keysym_t *)xcb_tmp; + xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_keysym_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) { + /* xcb_input_feedback_ctl_data_t.integer.int_to_display */ + _aux->integer.int_to_display = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) { + /* xcb_input_feedback_ctl_data_t.led.led_mask */ + _aux->led.led_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_ctl_data_t.led.led_values */ + _aux->led.led_values = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) { + /* xcb_input_feedback_ctl_data_t.bell.percent */ + _aux->bell.percent = *(int8_t *)xcb_tmp; + xcb_block_len += sizeof(int8_t); + xcb_tmp += sizeof(int8_t); + xcb_align_to = ALIGNOF(int8_t); + /* xcb_input_feedback_ctl_data_t.bell.pad2 */ + _aux->bell.pad2[0] = *(uint8_t *)xcb_tmp; + _aux->bell.pad2[1] = *(uint8_t *)xcb_tmp; + _aux->bell.pad2[2] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 3; + xcb_tmp += sizeof(uint8_t) * 3; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.bell.pitch */ + _aux->bell.pitch = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.bell.duration */ + _aux->bell.duration = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + return xcb_buffer_len; +} + +int +xcb_input_feedback_ctl_data_sizeof (const void *_buffer, + uint8_t class_id) +{ + xcb_input_feedback_ctl_data_t _aux; + return xcb_input_feedback_ctl_data_unpack(_buffer, class_id, &_aux); +} + +int +xcb_input_feedback_ctl_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_feedback_ctl_t *_aux = (xcb_input_feedback_ctl_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_feedback_ctl_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* data */ + xcb_block_len += xcb_input_feedback_ctl_data_sizeof(xcb_tmp, _aux->class_id); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +void * +xcb_input_feedback_ctl_data (const xcb_input_feedback_ctl_t *R) +{ + return (void *) (R + 1); +} + +void +xcb_input_feedback_ctl_next (xcb_input_feedback_ctl_iterator_t *i) +{ + xcb_input_feedback_ctl_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_feedback_ctl_t *)(((char *)R) + xcb_input_feedback_ctl_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_feedback_ctl_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_feedback_ctl_end (xcb_input_feedback_ctl_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_feedback_ctl_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_change_feedback_control_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_change_feedback_control_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* feedback */ + xcb_block_len += xcb_input_feedback_ctl_sizeof(xcb_tmp); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_feedback_ctl_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_input_change_feedback_control_checked (xcb_connection_t *c, + uint32_t mask, + uint8_t device_id, + uint8_t feedback_id, + xcb_input_feedback_ctl_t *feedback) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_FEEDBACK_CONTROL, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_change_feedback_control_request_t xcb_out; + + xcb_out.mask = mask; + xcb_out.device_id = device_id; + xcb_out.feedback_id = feedback_id; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_feedback_ctl_t feedback */ + xcb_parts[4].iov_base = (char *) feedback; + xcb_parts[4].iov_len = + xcb_input_feedback_ctl_sizeof (feedback); + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_change_feedback_control (xcb_connection_t *c, + uint32_t mask, + uint8_t device_id, + uint8_t feedback_id, + xcb_input_feedback_ctl_t *feedback) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_FEEDBACK_CONTROL, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_change_feedback_control_request_t xcb_out; + + xcb_out.mask = mask; + xcb_out.device_id = device_id; + xcb_out.feedback_id = feedback_id; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_feedback_ctl_t feedback */ + xcb_parts[4].iov_base = (char *) feedback; + xcb_parts[4].iov_len = + xcb_input_feedback_ctl_sizeof (feedback); + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_feedback_ctl_t * +xcb_input_change_feedback_control_feedback (const xcb_input_change_feedback_control_request_t *R) +{ + return (xcb_input_feedback_ctl_t *) (R + 1); +} + +int +xcb_input_get_device_key_mapping_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_get_device_key_mapping_reply_t *_aux = (xcb_input_get_device_key_mapping_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_get_device_key_mapping_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* keysyms */ + xcb_block_len += _aux->length * sizeof(xcb_keysym_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_keysym_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_get_device_key_mapping_cookie_t +xcb_input_get_device_key_mapping (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t count) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_KEY_MAPPING, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_key_mapping_cookie_t xcb_ret; + xcb_input_get_device_key_mapping_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.first_keycode = first_keycode; + xcb_out.count = count; + xcb_out.pad0 = 0; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_device_key_mapping_cookie_t +xcb_input_get_device_key_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t count) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_KEY_MAPPING, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_key_mapping_cookie_t xcb_ret; + xcb_input_get_device_key_mapping_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.first_keycode = first_keycode; + xcb_out.count = count; + xcb_out.pad0 = 0; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_keysym_t * +xcb_input_get_device_key_mapping_keysyms (const xcb_input_get_device_key_mapping_reply_t *R) +{ + return (xcb_keysym_t *) (R + 1); +} + +int +xcb_input_get_device_key_mapping_keysyms_length (const xcb_input_get_device_key_mapping_reply_t *R) +{ + return R->length; +} + +xcb_generic_iterator_t +xcb_input_get_device_key_mapping_keysyms_end (const xcb_input_get_device_key_mapping_reply_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_keysym_t *) (R + 1)) + (R->length); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_get_device_key_mapping_reply_t * +xcb_input_get_device_key_mapping_reply (xcb_connection_t *c, + xcb_input_get_device_key_mapping_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_get_device_key_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_change_device_key_mapping_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_change_device_key_mapping_request_t *_aux = (xcb_input_change_device_key_mapping_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_change_device_key_mapping_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* keysyms */ + xcb_block_len += (_aux->keycode_count * _aux->keysyms_per_keycode) * sizeof(xcb_keysym_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_keysym_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_input_change_device_key_mapping_checked (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t keysyms_per_keycode, + uint8_t keycode_count, + const xcb_keysym_t *keysyms) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_change_device_key_mapping_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.first_keycode = first_keycode; + xcb_out.keysyms_per_keycode = keysyms_per_keycode; + xcb_out.keycode_count = keycode_count; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_keysym_t keysyms */ + xcb_parts[4].iov_base = (char *) keysyms; + xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_change_device_key_mapping (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t keysyms_per_keycode, + uint8_t keycode_count, + const xcb_keysym_t *keysyms) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_change_device_key_mapping_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.first_keycode = first_keycode; + xcb_out.keysyms_per_keycode = keysyms_per_keycode; + xcb_out.keycode_count = keycode_count; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_keysym_t keysyms */ + xcb_parts[4].iov_base = (char *) keysyms; + xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_keysym_t * +xcb_input_change_device_key_mapping_keysyms (const xcb_input_change_device_key_mapping_request_t *R) +{ + return (xcb_keysym_t *) (R + 1); +} + +int +xcb_input_change_device_key_mapping_keysyms_length (const xcb_input_change_device_key_mapping_request_t *R) +{ + return (R->keycode_count * R->keysyms_per_keycode); +} + +xcb_generic_iterator_t +xcb_input_change_device_key_mapping_keysyms_end (const xcb_input_change_device_key_mapping_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_keysym_t *) (R + 1)) + ((R->keycode_count * R->keysyms_per_keycode)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_get_device_modifier_mapping_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_get_device_modifier_mapping_reply_t *_aux = (xcb_input_get_device_modifier_mapping_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_get_device_modifier_mapping_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* keymaps */ + xcb_block_len += (_aux->keycodes_per_modifier * 8) * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_get_device_modifier_mapping_cookie_t +xcb_input_get_device_modifier_mapping (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_modifier_mapping_cookie_t xcb_ret; + xcb_input_get_device_modifier_mapping_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_device_modifier_mapping_cookie_t +xcb_input_get_device_modifier_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_modifier_mapping_cookie_t xcb_ret; + xcb_input_get_device_modifier_mapping_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +uint8_t * +xcb_input_get_device_modifier_mapping_keymaps (const xcb_input_get_device_modifier_mapping_reply_t *R) +{ + return (uint8_t *) (R + 1); +} + +int +xcb_input_get_device_modifier_mapping_keymaps_length (const xcb_input_get_device_modifier_mapping_reply_t *R) +{ + return (R->keycodes_per_modifier * 8); +} + +xcb_generic_iterator_t +xcb_input_get_device_modifier_mapping_keymaps_end (const xcb_input_get_device_modifier_mapping_reply_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + ((R->keycodes_per_modifier * 8)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_get_device_modifier_mapping_reply_t * +xcb_input_get_device_modifier_mapping_reply (xcb_connection_t *c, + xcb_input_get_device_modifier_mapping_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_get_device_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_set_device_modifier_mapping_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_set_device_modifier_mapping_request_t *_aux = (xcb_input_set_device_modifier_mapping_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_set_device_modifier_mapping_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* keymaps */ + xcb_block_len += (_aux->keycodes_per_modifier * 8) * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_set_device_modifier_mapping_cookie_t +xcb_input_set_device_modifier_mapping (xcb_connection_t *c, + uint8_t device_id, + uint8_t keycodes_per_modifier, + const uint8_t *keymaps) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_set_device_modifier_mapping_cookie_t xcb_ret; + xcb_input_set_device_modifier_mapping_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.keycodes_per_modifier = keycodes_per_modifier; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint8_t keymaps */ + xcb_parts[4].iov_base = (char *) keymaps; + xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_set_device_modifier_mapping_cookie_t +xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t keycodes_per_modifier, + const uint8_t *keymaps) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_set_device_modifier_mapping_cookie_t xcb_ret; + xcb_input_set_device_modifier_mapping_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.keycodes_per_modifier = keycodes_per_modifier; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint8_t keymaps */ + xcb_parts[4].iov_base = (char *) keymaps; + xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_set_device_modifier_mapping_reply_t * +xcb_input_set_device_modifier_mapping_reply (xcb_connection_t *c, + xcb_input_set_device_modifier_mapping_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_set_device_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_get_device_button_mapping_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_get_device_button_mapping_reply_t *_aux = (xcb_input_get_device_button_mapping_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_get_device_button_mapping_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* map */ + xcb_block_len += _aux->map_size * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_get_device_button_mapping_cookie_t +xcb_input_get_device_button_mapping (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_BUTTON_MAPPING, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_button_mapping_cookie_t xcb_ret; + xcb_input_get_device_button_mapping_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_device_button_mapping_cookie_t +xcb_input_get_device_button_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_BUTTON_MAPPING, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_button_mapping_cookie_t xcb_ret; + xcb_input_get_device_button_mapping_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +uint8_t * +xcb_input_get_device_button_mapping_map (const xcb_input_get_device_button_mapping_reply_t *R) +{ + return (uint8_t *) (R + 1); +} + +int +xcb_input_get_device_button_mapping_map_length (const xcb_input_get_device_button_mapping_reply_t *R) +{ + return R->map_size; +} + +xcb_generic_iterator_t +xcb_input_get_device_button_mapping_map_end (const xcb_input_get_device_button_mapping_reply_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + (R->map_size); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_get_device_button_mapping_reply_t * +xcb_input_get_device_button_mapping_reply (xcb_connection_t *c, + xcb_input_get_device_button_mapping_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_get_device_button_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_set_device_button_mapping_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_set_device_button_mapping_request_t *_aux = (xcb_input_set_device_button_mapping_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_set_device_button_mapping_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* map */ + xcb_block_len += _aux->map_size * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_set_device_button_mapping_cookie_t +xcb_input_set_device_button_mapping (xcb_connection_t *c, + uint8_t device_id, + uint8_t map_size, + const uint8_t *map) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_BUTTON_MAPPING, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_set_device_button_mapping_cookie_t xcb_ret; + xcb_input_set_device_button_mapping_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.map_size = map_size; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint8_t map */ + xcb_parts[4].iov_base = (char *) map; + xcb_parts[4].iov_len = map_size * sizeof(uint8_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_set_device_button_mapping_cookie_t +xcb_input_set_device_button_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t map_size, + const uint8_t *map) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_BUTTON_MAPPING, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_set_device_button_mapping_cookie_t xcb_ret; + xcb_input_set_device_button_mapping_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.map_size = map_size; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint8_t map */ + xcb_parts[4].iov_base = (char *) map; + xcb_parts[4].iov_len = map_size * sizeof(uint8_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_set_device_button_mapping_reply_t * +xcb_input_set_device_button_mapping_reply (xcb_connection_t *c, + xcb_input_set_device_button_mapping_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_set_device_button_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +void +xcb_input_key_state_next (xcb_input_key_state_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_key_state_t); +} + +xcb_generic_iterator_t +xcb_input_key_state_end (xcb_input_key_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_button_state_next (xcb_input_button_state_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_button_state_t); +} + +xcb_generic_iterator_t +xcb_input_button_state_end (xcb_input_button_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +int +xcb_input_valuator_state_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_valuator_state_t *_aux = (xcb_input_valuator_state_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_valuator_state_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* valuators */ + xcb_block_len += _aux->num_valuators * sizeof(int32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(int32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +int32_t * +xcb_input_valuator_state_valuators (const xcb_input_valuator_state_t *R) +{ + return (int32_t *) (R + 1); +} + +int +xcb_input_valuator_state_valuators_length (const xcb_input_valuator_state_t *R) +{ + return R->num_valuators; +} + +xcb_generic_iterator_t +xcb_input_valuator_state_valuators_end (const xcb_input_valuator_state_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((int32_t *) (R + 1)) + (R->num_valuators); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_valuator_state_next (xcb_input_valuator_state_iterator_t *i) +{ + xcb_input_valuator_state_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_valuator_state_t *)(((char *)R) + xcb_input_valuator_state_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_valuator_state_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_valuator_state_end (xcb_input_valuator_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_valuator_state_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int32_t * +xcb_input_input_state_data_valuator_valuators (const xcb_input_input_state_data_t *S) +{ + return S->valuator.valuators; +} + +int +xcb_input_input_state_data_valuator_valuators_length (const xcb_input_input_state_t *R, + const xcb_input_input_state_data_t *S) +{ + return S->valuator.num_valuators; +} + +xcb_generic_iterator_t +xcb_input_input_state_data_valuator_valuators_end (const xcb_input_input_state_t *R, + const xcb_input_input_state_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->valuator.valuators + S->valuator.num_valuators; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_input_state_data_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_input_state_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 2; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[11]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(class_id == XCB_INPUT_INPUT_CLASS_KEY) { + /* xcb_input_input_state_data_t.key.num_keys */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.num_keys; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.key.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.key.keys */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->key.keys; + xcb_block_len += 32; + xcb_parts[xcb_parts_idx].iov_len = 32; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) { + /* xcb_input_input_state_data_t.button.num_buttons */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->button.num_buttons; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.button.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.button.buttons */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->button.buttons; + xcb_block_len += 32; + xcb_parts[xcb_parts_idx].iov_len = 32; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) { + /* xcb_input_input_state_data_t.valuator.num_valuators */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.num_valuators; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.valuator.mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.mode; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* valuators */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->valuator.valuators; + xcb_block_len += _aux->valuator.num_valuators * sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->valuator.num_valuators * sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; i<xcb_parts_idx; i++) { + if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) + memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); + if (0 != xcb_parts[i].iov_len) + xcb_tmp += xcb_parts[i].iov_len; + } + + return xcb_buffer_len; +} + +int +xcb_input_input_state_data_unpack (const void *_buffer, + uint8_t class_id, + xcb_input_input_state_data_t *_aux) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 2; + + + if(class_id == XCB_INPUT_INPUT_CLASS_KEY) { + /* xcb_input_input_state_data_t.key.num_keys */ + _aux->key.num_keys = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.key.pad0 */ + _aux->key.pad0 = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.key.keys */ + memcpy(_aux->key.keys, xcb_tmp, sizeof(uint8_t) * 32); + xcb_block_len += sizeof(uint8_t) * 32; + xcb_tmp += sizeof(uint8_t) * 32; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) { + /* xcb_input_input_state_data_t.button.num_buttons */ + _aux->button.num_buttons = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.button.pad1 */ + _aux->button.pad1 = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.button.buttons */ + memcpy(_aux->button.buttons, xcb_tmp, sizeof(uint8_t) * 32); + xcb_block_len += sizeof(uint8_t) * 32; + xcb_tmp += sizeof(uint8_t) * 32; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) { + /* xcb_input_input_state_data_t.valuator.num_valuators */ + _aux->valuator.num_valuators = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.valuator.mode */ + _aux->valuator.mode = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* valuators */ + _aux->valuator.valuators = (int32_t *)xcb_tmp; + xcb_block_len += _aux->valuator.num_valuators * sizeof(int32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(int32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + return xcb_buffer_len; +} + +int +xcb_input_input_state_data_sizeof (const void *_buffer, + uint8_t class_id) +{ + xcb_input_input_state_data_t _aux; + return xcb_input_input_state_data_unpack(_buffer, class_id, &_aux); +} + +int +xcb_input_input_state_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_input_state_t *_aux = (xcb_input_input_state_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_input_state_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* data */ + xcb_block_len += xcb_input_input_state_data_sizeof(xcb_tmp, _aux->class_id); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +void * +xcb_input_input_state_data (const xcb_input_input_state_t *R) +{ + return (void *) (R + 1); +} + +void +xcb_input_input_state_next (xcb_input_input_state_iterator_t *i) +{ + xcb_input_input_state_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_input_state_t *)(((char *)R) + xcb_input_input_state_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_input_state_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_input_state_end (xcb_input_input_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_input_state_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_query_device_state_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_query_device_state_reply_t *_aux = (xcb_input_query_device_state_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_input_query_device_state_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* classes */ + for(i=0; i<_aux->num_classes; i++) { + xcb_tmp_len = xcb_input_input_state_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_input_input_state_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_query_device_state_cookie_t +xcb_input_query_device_state (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_QUERY_DEVICE_STATE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_query_device_state_cookie_t xcb_ret; + xcb_input_query_device_state_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_query_device_state_cookie_t +xcb_input_query_device_state_unchecked (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_QUERY_DEVICE_STATE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_query_device_state_cookie_t xcb_ret; + xcb_input_query_device_state_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_input_query_device_state_classes_length (const xcb_input_query_device_state_reply_t *R) +{ + return R->num_classes; +} + +xcb_input_input_state_iterator_t +xcb_input_query_device_state_classes_iterator (const xcb_input_query_device_state_reply_t *R) +{ + xcb_input_input_state_iterator_t i; + i.data = (xcb_input_input_state_t *) (R + 1); + i.rem = R->num_classes; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_query_device_state_reply_t * +xcb_input_query_device_state_reply (xcb_connection_t *c, + xcb_input_query_device_state_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_query_device_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_void_cookie_t +xcb_input_device_bell_checked (xcb_connection_t *c, + uint8_t device_id, + uint8_t feedback_id, + uint8_t feedback_class, + int8_t percent) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_DEVICE_BELL, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_device_bell_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.feedback_id = feedback_id; + xcb_out.feedback_class = feedback_class; + xcb_out.percent = percent; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_device_bell (xcb_connection_t *c, + uint8_t device_id, + uint8_t feedback_id, + uint8_t feedback_class, + int8_t percent) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_DEVICE_BELL, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_device_bell_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.feedback_id = feedback_id; + xcb_out.feedback_class = feedback_class; + xcb_out.percent = percent; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_input_set_device_valuators_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_set_device_valuators_request_t *_aux = (xcb_input_set_device_valuators_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_set_device_valuators_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* valuators */ + xcb_block_len += _aux->num_valuators * sizeof(int32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(int32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_set_device_valuators_cookie_t +xcb_input_set_device_valuators (xcb_connection_t *c, + uint8_t device_id, + uint8_t first_valuator, + uint8_t num_valuators, + const int32_t *valuators) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_VALUATORS, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_set_device_valuators_cookie_t xcb_ret; + xcb_input_set_device_valuators_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.first_valuator = first_valuator; + xcb_out.num_valuators = num_valuators; + xcb_out.pad0 = 0; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* int32_t valuators */ + xcb_parts[4].iov_base = (char *) valuators; + xcb_parts[4].iov_len = num_valuators * sizeof(int32_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_set_device_valuators_cookie_t +xcb_input_set_device_valuators_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t first_valuator, + uint8_t num_valuators, + const int32_t *valuators) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_VALUATORS, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_set_device_valuators_cookie_t xcb_ret; + xcb_input_set_device_valuators_request_t xcb_out; + + xcb_out.device_id = device_id; + xcb_out.first_valuator = first_valuator; + xcb_out.num_valuators = num_valuators; + xcb_out.pad0 = 0; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* int32_t valuators */ + xcb_parts[4].iov_base = (char *) valuators; + xcb_parts[4].iov_len = num_valuators * sizeof(int32_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_set_device_valuators_reply_t * +xcb_input_set_device_valuators_reply (xcb_connection_t *c, + xcb_input_set_device_valuators_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_set_device_valuators_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_device_resolution_state_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_device_resolution_state_t *_aux = (xcb_input_device_resolution_state_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_device_resolution_state_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* resolution_values */ + xcb_block_len += _aux->num_valuators * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* resolution_min */ + xcb_block_len += _aux->num_valuators * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* resolution_max */ + xcb_block_len += _aux->num_valuators * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +uint32_t * +xcb_input_device_resolution_state_resolution_values (const xcb_input_device_resolution_state_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_device_resolution_state_resolution_values_length (const xcb_input_device_resolution_state_t *R) +{ + return R->num_valuators; +} + +xcb_generic_iterator_t +xcb_input_device_resolution_state_resolution_values_end (const xcb_input_device_resolution_state_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->num_valuators); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +uint32_t * +xcb_input_device_resolution_state_resolution_min (const xcb_input_device_resolution_state_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_values_end(R); + return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); +} + +int +xcb_input_device_resolution_state_resolution_min_length (const xcb_input_device_resolution_state_t *R) +{ + return R->num_valuators; +} + +xcb_generic_iterator_t +xcb_input_device_resolution_state_resolution_min_end (const xcb_input_device_resolution_state_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_values_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_valuators); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +uint32_t * +xcb_input_device_resolution_state_resolution_max (const xcb_input_device_resolution_state_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_min_end(R); + return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); +} + +int +xcb_input_device_resolution_state_resolution_max_length (const xcb_input_device_resolution_state_t *R) +{ + return R->num_valuators; +} + +xcb_generic_iterator_t +xcb_input_device_resolution_state_resolution_max_end (const xcb_input_device_resolution_state_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_min_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_valuators); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_device_resolution_state_next (xcb_input_device_resolution_state_iterator_t *i) +{ + xcb_input_device_resolution_state_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_device_resolution_state_t *)(((char *)R) + xcb_input_device_resolution_state_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_device_resolution_state_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_device_resolution_state_end (xcb_input_device_resolution_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_device_resolution_state_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +void +xcb_input_device_abs_calib_state_next (xcb_input_device_abs_calib_state_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_device_abs_calib_state_t); +} + +xcb_generic_iterator_t +xcb_input_device_abs_calib_state_end (xcb_input_device_abs_calib_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_device_abs_area_state_next (xcb_input_device_abs_area_state_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_device_abs_area_state_t); +} + +xcb_generic_iterator_t +xcb_input_device_abs_area_state_end (xcb_input_device_abs_area_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_device_core_state_next (xcb_input_device_core_state_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_device_core_state_t); +} + +xcb_generic_iterator_t +xcb_input_device_core_state_end (xcb_input_device_core_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_device_enable_state_next (xcb_input_device_enable_state_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_device_enable_state_t); +} + +xcb_generic_iterator_t +xcb_input_device_enable_state_end (xcb_input_device_enable_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +uint32_t * +xcb_input_device_state_data_resolution_resolution_values (const xcb_input_device_state_data_t *S) +{ + return S->resolution.resolution_values; +} + +int +xcb_input_device_state_data_resolution_resolution_values_length (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S) +{ + return S->resolution.num_valuators; +} + +xcb_generic_iterator_t +xcb_input_device_state_data_resolution_resolution_values_end (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->resolution.resolution_values + S->resolution.num_valuators; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint32_t * +xcb_input_device_state_data_resolution_resolution_min (const xcb_input_device_state_data_t *S) +{ + return S->resolution.resolution_min; +} + +int +xcb_input_device_state_data_resolution_resolution_min_length (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S) +{ + return S->resolution.num_valuators; +} + +xcb_generic_iterator_t +xcb_input_device_state_data_resolution_resolution_min_end (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->resolution.resolution_min + S->resolution.num_valuators; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint32_t * +xcb_input_device_state_data_resolution_resolution_max (const xcb_input_device_state_data_t *S) +{ + return S->resolution.resolution_max; +} + +int +xcb_input_device_state_data_resolution_resolution_max_length (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S) +{ + return S->resolution.num_valuators; +} + +xcb_generic_iterator_t +xcb_input_device_state_data_resolution_resolution_max_end (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->resolution.resolution_max + S->resolution.num_valuators; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_device_state_data_serialize (void **_buffer, + uint16_t control_id, + const xcb_input_device_state_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[27]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) { + /* xcb_input_device_state_data_t.resolution.num_valuators */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->resolution.num_valuators; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* resolution_values */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_values; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* resolution_min */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_min; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* resolution_max */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_max; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) { + /* xcb_input_device_state_data_t.abs_calib.min_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_x; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.max_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_x; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.min_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_y; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.max_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_y; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.flip_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_x; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_calib.flip_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_y; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_calib.rotation */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.rotation; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_calib.button_threshold */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.button_threshold; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) { + /* xcb_input_device_state_data_t.core.status */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->core.status; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_state_data_t.core.iscore */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->core.iscore; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_state_data_t.core.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) { + /* xcb_input_device_state_data_t.enable.enable */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->enable.enable; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_state_data_t.enable.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*3; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) { + /* xcb_input_device_state_data_t.abs_area.offset_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_x; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.offset_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_y; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.width */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.width; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.height */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.height; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.screen */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.screen; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.following */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.following; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; i<xcb_parts_idx; i++) { + if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) + memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); + if (0 != xcb_parts[i].iov_len) + xcb_tmp += xcb_parts[i].iov_len; + } + + return xcb_buffer_len; +} + +int +xcb_input_device_state_data_unpack (const void *_buffer, + uint16_t control_id, + xcb_input_device_state_data_t *_aux) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + + if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) { + /* xcb_input_device_state_data_t.resolution.num_valuators */ + _aux->resolution.num_valuators = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* resolution_values */ + _aux->resolution.resolution_values = (uint32_t *)xcb_tmp; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* resolution_min */ + _aux->resolution.resolution_min = (uint32_t *)xcb_tmp; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* resolution_max */ + _aux->resolution.resolution_max = (uint32_t *)xcb_tmp; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) { + /* xcb_input_device_state_data_t.abs_calib.min_x */ + _aux->abs_calib.min_x = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.max_x */ + _aux->abs_calib.max_x = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.min_y */ + _aux->abs_calib.min_y = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.max_y */ + _aux->abs_calib.max_y = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.flip_x */ + _aux->abs_calib.flip_x = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_calib.flip_y */ + _aux->abs_calib.flip_y = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_calib.rotation */ + _aux->abs_calib.rotation = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_calib.button_threshold */ + _aux->abs_calib.button_threshold = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) { + /* xcb_input_device_state_data_t.core.status */ + _aux->core.status = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_state_data_t.core.iscore */ + _aux->core.iscore = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_state_data_t.core.pad0 */ + _aux->core.pad0[0] = *(uint8_t *)xcb_tmp; + _aux->core.pad0[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) { + /* xcb_input_device_state_data_t.enable.enable */ + _aux->enable.enable = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_state_data_t.enable.pad1 */ + _aux->enable.pad1[0] = *(uint8_t *)xcb_tmp; + _aux->enable.pad1[1] = *(uint8_t *)xcb_tmp; + _aux->enable.pad1[2] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 3; + xcb_tmp += sizeof(uint8_t) * 3; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) { + /* xcb_input_device_state_data_t.abs_area.offset_x */ + _aux->abs_area.offset_x = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.offset_y */ + _aux->abs_area.offset_y = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.width */ + _aux->abs_area.width = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.height */ + _aux->abs_area.height = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.screen */ + _aux->abs_area.screen = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.following */ + _aux->abs_area.following = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + return xcb_buffer_len; +} + +int +xcb_input_device_state_data_sizeof (const void *_buffer, + uint16_t control_id) +{ + xcb_input_device_state_data_t _aux; + return xcb_input_device_state_data_unpack(_buffer, control_id, &_aux); +} + +int +xcb_input_device_state_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_device_state_t *_aux = (xcb_input_device_state_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_device_state_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* data */ + xcb_block_len += xcb_input_device_state_data_sizeof(xcb_tmp, _aux->control_id); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +void * +xcb_input_device_state_data (const xcb_input_device_state_t *R) +{ + return (void *) (R + 1); +} + +void +xcb_input_device_state_next (xcb_input_device_state_iterator_t *i) +{ + xcb_input_device_state_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_device_state_t *)(((char *)R) + xcb_input_device_state_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_device_state_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_device_state_end (xcb_input_device_state_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_device_state_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_get_device_control_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_get_device_control_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* control */ + xcb_block_len += xcb_input_device_state_sizeof(xcb_tmp); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_device_state_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_get_device_control_cookie_t +xcb_input_get_device_control (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_CONTROL, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_control_cookie_t xcb_ret; + xcb_input_get_device_control_request_t xcb_out; + + xcb_out.control_id = control_id; + xcb_out.device_id = device_id; + xcb_out.pad0 = 0; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_device_control_cookie_t +xcb_input_get_device_control_unchecked (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_CONTROL, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_control_cookie_t xcb_ret; + xcb_input_get_device_control_request_t xcb_out; + + xcb_out.control_id = control_id; + xcb_out.device_id = device_id; + xcb_out.pad0 = 0; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_device_state_t * +xcb_input_get_device_control_control (const xcb_input_get_device_control_reply_t *R) +{ + return (xcb_input_device_state_t *) (R + 1); +} + +xcb_input_get_device_control_reply_t * +xcb_input_get_device_control_reply (xcb_connection_t *c, + xcb_input_get_device_control_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_get_device_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_device_resolution_ctl_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_device_resolution_ctl_t *_aux = (xcb_input_device_resolution_ctl_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_device_resolution_ctl_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* resolution_values */ + xcb_block_len += _aux->num_valuators * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +uint32_t * +xcb_input_device_resolution_ctl_resolution_values (const xcb_input_device_resolution_ctl_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_device_resolution_ctl_resolution_values_length (const xcb_input_device_resolution_ctl_t *R) +{ + return R->num_valuators; +} + +xcb_generic_iterator_t +xcb_input_device_resolution_ctl_resolution_values_end (const xcb_input_device_resolution_ctl_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->num_valuators); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_device_resolution_ctl_next (xcb_input_device_resolution_ctl_iterator_t *i) +{ + xcb_input_device_resolution_ctl_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_device_resolution_ctl_t *)(((char *)R) + xcb_input_device_resolution_ctl_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_device_resolution_ctl_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_device_resolution_ctl_end (xcb_input_device_resolution_ctl_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_device_resolution_ctl_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +void +xcb_input_device_abs_calib_ctl_next (xcb_input_device_abs_calib_ctl_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_device_abs_calib_ctl_t); +} + +xcb_generic_iterator_t +xcb_input_device_abs_calib_ctl_end (xcb_input_device_abs_calib_ctl_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_device_abs_area_ctrl_next (xcb_input_device_abs_area_ctrl_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_device_abs_area_ctrl_t); +} + +xcb_generic_iterator_t +xcb_input_device_abs_area_ctrl_end (xcb_input_device_abs_area_ctrl_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_device_core_ctrl_next (xcb_input_device_core_ctrl_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_device_core_ctrl_t); +} + +xcb_generic_iterator_t +xcb_input_device_core_ctrl_end (xcb_input_device_core_ctrl_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_device_enable_ctrl_next (xcb_input_device_enable_ctrl_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_device_enable_ctrl_t); +} + +xcb_generic_iterator_t +xcb_input_device_enable_ctrl_end (xcb_input_device_enable_ctrl_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +uint32_t * +xcb_input_device_ctl_data_resolution_resolution_values (const xcb_input_device_ctl_data_t *S) +{ + return S->resolution.resolution_values; +} + +int +xcb_input_device_ctl_data_resolution_resolution_values_length (const xcb_input_device_ctl_t *R, + const xcb_input_device_ctl_data_t *S) +{ + return S->resolution.num_valuators; +} + +xcb_generic_iterator_t +xcb_input_device_ctl_data_resolution_resolution_values_end (const xcb_input_device_ctl_t *R, + const xcb_input_device_ctl_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->resolution.resolution_values + S->resolution.num_valuators; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_device_ctl_data_serialize (void **_buffer, + uint16_t control_id, + const xcb_input_device_ctl_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[24]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) { + /* xcb_input_device_ctl_data_t.resolution.first_valuator */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->resolution.first_valuator; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.resolution.num_valuators */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->resolution.num_valuators; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.resolution.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* resolution_values */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_values; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) { + /* xcb_input_device_ctl_data_t.abs_calib.min_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_x; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.max_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_x; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.min_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_y; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.max_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_y; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.flip_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_x; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_calib.flip_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_y; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_calib.rotation */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.rotation; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_calib.button_threshold */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.button_threshold; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) { + /* xcb_input_device_ctl_data_t.core.status */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->core.status; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.core.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*3; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) { + /* xcb_input_device_ctl_data_t.enable.enable */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->enable.enable; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.enable.pad2 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*3; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) { + /* xcb_input_device_ctl_data_t.abs_area.offset_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_x; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_area.offset_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_y; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_area.width */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.width; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_area.height */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.height; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_area.screen */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.screen; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_area.following */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.following; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; i<xcb_parts_idx; i++) { + if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) + memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); + if (0 != xcb_parts[i].iov_len) + xcb_tmp += xcb_parts[i].iov_len; + } + + return xcb_buffer_len; +} + +int +xcb_input_device_ctl_data_unpack (const void *_buffer, + uint16_t control_id, + xcb_input_device_ctl_data_t *_aux) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + + if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) { + /* xcb_input_device_ctl_data_t.resolution.first_valuator */ + _aux->resolution.first_valuator = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.resolution.num_valuators */ + _aux->resolution.num_valuators = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.resolution.pad0 */ + _aux->resolution.pad0[0] = *(uint8_t *)xcb_tmp; + _aux->resolution.pad0[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* resolution_values */ + _aux->resolution.resolution_values = (uint32_t *)xcb_tmp; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) { + /* xcb_input_device_ctl_data_t.abs_calib.min_x */ + _aux->abs_calib.min_x = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.max_x */ + _aux->abs_calib.max_x = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.min_y */ + _aux->abs_calib.min_y = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.max_y */ + _aux->abs_calib.max_y = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.flip_x */ + _aux->abs_calib.flip_x = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_calib.flip_y */ + _aux->abs_calib.flip_y = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_calib.rotation */ + _aux->abs_calib.rotation = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_calib.button_threshold */ + _aux->abs_calib.button_threshold = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) { + /* xcb_input_device_ctl_data_t.core.status */ + _aux->core.status = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.core.pad1 */ + _aux->core.pad1[0] = *(uint8_t *)xcb_tmp; + _aux->core.pad1[1] = *(uint8_t *)xcb_tmp; + _aux->core.pad1[2] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 3; + xcb_tmp += sizeof(uint8_t) * 3; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) { + /* xcb_input_device_ctl_data_t.enable.enable */ + _aux->enable.enable = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.enable.pad2 */ + _aux->enable.pad2[0] = *(uint8_t *)xcb_tmp; + _aux->enable.pad2[1] = *(uint8_t *)xcb_tmp; + _aux->enable.pad2[2] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 3; + xcb_tmp += sizeof(uint8_t) * 3; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) { + /* xcb_input_device_ctl_data_t.abs_area.offset_x */ + _aux->abs_area.offset_x = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_area.offset_y */ + _aux->abs_area.offset_y = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_area.width */ + _aux->abs_area.width = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_area.height */ + _aux->abs_area.height = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_area.screen */ + _aux->abs_area.screen = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_area.following */ + _aux->abs_area.following = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + return xcb_buffer_len; +} + +int +xcb_input_device_ctl_data_sizeof (const void *_buffer, + uint16_t control_id) +{ + xcb_input_device_ctl_data_t _aux; + return xcb_input_device_ctl_data_unpack(_buffer, control_id, &_aux); +} + +int +xcb_input_device_ctl_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_device_ctl_t *_aux = (xcb_input_device_ctl_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_device_ctl_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* data */ + xcb_block_len += xcb_input_device_ctl_data_sizeof(xcb_tmp, _aux->control_id); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +void * +xcb_input_device_ctl_data (const xcb_input_device_ctl_t *R) +{ + return (void *) (R + 1); +} + +void +xcb_input_device_ctl_next (xcb_input_device_ctl_iterator_t *i) +{ + xcb_input_device_ctl_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_device_ctl_t *)(((char *)R) + xcb_input_device_ctl_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_device_ctl_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_device_ctl_end (xcb_input_device_ctl_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_device_ctl_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_change_device_control_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_change_device_control_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* control */ + xcb_block_len += xcb_input_device_ctl_sizeof(xcb_tmp); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_device_ctl_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_change_device_control_cookie_t +xcb_input_change_device_control (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id, + xcb_input_device_ctl_t *control) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_CONTROL, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_change_device_control_cookie_t xcb_ret; + xcb_input_change_device_control_request_t xcb_out; + + xcb_out.control_id = control_id; + xcb_out.device_id = device_id; + xcb_out.pad0 = 0; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_device_ctl_t control */ + xcb_parts[4].iov_base = (char *) control; + xcb_parts[4].iov_len = + xcb_input_device_ctl_sizeof (control); + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_change_device_control_cookie_t +xcb_input_change_device_control_unchecked (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id, + xcb_input_device_ctl_t *control) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_CONTROL, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_change_device_control_cookie_t xcb_ret; + xcb_input_change_device_control_request_t xcb_out; + + xcb_out.control_id = control_id; + xcb_out.device_id = device_id; + xcb_out.pad0 = 0; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_device_ctl_t control */ + xcb_parts[4].iov_base = (char *) control; + xcb_parts[4].iov_len = + xcb_input_device_ctl_sizeof (control); + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_change_device_control_reply_t * +xcb_input_change_device_control_reply (xcb_connection_t *c, + xcb_input_change_device_control_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_change_device_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_list_device_properties_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_list_device_properties_reply_t *_aux = (xcb_input_list_device_properties_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_list_device_properties_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* atoms */ + xcb_block_len += _aux->num_atoms * sizeof(xcb_atom_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_atom_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_list_device_properties_cookie_t +xcb_input_list_device_properties (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_LIST_DEVICE_PROPERTIES, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_list_device_properties_cookie_t xcb_ret; + xcb_input_list_device_properties_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_list_device_properties_cookie_t +xcb_input_list_device_properties_unchecked (xcb_connection_t *c, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_LIST_DEVICE_PROPERTIES, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_list_device_properties_cookie_t xcb_ret; + xcb_input_list_device_properties_request_t xcb_out; + + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_atom_t * +xcb_input_list_device_properties_atoms (const xcb_input_list_device_properties_reply_t *R) +{ + return (xcb_atom_t *) (R + 1); +} + +int +xcb_input_list_device_properties_atoms_length (const xcb_input_list_device_properties_reply_t *R) +{ + return R->num_atoms; +} + +xcb_generic_iterator_t +xcb_input_list_device_properties_atoms_end (const xcb_input_list_device_properties_reply_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_atom_t *) (R + 1)) + (R->num_atoms); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_list_device_properties_reply_t * +xcb_input_list_device_properties_reply (xcb_connection_t *c, + xcb_input_list_device_properties_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_list_device_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +uint8_t * +xcb_input_change_device_property_items_data_8 (const xcb_input_change_device_property_items_t *S) +{ + return S->data8; +} + +int +xcb_input_change_device_property_items_data_8_length (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S) +{ + return R->num_items; +} + +xcb_generic_iterator_t +xcb_input_change_device_property_items_data_8_end (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->data8 + R->num_items; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint16_t * +xcb_input_change_device_property_items_data_16 (const xcb_input_change_device_property_items_t *S) +{ + return S->data16; +} + +int +xcb_input_change_device_property_items_data_16_length (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S) +{ + return R->num_items; +} + +xcb_generic_iterator_t +xcb_input_change_device_property_items_data_16_end (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->data16 + R->num_items; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint32_t * +xcb_input_change_device_property_items_data_32 (const xcb_input_change_device_property_items_t *S) +{ + return S->data32; +} + +int +xcb_input_change_device_property_items_data_32_length (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S) +{ + return R->num_items; +} + +xcb_generic_iterator_t +xcb_input_change_device_property_items_data_32_end (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->data32 + R->num_items; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_change_device_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_change_device_property_items_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[9]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data8 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8; + xcb_block_len += num_items * sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data16 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16; + xcb_block_len += num_items * sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data32 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32; + xcb_block_len += num_items * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; i<xcb_parts_idx; i++) { + if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) + memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); + if (0 != xcb_parts[i].iov_len) + xcb_tmp += xcb_parts[i].iov_len; + } + + return xcb_buffer_len; +} + +int +xcb_input_change_device_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_change_device_property_items_t *_aux) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data8 */ + _aux->data8 = (uint8_t *)xcb_tmp; + xcb_block_len += num_items * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data16 */ + _aux->data16 = (uint16_t *)xcb_tmp; + xcb_block_len += num_items * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data32 */ + _aux->data32 = (uint32_t *)xcb_tmp; + xcb_block_len += num_items * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + return xcb_buffer_len; +} + +int +xcb_input_change_device_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format) +{ + xcb_input_change_device_property_items_t _aux; + return xcb_input_change_device_property_items_unpack(_buffer, num_items, format, &_aux); +} + +int +xcb_input_change_device_property_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_change_device_property_request_t *_aux = (xcb_input_change_device_property_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_change_device_property_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* items */ + xcb_block_len += xcb_input_change_device_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_input_change_device_property_checked (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const void *items) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_input_change_device_property_request_t xcb_out; + + xcb_out.property = property; + xcb_out.type = type; + xcb_out.device_id = device_id; + xcb_out.format = format; + xcb_out.mode = mode; + xcb_out.pad0 = 0; + xcb_out.num_items = num_items; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_change_device_property_items_t items */ + xcb_parts[4].iov_base = (char *) items; + xcb_parts[4].iov_len = + xcb_input_change_device_property_items_sizeof (items, num_items, format); + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_change_device_property (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const void *items) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_input_change_device_property_request_t xcb_out; + + xcb_out.property = property; + xcb_out.type = type; + xcb_out.device_id = device_id; + xcb_out.format = format; + xcb_out.mode = mode; + xcb_out.pad0 = 0; + xcb_out.num_items = num_items; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_change_device_property_items_t items */ + xcb_parts[4].iov_base = (char *) items; + xcb_parts[4].iov_len = + xcb_input_change_device_property_items_sizeof (items, num_items, format); + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_change_device_property_aux_checked (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const xcb_input_change_device_property_items_t *items) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_input_change_device_property_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.property = property; + xcb_out.type = type; + xcb_out.device_id = device_id; + xcb_out.format = format; + xcb_out.mode = mode; + xcb_out.pad0 = 0; + xcb_out.num_items = num_items; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_change_device_property_items_t items */ + xcb_parts[4].iov_len = + xcb_input_change_device_property_items_serialize (&xcb_aux0, num_items, format, items); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_change_device_property_aux (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const xcb_input_change_device_property_items_t *items) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_input_change_device_property_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.property = property; + xcb_out.type = type; + xcb_out.device_id = device_id; + xcb_out.format = format; + xcb_out.mode = mode; + xcb_out.pad0 = 0; + xcb_out.num_items = num_items; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_change_device_property_items_t items */ + xcb_parts[4].iov_len = + xcb_input_change_device_property_items_serialize (&xcb_aux0, num_items, format, items); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +void * +xcb_input_change_device_property_items (const xcb_input_change_device_property_request_t *R) +{ + return (void *) (R + 1); +} + +xcb_void_cookie_t +xcb_input_delete_device_property_checked (xcb_connection_t *c, + xcb_atom_t property, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_DELETE_DEVICE_PROPERTY, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_delete_device_property_request_t xcb_out; + + xcb_out.property = property; + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_delete_device_property (xcb_connection_t *c, + xcb_atom_t property, + uint8_t device_id) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_DELETE_DEVICE_PROPERTY, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_delete_device_property_request_t xcb_out; + + xcb_out.property = property; + xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +uint8_t * +xcb_input_get_device_property_items_data_8 (const xcb_input_get_device_property_items_t *S) +{ + return S->data8; +} + +int +xcb_input_get_device_property_items_data_8_length (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S) +{ + return R->num_items; +} + +xcb_generic_iterator_t +xcb_input_get_device_property_items_data_8_end (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->data8 + R->num_items; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint16_t * +xcb_input_get_device_property_items_data_16 (const xcb_input_get_device_property_items_t *S) +{ + return S->data16; +} + +int +xcb_input_get_device_property_items_data_16_length (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S) +{ + return R->num_items; +} + +xcb_generic_iterator_t +xcb_input_get_device_property_items_data_16_end (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->data16 + R->num_items; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint32_t * +xcb_input_get_device_property_items_data_32 (const xcb_input_get_device_property_items_t *S) +{ + return S->data32; +} + +int +xcb_input_get_device_property_items_data_32_length (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S) +{ + return R->num_items; +} + +xcb_generic_iterator_t +xcb_input_get_device_property_items_data_32_end (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->data32 + R->num_items; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_get_device_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_get_device_property_items_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[9]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data8 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8; + xcb_block_len += num_items * sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data16 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16; + xcb_block_len += num_items * sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data32 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32; + xcb_block_len += num_items * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; i<xcb_parts_idx; i++) { + if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) + memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); + if (0 != xcb_parts[i].iov_len) + xcb_tmp += xcb_parts[i].iov_len; + } + + return xcb_buffer_len; +} + +int +xcb_input_get_device_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_get_device_property_items_t *_aux) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data8 */ + _aux->data8 = (uint8_t *)xcb_tmp; + xcb_block_len += num_items * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data16 */ + _aux->data16 = (uint16_t *)xcb_tmp; + xcb_block_len += num_items * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data32 */ + _aux->data32 = (uint32_t *)xcb_tmp; + xcb_block_len += num_items * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + return xcb_buffer_len; +} + +int +xcb_input_get_device_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format) +{ + xcb_input_get_device_property_items_t _aux; + return xcb_input_get_device_property_items_unpack(_buffer, num_items, format, &_aux); +} + +int +xcb_input_get_device_property_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_get_device_property_reply_t *_aux = (xcb_input_get_device_property_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_get_device_property_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* items */ + xcb_block_len += xcb_input_get_device_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_get_device_property_cookie_t +xcb_input_get_device_property (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len, + uint8_t device_id, + uint8_t _delete) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_PROPERTY, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_property_cookie_t xcb_ret; + xcb_input_get_device_property_request_t xcb_out; + + xcb_out.property = property; + xcb_out.type = type; + xcb_out.offset = offset; + xcb_out.len = len; + xcb_out.device_id = device_id; + xcb_out._delete = _delete; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_get_device_property_cookie_t +xcb_input_get_device_property_unchecked (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len, + uint8_t device_id, + uint8_t _delete) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_PROPERTY, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_get_device_property_cookie_t xcb_ret; + xcb_input_get_device_property_request_t xcb_out; + + xcb_out.property = property; + xcb_out.type = type; + xcb_out.offset = offset; + xcb_out.len = len; + xcb_out.device_id = device_id; + xcb_out._delete = _delete; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +void * +xcb_input_get_device_property_items (const xcb_input_get_device_property_reply_t *R) +{ + return (void *) (R + 1); +} + +xcb_input_get_device_property_reply_t * +xcb_input_get_device_property_reply (xcb_connection_t *c, + xcb_input_get_device_property_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_get_device_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +void +xcb_input_group_info_next (xcb_input_group_info_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_group_info_t); +} + +xcb_generic_iterator_t +xcb_input_group_info_end (xcb_input_group_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_modifier_info_next (xcb_input_modifier_info_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_modifier_info_t); +} + +xcb_generic_iterator_t +xcb_input_modifier_info_end (xcb_input_modifier_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +int +xcb_input_xi_query_pointer_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_query_pointer_reply_t *_aux = (xcb_input_xi_query_pointer_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_xi_query_pointer_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* buttons */ + xcb_block_len += _aux->buttons_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_xi_query_pointer_cookie_t +xcb_input_xi_query_pointer (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_QUERY_POINTER, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_query_pointer_cookie_t xcb_ret; + xcb_input_xi_query_pointer_request_t xcb_out; + + xcb_out.window = window; + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_query_pointer_cookie_t +xcb_input_xi_query_pointer_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_QUERY_POINTER, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_query_pointer_cookie_t xcb_ret; + xcb_input_xi_query_pointer_request_t xcb_out; + + xcb_out.window = window; + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +uint32_t * +xcb_input_xi_query_pointer_buttons (const xcb_input_xi_query_pointer_reply_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_xi_query_pointer_buttons_length (const xcb_input_xi_query_pointer_reply_t *R) +{ + return R->buttons_len; +} + +xcb_generic_iterator_t +xcb_input_xi_query_pointer_buttons_end (const xcb_input_xi_query_pointer_reply_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->buttons_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_xi_query_pointer_reply_t * +xcb_input_xi_query_pointer_reply (xcb_connection_t *c, + xcb_input_xi_query_pointer_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_xi_query_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_void_cookie_t +xcb_input_xi_warp_pointer_checked (xcb_connection_t *c, + xcb_window_t src_win, + xcb_window_t dst_win, + xcb_input_fp1616_t src_x, + xcb_input_fp1616_t src_y, + uint16_t src_width, + uint16_t src_height, + xcb_input_fp1616_t dst_x, + xcb_input_fp1616_t dst_y, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_WARP_POINTER, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_warp_pointer_request_t xcb_out; + + xcb_out.src_win = src_win; + xcb_out.dst_win = dst_win; + xcb_out.src_x = src_x; + xcb_out.src_y = src_y; + xcb_out.src_width = src_width; + xcb_out.src_height = src_height; + xcb_out.dst_x = dst_x; + xcb_out.dst_y = dst_y; + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_warp_pointer (xcb_connection_t *c, + xcb_window_t src_win, + xcb_window_t dst_win, + xcb_input_fp1616_t src_x, + xcb_input_fp1616_t src_y, + uint16_t src_width, + uint16_t src_height, + xcb_input_fp1616_t dst_x, + xcb_input_fp1616_t dst_y, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_WARP_POINTER, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_warp_pointer_request_t xcb_out; + + xcb_out.src_win = src_win; + xcb_out.dst_win = dst_win; + xcb_out.src_x = src_x; + xcb_out.src_y = src_y; + xcb_out.src_width = src_width; + xcb_out.src_height = src_height; + xcb_out.dst_x = dst_x; + xcb_out.dst_y = dst_y; + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_change_cursor_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_CURSOR, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_change_cursor_request_t xcb_out; + + xcb_out.window = window; + xcb_out.cursor = cursor; + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_change_cursor (xcb_connection_t *c, + xcb_window_t window, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_CURSOR, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_change_cursor_request_t xcb_out; + + xcb_out.window = window; + xcb_out.cursor = cursor; + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_input_add_master_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_add_master_t *_aux = (xcb_input_add_master_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_add_master_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* name */ + xcb_block_len += _aux->name_len * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +char * +xcb_input_add_master_name (const xcb_input_add_master_t *R) +{ + return (char *) (R + 1); +} + +int +xcb_input_add_master_name_length (const xcb_input_add_master_t *R) +{ + return R->name_len; +} + +xcb_generic_iterator_t +xcb_input_add_master_name_end (const xcb_input_add_master_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->name_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_add_master_next (xcb_input_add_master_iterator_t *i) +{ + xcb_input_add_master_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_add_master_t *)(((char *)R) + xcb_input_add_master_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_add_master_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_add_master_end (xcb_input_add_master_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_add_master_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +void +xcb_input_remove_master_next (xcb_input_remove_master_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_remove_master_t); +} + +xcb_generic_iterator_t +xcb_input_remove_master_end (xcb_input_remove_master_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_attach_slave_next (xcb_input_attach_slave_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_attach_slave_t); +} + +xcb_generic_iterator_t +xcb_input_attach_slave_end (xcb_input_attach_slave_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_detach_slave_next (xcb_input_detach_slave_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_detach_slave_t); +} + +xcb_generic_iterator_t +xcb_input_detach_slave_end (xcb_input_detach_slave_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +char * +xcb_input_hierarchy_change_data_add_master_name (const xcb_input_hierarchy_change_data_t *S) +{ + return S->add_master.name; +} + +int +xcb_input_hierarchy_change_data_add_master_name_length (const xcb_input_hierarchy_change_t *R, + const xcb_input_hierarchy_change_data_t *S) +{ + return S->add_master.name_len; +} + +xcb_generic_iterator_t +xcb_input_hierarchy_change_data_add_master_name_end (const xcb_input_hierarchy_change_t *R, + const xcb_input_hierarchy_change_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->add_master.name + S->add_master.name_len; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_hierarchy_change_data_serialize (void **_buffer, + uint16_t type, + const xcb_input_hierarchy_change_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[16]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ADD_MASTER) { + /* xcb_input_hierarchy_change_data_t.add_master.name_len */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->add_master.name_len; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_hierarchy_change_data_t.add_master.send_core */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->add_master.send_core; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_hierarchy_change_data_t.add_master.enable */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->add_master.enable; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* name */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->add_master.name; + xcb_block_len += _aux->add_master.name_len * sizeof(char); + xcb_parts[xcb_parts_idx].iov_len = _aux->add_master.name_len * sizeof(char); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_REMOVE_MASTER) { + /* xcb_input_hierarchy_change_data_t.remove_master.deviceid */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.deviceid; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.remove_master.return_mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.return_mode; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_hierarchy_change_data_t.remove_master.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_hierarchy_change_data_t.remove_master.return_pointer */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.return_pointer; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.remove_master.return_keyboard */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.return_keyboard; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + } + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ATTACH_SLAVE) { + /* xcb_input_hierarchy_change_data_t.attach_slave.deviceid */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->attach_slave.deviceid; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.attach_slave.master */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->attach_slave.master; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + } + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_DETACH_SLAVE) { + /* xcb_input_hierarchy_change_data_t.detach_slave.deviceid */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->detach_slave.deviceid; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.detach_slave.pad2 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; i<xcb_parts_idx; i++) { + if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) + memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); + if (0 != xcb_parts[i].iov_len) + xcb_tmp += xcb_parts[i].iov_len; + } + + return xcb_buffer_len; +} + +int +xcb_input_hierarchy_change_data_unpack (const void *_buffer, + uint16_t type, + xcb_input_hierarchy_change_data_t *_aux) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ADD_MASTER) { + /* xcb_input_hierarchy_change_data_t.add_master.name_len */ + _aux->add_master.name_len = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_hierarchy_change_data_t.add_master.send_core */ + _aux->add_master.send_core = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_hierarchy_change_data_t.add_master.enable */ + _aux->add_master.enable = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* name */ + _aux->add_master.name = (char *)xcb_tmp; + xcb_block_len += _aux->add_master.name_len * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_REMOVE_MASTER) { + /* xcb_input_hierarchy_change_data_t.remove_master.deviceid */ + _aux->remove_master.deviceid = *(xcb_input_device_id_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_tmp += sizeof(xcb_input_device_id_t); + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.remove_master.return_mode */ + _aux->remove_master.return_mode = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_hierarchy_change_data_t.remove_master.pad1 */ + _aux->remove_master.pad1 = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_hierarchy_change_data_t.remove_master.return_pointer */ + _aux->remove_master.return_pointer = *(xcb_input_device_id_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_tmp += sizeof(xcb_input_device_id_t); + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.remove_master.return_keyboard */ + _aux->remove_master.return_keyboard = *(xcb_input_device_id_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_tmp += sizeof(xcb_input_device_id_t); + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + } + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ATTACH_SLAVE) { + /* xcb_input_hierarchy_change_data_t.attach_slave.deviceid */ + _aux->attach_slave.deviceid = *(xcb_input_device_id_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_tmp += sizeof(xcb_input_device_id_t); + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.attach_slave.master */ + _aux->attach_slave.master = *(xcb_input_device_id_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_tmp += sizeof(xcb_input_device_id_t); + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + } + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_DETACH_SLAVE) { + /* xcb_input_hierarchy_change_data_t.detach_slave.deviceid */ + _aux->detach_slave.deviceid = *(xcb_input_device_id_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_tmp += sizeof(xcb_input_device_id_t); + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.detach_slave.pad2 */ + _aux->detach_slave.pad2[0] = *(uint8_t *)xcb_tmp; + _aux->detach_slave.pad2[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + return xcb_buffer_len; +} + +int +xcb_input_hierarchy_change_data_sizeof (const void *_buffer, + uint16_t type) +{ + xcb_input_hierarchy_change_data_t _aux; + return xcb_input_hierarchy_change_data_unpack(_buffer, type, &_aux); +} + +int +xcb_input_hierarchy_change_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_hierarchy_change_t *_aux = (xcb_input_hierarchy_change_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_hierarchy_change_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* data */ + xcb_block_len += xcb_input_hierarchy_change_data_sizeof(xcb_tmp, _aux->type); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +void * +xcb_input_hierarchy_change_data (const xcb_input_hierarchy_change_t *R) +{ + return (void *) (R + 1); +} + +void +xcb_input_hierarchy_change_next (xcb_input_hierarchy_change_iterator_t *i) +{ + xcb_input_hierarchy_change_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_hierarchy_change_t *)(((char *)R) + xcb_input_hierarchy_change_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_hierarchy_change_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_hierarchy_change_end (xcb_input_hierarchy_change_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_hierarchy_change_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_xi_change_hierarchy_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_change_hierarchy_request_t *_aux = (xcb_input_xi_change_hierarchy_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_input_xi_change_hierarchy_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* changes */ + for(i=0; i<_aux->num_changes; i++) { + xcb_tmp_len = xcb_input_hierarchy_change_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_input_hierarchy_change_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_input_xi_change_hierarchy_checked (xcb_connection_t *c, + uint8_t num_changes, + const xcb_input_hierarchy_change_t *changes) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_HIERARCHY, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_change_hierarchy_request_t xcb_out; + unsigned int xcb_tmp_len; + char *xcb_tmp; + unsigned int i; + + xcb_out.num_changes = num_changes; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_hierarchy_change_t changes */ + xcb_parts[4].iov_base = (char *) changes; + xcb_parts[4].iov_len = 0; + xcb_tmp = (char *)changes; + for(i=0; i<num_changes; i++) { + xcb_tmp_len = xcb_input_hierarchy_change_sizeof(xcb_tmp); + xcb_parts[4].iov_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_change_hierarchy (xcb_connection_t *c, + uint8_t num_changes, + const xcb_input_hierarchy_change_t *changes) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_HIERARCHY, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_change_hierarchy_request_t xcb_out; + unsigned int xcb_tmp_len; + char *xcb_tmp; + unsigned int i; + + xcb_out.num_changes = num_changes; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_hierarchy_change_t changes */ + xcb_parts[4].iov_base = (char *) changes; + xcb_parts[4].iov_len = 0; + xcb_tmp = (char *)changes; + for(i=0; i<num_changes; i++) { + xcb_tmp_len = xcb_input_hierarchy_change_sizeof(xcb_tmp); + xcb_parts[4].iov_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_input_xi_change_hierarchy_changes_length (const xcb_input_xi_change_hierarchy_request_t *R) +{ + return R->num_changes; +} + +xcb_input_hierarchy_change_iterator_t +xcb_input_xi_change_hierarchy_changes_iterator (const xcb_input_xi_change_hierarchy_request_t *R) +{ + xcb_input_hierarchy_change_iterator_t i; + i.data = (xcb_input_hierarchy_change_t *) (R + 1); + i.rem = R->num_changes; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_void_cookie_t +xcb_input_xi_set_client_pointer_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_SET_CLIENT_POINTER, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_set_client_pointer_request_t xcb_out; + + xcb_out.window = window; + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_set_client_pointer (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_SET_CLIENT_POINTER, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_set_client_pointer_request_t xcb_out; + + xcb_out.window = window; + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_get_client_pointer_cookie_t +xcb_input_xi_get_client_pointer (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_CLIENT_POINTER, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_get_client_pointer_cookie_t xcb_ret; + xcb_input_xi_get_client_pointer_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_get_client_pointer_cookie_t +xcb_input_xi_get_client_pointer_unchecked (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_CLIENT_POINTER, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_get_client_pointer_cookie_t xcb_ret; + xcb_input_xi_get_client_pointer_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_get_client_pointer_reply_t * +xcb_input_xi_get_client_pointer_reply (xcb_connection_t *c, + xcb_input_xi_get_client_pointer_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_xi_get_client_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_event_mask_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_event_mask_t *_aux = (xcb_input_event_mask_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_event_mask_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* mask */ + xcb_block_len += _aux->mask_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +uint32_t * +xcb_input_event_mask_mask (const xcb_input_event_mask_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_event_mask_mask_length (const xcb_input_event_mask_t *R) +{ + return R->mask_len; +} + +xcb_generic_iterator_t +xcb_input_event_mask_mask_end (const xcb_input_event_mask_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->mask_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_event_mask_next (xcb_input_event_mask_iterator_t *i) +{ + xcb_input_event_mask_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_event_mask_t *)(((char *)R) + xcb_input_event_mask_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_event_mask_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_event_mask_end (xcb_input_event_mask_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_event_mask_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_xi_select_events_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_select_events_request_t *_aux = (xcb_input_xi_select_events_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_input_xi_select_events_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* masks */ + for(i=0; i<_aux->num_mask; i++) { + xcb_tmp_len = xcb_input_event_mask_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_input_event_mask_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_input_xi_select_events_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_mask, + const xcb_input_event_mask_t *masks) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_SELECT_EVENTS, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_select_events_request_t xcb_out; + unsigned int xcb_tmp_len; + char *xcb_tmp; + unsigned int i; + + xcb_out.window = window; + xcb_out.num_mask = num_mask; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_event_mask_t masks */ + xcb_parts[4].iov_base = (char *) masks; + xcb_parts[4].iov_len = 0; + xcb_tmp = (char *)masks; + for(i=0; i<num_mask; i++) { + xcb_tmp_len = xcb_input_event_mask_sizeof(xcb_tmp); + xcb_parts[4].iov_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_select_events (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_mask, + const xcb_input_event_mask_t *masks) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_SELECT_EVENTS, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_select_events_request_t xcb_out; + unsigned int xcb_tmp_len; + char *xcb_tmp; + unsigned int i; + + xcb_out.window = window; + xcb_out.num_mask = num_mask; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_event_mask_t masks */ + xcb_parts[4].iov_base = (char *) masks; + xcb_parts[4].iov_len = 0; + xcb_tmp = (char *)masks; + for(i=0; i<num_mask; i++) { + xcb_tmp_len = xcb_input_event_mask_sizeof(xcb_tmp); + xcb_parts[4].iov_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_input_xi_select_events_masks_length (const xcb_input_xi_select_events_request_t *R) +{ + return R->num_mask; +} + +xcb_input_event_mask_iterator_t +xcb_input_xi_select_events_masks_iterator (const xcb_input_xi_select_events_request_t *R) +{ + xcb_input_event_mask_iterator_t i; + i.data = (xcb_input_event_mask_t *) (R + 1); + i.rem = R->num_mask; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_xi_query_version_cookie_t +xcb_input_xi_query_version (xcb_connection_t *c, + uint16_t major_version, + uint16_t minor_version) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_QUERY_VERSION, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_query_version_cookie_t xcb_ret; + xcb_input_xi_query_version_request_t xcb_out; + + xcb_out.major_version = major_version; + xcb_out.minor_version = minor_version; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_query_version_cookie_t +xcb_input_xi_query_version_unchecked (xcb_connection_t *c, + uint16_t major_version, + uint16_t minor_version) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_QUERY_VERSION, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_query_version_cookie_t xcb_ret; + xcb_input_xi_query_version_request_t xcb_out; + + xcb_out.major_version = major_version; + xcb_out.minor_version = minor_version; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_query_version_reply_t * +xcb_input_xi_query_version_reply (xcb_connection_t *c, + xcb_input_xi_query_version_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_xi_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_button_class_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_button_class_t *_aux = (xcb_input_button_class_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_button_class_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* state */ + xcb_block_len += ((_aux->num_buttons + 31) / 32) * sizeof(xcb_atom_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* labels */ + xcb_block_len += _aux->num_buttons * sizeof(xcb_atom_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_atom_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +uint32_t * +xcb_input_button_class_state (const xcb_input_button_class_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_button_class_state_length (const xcb_input_button_class_t *R) +{ + return ((R->num_buttons + 31) / 32); +} + +xcb_generic_iterator_t +xcb_input_button_class_state_end (const xcb_input_button_class_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (((R->num_buttons + 31) / 32)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_atom_t * +xcb_input_button_class_labels (const xcb_input_button_class_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_button_class_state_end(R); + return (xcb_atom_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_atom_t, prev.index) + 0); +} + +int +xcb_input_button_class_labels_length (const xcb_input_button_class_t *R) +{ + return R->num_buttons; +} + +xcb_generic_iterator_t +xcb_input_button_class_labels_end (const xcb_input_button_class_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_button_class_state_end(R); + i.data = ((xcb_atom_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_atom_t, prev.index))) + (R->num_buttons); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_button_class_next (xcb_input_button_class_iterator_t *i) +{ + xcb_input_button_class_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_button_class_t *)(((char *)R) + xcb_input_button_class_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_button_class_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_button_class_end (xcb_input_button_class_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_button_class_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_key_class_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_key_class_t *_aux = (xcb_input_key_class_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_key_class_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* keys */ + xcb_block_len += _aux->num_keys * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +uint32_t * +xcb_input_key_class_keys (const xcb_input_key_class_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_key_class_keys_length (const xcb_input_key_class_t *R) +{ + return R->num_keys; +} + +xcb_generic_iterator_t +xcb_input_key_class_keys_end (const xcb_input_key_class_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->num_keys); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_key_class_next (xcb_input_key_class_iterator_t *i) +{ + xcb_input_key_class_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_key_class_t *)(((char *)R) + xcb_input_key_class_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_key_class_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_key_class_end (xcb_input_key_class_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_key_class_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +void +xcb_input_scroll_class_next (xcb_input_scroll_class_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_scroll_class_t); +} + +xcb_generic_iterator_t +xcb_input_scroll_class_end (xcb_input_scroll_class_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_touch_class_next (xcb_input_touch_class_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_touch_class_t); +} + +xcb_generic_iterator_t +xcb_input_touch_class_end (xcb_input_touch_class_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +void +xcb_input_valuator_class_next (xcb_input_valuator_class_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_valuator_class_t); +} + +xcb_generic_iterator_t +xcb_input_valuator_class_end (xcb_input_valuator_class_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +uint32_t * +xcb_input_device_class_data_key_keys (const xcb_input_device_class_data_t *S) +{ + return S->key.keys; +} + +int +xcb_input_device_class_data_key_keys_length (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S) +{ + return S->key.num_keys; +} + +xcb_generic_iterator_t +xcb_input_device_class_data_key_keys_end (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->key.keys + S->key.num_keys; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint32_t * +xcb_input_device_class_data_button_state (const xcb_input_device_class_data_t *S) +{ + return S->button.state; +} + +int +xcb_input_device_class_data_button_state_length (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S) +{ + return ((S->button.num_buttons + 31) / 32); +} + +xcb_generic_iterator_t +xcb_input_device_class_data_button_state_end (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->button.state + ((S->button.num_buttons + 31) / 32); + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +xcb_atom_t * +xcb_input_device_class_data_button_labels (const xcb_input_device_class_data_t *S) +{ + return S->button.labels; +} + +int +xcb_input_device_class_data_button_labels_length (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S) +{ + return S->button.num_buttons; +} + +xcb_generic_iterator_t +xcb_input_device_class_data_button_labels_end (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->button.labels + S->button.num_buttons; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_device_class_data_serialize (void **_buffer, + uint16_t type, + const xcb_input_device_class_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 2; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[24]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_KEY) { + /* xcb_input_device_class_data_t.key.num_keys */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.num_keys; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* keys */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->key.keys; + xcb_block_len += _aux->key.num_keys * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->key.num_keys * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_BUTTON) { + /* xcb_input_device_class_data_t.button.num_buttons */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->button.num_buttons; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* state */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->button.state; + xcb_block_len += ((_aux->button.num_buttons + 31) / 32) * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = ((_aux->button.num_buttons + 31) / 32) * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* labels */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->button.labels; + xcb_block_len += _aux->button.num_buttons * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->button.num_buttons * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_atom_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR) { + /* xcb_input_device_class_data_t.valuator.number */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.number; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_device_class_data_t.valuator.label */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.label; + xcb_block_len += sizeof(xcb_atom_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_atom_t); + /* xcb_input_device_class_data_t.valuator.min */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.min; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* xcb_input_device_class_data_t.valuator.max */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.max; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* xcb_input_device_class_data_t.valuator.value */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.value; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* xcb_input_device_class_data_t.valuator.resolution */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.resolution; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_class_data_t.valuator.mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.mode; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_class_data_t.valuator.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*3; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_SCROLL) { + /* xcb_input_device_class_data_t.scroll.number */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.number; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_device_class_data_t.scroll.scroll_type */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.scroll_type; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_device_class_data_t.scroll.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_class_data_t.scroll.flags */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.flags; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_class_data_t.scroll.increment */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.increment; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_TOUCH) { + /* xcb_input_device_class_data_t.touch.mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->touch.mode; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_class_data_t.touch.num_touches */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->touch.num_touches; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; i<xcb_parts_idx; i++) { + if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) + memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); + if (0 != xcb_parts[i].iov_len) + xcb_tmp += xcb_parts[i].iov_len; + } + + return xcb_buffer_len; +} + +int +xcb_input_device_class_data_unpack (const void *_buffer, + uint16_t type, + xcb_input_device_class_data_t *_aux) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 2; + + + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_KEY) { + /* xcb_input_device_class_data_t.key.num_keys */ + _aux->key.num_keys = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* keys */ + _aux->key.keys = (uint32_t *)xcb_tmp; + xcb_block_len += _aux->key.num_keys * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_BUTTON) { + /* xcb_input_device_class_data_t.button.num_buttons */ + _aux->button.num_buttons = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* state */ + _aux->button.state = (uint32_t *)xcb_tmp; + xcb_block_len += ((_aux->button.num_buttons + 31) / 32) * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* labels */ + _aux->button.labels = (xcb_atom_t *)xcb_tmp; + xcb_block_len += _aux->button.num_buttons * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_atom_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR) { + /* xcb_input_device_class_data_t.valuator.number */ + _aux->valuator.number = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_device_class_data_t.valuator.label */ + _aux->valuator.label = *(xcb_atom_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_atom_t); + xcb_tmp += sizeof(xcb_atom_t); + xcb_align_to = ALIGNOF(xcb_atom_t); + /* xcb_input_device_class_data_t.valuator.min */ + _aux->valuator.min = *(xcb_input_fp3232_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_tmp += sizeof(xcb_input_fp3232_t); + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* xcb_input_device_class_data_t.valuator.max */ + _aux->valuator.max = *(xcb_input_fp3232_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_tmp += sizeof(xcb_input_fp3232_t); + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* xcb_input_device_class_data_t.valuator.value */ + _aux->valuator.value = *(xcb_input_fp3232_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_tmp += sizeof(xcb_input_fp3232_t); + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* xcb_input_device_class_data_t.valuator.resolution */ + _aux->valuator.resolution = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_class_data_t.valuator.mode */ + _aux->valuator.mode = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_class_data_t.valuator.pad0 */ + _aux->valuator.pad0[0] = *(uint8_t *)xcb_tmp; + _aux->valuator.pad0[1] = *(uint8_t *)xcb_tmp; + _aux->valuator.pad0[2] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 3; + xcb_tmp += sizeof(uint8_t) * 3; + xcb_align_to = ALIGNOF(uint8_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_SCROLL) { + /* xcb_input_device_class_data_t.scroll.number */ + _aux->scroll.number = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_device_class_data_t.scroll.scroll_type */ + _aux->scroll.scroll_type = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_device_class_data_t.scroll.pad1 */ + _aux->scroll.pad1[0] = *(uint8_t *)xcb_tmp; + _aux->scroll.pad1[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_class_data_t.scroll.flags */ + _aux->scroll.flags = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_class_data_t.scroll.increment */ + _aux->scroll.increment = *(xcb_input_fp3232_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_tmp += sizeof(xcb_input_fp3232_t); + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_TOUCH) { + /* xcb_input_device_class_data_t.touch.mode */ + _aux->touch.mode = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_class_data_t.touch.num_touches */ + _aux->touch.num_touches = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + return xcb_buffer_len; +} + +int +xcb_input_device_class_data_sizeof (const void *_buffer, + uint16_t type) +{ + xcb_input_device_class_data_t _aux; + return xcb_input_device_class_data_unpack(_buffer, type, &_aux); +} + +int +xcb_input_device_class_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_device_class_t *_aux = (xcb_input_device_class_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_device_class_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* data */ + xcb_block_len += xcb_input_device_class_data_sizeof(xcb_tmp, _aux->type); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +void * +xcb_input_device_class_data (const xcb_input_device_class_t *R) +{ + return (void *) (R + 1); +} + +void +xcb_input_device_class_next (xcb_input_device_class_iterator_t *i) +{ + xcb_input_device_class_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_device_class_t *)(((char *)R) + xcb_input_device_class_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_device_class_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_device_class_end (xcb_input_device_class_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_device_class_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_xi_device_info_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_device_info_t *_aux = (xcb_input_xi_device_info_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_input_xi_device_info_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* name */ + xcb_block_len += _aux->name_len * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* classes */ + for(i=0; i<_aux->num_classes; i++) { + xcb_tmp_len = xcb_input_device_class_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_input_device_class_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +char * +xcb_input_xi_device_info_name (const xcb_input_xi_device_info_t *R) +{ + return (char *) (R + 1); +} + +int +xcb_input_xi_device_info_name_length (const xcb_input_xi_device_info_t *R) +{ + return R->name_len; +} + +xcb_generic_iterator_t +xcb_input_xi_device_info_name_end (const xcb_input_xi_device_info_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->name_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_xi_device_info_classes_length (const xcb_input_xi_device_info_t *R) +{ + return R->num_classes; +} + +xcb_input_device_class_iterator_t +xcb_input_xi_device_info_classes_iterator (const xcb_input_xi_device_info_t *R) +{ + xcb_input_device_class_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_xi_device_info_name_end(R); + i.data = (xcb_input_device_class_t *) ((char *) prev.data + ((-prev.index) & (4 - 1))); + i.rem = R->num_classes; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_input_xi_device_info_next (xcb_input_xi_device_info_iterator_t *i) +{ + xcb_input_xi_device_info_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_xi_device_info_t *)(((char *)R) + xcb_input_xi_device_info_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_input_xi_device_info_t *) child.data; +} + +xcb_generic_iterator_t +xcb_input_xi_device_info_end (xcb_input_xi_device_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_input_xi_device_info_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_input_xi_query_device_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_query_device_reply_t *_aux = (xcb_input_xi_query_device_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_input_xi_query_device_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* infos */ + for(i=0; i<_aux->num_infos; i++) { + xcb_tmp_len = xcb_input_xi_device_info_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_input_xi_device_info_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_xi_query_device_cookie_t +xcb_input_xi_query_device (xcb_connection_t *c, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_QUERY_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_query_device_cookie_t xcb_ret; + xcb_input_xi_query_device_request_t xcb_out; + + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_query_device_cookie_t +xcb_input_xi_query_device_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_QUERY_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_query_device_cookie_t xcb_ret; + xcb_input_xi_query_device_request_t xcb_out; + + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_input_xi_query_device_infos_length (const xcb_input_xi_query_device_reply_t *R) +{ + return R->num_infos; +} + +xcb_input_xi_device_info_iterator_t +xcb_input_xi_query_device_infos_iterator (const xcb_input_xi_query_device_reply_t *R) +{ + xcb_input_xi_device_info_iterator_t i; + i.data = (xcb_input_xi_device_info_t *) (R + 1); + i.rem = R->num_infos; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_xi_query_device_reply_t * +xcb_input_xi_query_device_reply (xcb_connection_t *c, + xcb_input_xi_query_device_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_xi_query_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_void_cookie_t +xcb_input_xi_set_focus_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_SET_FOCUS, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_set_focus_request_t xcb_out; + + xcb_out.window = window; + xcb_out.time = time; + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_set_focus (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_SET_FOCUS, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_set_focus_request_t xcb_out; + + xcb_out.window = window; + xcb_out.time = time; + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_get_focus_cookie_t +xcb_input_xi_get_focus (xcb_connection_t *c, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_FOCUS, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_get_focus_cookie_t xcb_ret; + xcb_input_xi_get_focus_request_t xcb_out; + + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_get_focus_cookie_t +xcb_input_xi_get_focus_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_FOCUS, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_get_focus_cookie_t xcb_ret; + xcb_input_xi_get_focus_request_t xcb_out; + + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_get_focus_reply_t * +xcb_input_xi_get_focus_reply (xcb_connection_t *c, + xcb_input_xi_get_focus_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_xi_get_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_xi_grab_device_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_grab_device_request_t *_aux = (xcb_input_xi_grab_device_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_xi_grab_device_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* mask */ + xcb_block_len += _aux->mask_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_xi_grab_device_cookie_t +xcb_input_xi_grab_device (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t paired_device_mode, + uint8_t owner_events, + uint16_t mask_len, + const uint32_t *mask) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GRAB_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_xi_grab_device_cookie_t xcb_ret; + xcb_input_xi_grab_device_request_t xcb_out; + + xcb_out.window = window; + xcb_out.time = time; + xcb_out.cursor = cursor; + xcb_out.deviceid = deviceid; + xcb_out.mode = mode; + xcb_out.paired_device_mode = paired_device_mode; + xcb_out.owner_events = owner_events; + xcb_out.pad0 = 0; + xcb_out.mask_len = mask_len; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t mask */ + xcb_parts[4].iov_base = (char *) mask; + xcb_parts[4].iov_len = mask_len * sizeof(uint32_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_grab_device_cookie_t +xcb_input_xi_grab_device_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t paired_device_mode, + uint8_t owner_events, + uint16_t mask_len, + const uint32_t *mask) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GRAB_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[6]; + xcb_input_xi_grab_device_cookie_t xcb_ret; + xcb_input_xi_grab_device_request_t xcb_out; + + xcb_out.window = window; + xcb_out.time = time; + xcb_out.cursor = cursor; + xcb_out.deviceid = deviceid; + xcb_out.mode = mode; + xcb_out.paired_device_mode = paired_device_mode; + xcb_out.owner_events = owner_events; + xcb_out.pad0 = 0; + xcb_out.mask_len = mask_len; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t mask */ + xcb_parts[4].iov_base = (char *) mask; + xcb_parts[4].iov_len = mask_len * sizeof(uint32_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_grab_device_reply_t * +xcb_input_xi_grab_device_reply (xcb_connection_t *c, + xcb_input_xi_grab_device_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_xi_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_void_cookie_t +xcb_input_xi_ungrab_device_checked (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_UNGRAB_DEVICE, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_ungrab_device_request_t xcb_out; + + xcb_out.time = time; + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_ungrab_device (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_UNGRAB_DEVICE, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_ungrab_device_request_t xcb_out; + + xcb_out.time = time; + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_allow_events_checked (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid, + uint8_t event_mode, + uint32_t touchid, + xcb_window_t grab_window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_ALLOW_EVENTS, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_allow_events_request_t xcb_out; + + xcb_out.time = time; + xcb_out.deviceid = deviceid; + xcb_out.event_mode = event_mode; + xcb_out.pad0 = 0; + xcb_out.touchid = touchid; + xcb_out.grab_window = grab_window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_allow_events (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid, + uint8_t event_mode, + uint32_t touchid, + xcb_window_t grab_window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_ALLOW_EVENTS, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_allow_events_request_t xcb_out; + + xcb_out.time = time; + xcb_out.deviceid = deviceid; + xcb_out.event_mode = event_mode; + xcb_out.pad0 = 0; + xcb_out.touchid = touchid; + xcb_out.grab_window = grab_window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +void +xcb_input_grab_modifier_info_next (xcb_input_grab_modifier_info_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_grab_modifier_info_t); +} + +xcb_generic_iterator_t +xcb_input_grab_modifier_info_end (xcb_input_grab_modifier_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +int +xcb_input_xi_passive_grab_device_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_passive_grab_device_request_t *_aux = (xcb_input_xi_passive_grab_device_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_xi_passive_grab_device_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* mask */ + xcb_block_len += _aux->mask_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* modifiers */ + xcb_block_len += _aux->num_modifiers * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_xi_passive_grab_device_cookie_t +xcb_input_xi_passive_grab_device (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_window_t grab_window, + xcb_cursor_t cursor, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint16_t mask_len, + uint8_t grab_type, + uint8_t grab_mode, + uint8_t paired_device_mode, + uint8_t owner_events, + const uint32_t *mask, + const uint32_t *modifiers) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 6, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_PASSIVE_GRAB_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[8]; + xcb_input_xi_passive_grab_device_cookie_t xcb_ret; + xcb_input_xi_passive_grab_device_request_t xcb_out; + + xcb_out.time = time; + xcb_out.grab_window = grab_window; + xcb_out.cursor = cursor; + xcb_out.detail = detail; + xcb_out.deviceid = deviceid; + xcb_out.num_modifiers = num_modifiers; + xcb_out.mask_len = mask_len; + xcb_out.grab_type = grab_type; + xcb_out.grab_mode = grab_mode; + xcb_out.paired_device_mode = paired_device_mode; + xcb_out.owner_events = owner_events; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t mask */ + xcb_parts[4].iov_base = (char *) mask; + xcb_parts[4].iov_len = mask_len * sizeof(uint32_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* uint32_t modifiers */ + xcb_parts[6].iov_base = (char *) modifiers; + xcb_parts[6].iov_len = num_modifiers * sizeof(uint32_t); + xcb_parts[7].iov_base = 0; + xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_passive_grab_device_cookie_t +xcb_input_xi_passive_grab_device_unchecked (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_window_t grab_window, + xcb_cursor_t cursor, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint16_t mask_len, + uint8_t grab_type, + uint8_t grab_mode, + uint8_t paired_device_mode, + uint8_t owner_events, + const uint32_t *mask, + const uint32_t *modifiers) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 6, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_PASSIVE_GRAB_DEVICE, + .isvoid = 0 + }; + + struct iovec xcb_parts[8]; + xcb_input_xi_passive_grab_device_cookie_t xcb_ret; + xcb_input_xi_passive_grab_device_request_t xcb_out; + + xcb_out.time = time; + xcb_out.grab_window = grab_window; + xcb_out.cursor = cursor; + xcb_out.detail = detail; + xcb_out.deviceid = deviceid; + xcb_out.num_modifiers = num_modifiers; + xcb_out.mask_len = mask_len; + xcb_out.grab_type = grab_type; + xcb_out.grab_mode = grab_mode; + xcb_out.paired_device_mode = paired_device_mode; + xcb_out.owner_events = owner_events; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t mask */ + xcb_parts[4].iov_base = (char *) mask; + xcb_parts[4].iov_len = mask_len * sizeof(uint32_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + /* uint32_t modifiers */ + xcb_parts[6].iov_base = (char *) modifiers; + xcb_parts[6].iov_len = num_modifiers * sizeof(uint32_t); + xcb_parts[7].iov_base = 0; + xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_grab_modifier_info_t * +xcb_input_xi_passive_grab_device_modifiers (const xcb_input_xi_passive_grab_device_reply_t *R) +{ + return (xcb_input_grab_modifier_info_t *) (R + 1); +} + +int +xcb_input_xi_passive_grab_device_modifiers_length (const xcb_input_xi_passive_grab_device_reply_t *R) +{ + return R->num_modifiers; +} + +xcb_input_grab_modifier_info_iterator_t +xcb_input_xi_passive_grab_device_modifiers_iterator (const xcb_input_xi_passive_grab_device_reply_t *R) +{ + xcb_input_grab_modifier_info_iterator_t i; + i.data = (xcb_input_grab_modifier_info_t *) (R + 1); + i.rem = R->num_modifiers; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_xi_passive_grab_device_reply_t * +xcb_input_xi_passive_grab_device_reply (xcb_connection_t *c, + xcb_input_xi_passive_grab_device_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_xi_passive_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_xi_passive_ungrab_device_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_passive_ungrab_device_request_t *_aux = (xcb_input_xi_passive_ungrab_device_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_xi_passive_ungrab_device_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* modifiers */ + xcb_block_len += _aux->num_modifiers * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_input_xi_passive_ungrab_device_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint8_t grab_type, + const uint32_t *modifiers) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_PASSIVE_UNGRAB_DEVICE, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_passive_ungrab_device_request_t xcb_out; + + xcb_out.grab_window = grab_window; + xcb_out.detail = detail; + xcb_out.deviceid = deviceid; + xcb_out.num_modifiers = num_modifiers; + xcb_out.grab_type = grab_type; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t modifiers */ + xcb_parts[4].iov_base = (char *) modifiers; + xcb_parts[4].iov_len = num_modifiers * sizeof(uint32_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_passive_ungrab_device (xcb_connection_t *c, + xcb_window_t grab_window, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint8_t grab_type, + const uint32_t *modifiers) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_PASSIVE_UNGRAB_DEVICE, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_passive_ungrab_device_request_t xcb_out; + + xcb_out.grab_window = grab_window; + xcb_out.detail = detail; + xcb_out.deviceid = deviceid; + xcb_out.num_modifiers = num_modifiers; + xcb_out.grab_type = grab_type; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint32_t modifiers */ + xcb_parts[4].iov_base = (char *) modifiers; + xcb_parts[4].iov_len = num_modifiers * sizeof(uint32_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +uint32_t * +xcb_input_xi_passive_ungrab_device_modifiers (const xcb_input_xi_passive_ungrab_device_request_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_xi_passive_ungrab_device_modifiers_length (const xcb_input_xi_passive_ungrab_device_request_t *R) +{ + return R->num_modifiers; +} + +xcb_generic_iterator_t +xcb_input_xi_passive_ungrab_device_modifiers_end (const xcb_input_xi_passive_ungrab_device_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->num_modifiers); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_xi_list_properties_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_list_properties_reply_t *_aux = (xcb_input_xi_list_properties_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_xi_list_properties_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* properties */ + xcb_block_len += _aux->num_properties * sizeof(xcb_atom_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_atom_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_xi_list_properties_cookie_t +xcb_input_xi_list_properties (xcb_connection_t *c, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_LIST_PROPERTIES, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_list_properties_cookie_t xcb_ret; + xcb_input_xi_list_properties_request_t xcb_out; + + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_list_properties_cookie_t +xcb_input_xi_list_properties_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_LIST_PROPERTIES, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_list_properties_cookie_t xcb_ret; + xcb_input_xi_list_properties_request_t xcb_out; + + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_atom_t * +xcb_input_xi_list_properties_properties (const xcb_input_xi_list_properties_reply_t *R) +{ + return (xcb_atom_t *) (R + 1); +} + +int +xcb_input_xi_list_properties_properties_length (const xcb_input_xi_list_properties_reply_t *R) +{ + return R->num_properties; +} + +xcb_generic_iterator_t +xcb_input_xi_list_properties_properties_end (const xcb_input_xi_list_properties_reply_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_atom_t *) (R + 1)) + (R->num_properties); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_xi_list_properties_reply_t * +xcb_input_xi_list_properties_reply (xcb_connection_t *c, + xcb_input_xi_list_properties_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_xi_list_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +uint8_t * +xcb_input_xi_change_property_items_data_8 (const xcb_input_xi_change_property_items_t *S) +{ + return S->data8; +} + +int +xcb_input_xi_change_property_items_data_8_length (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S) +{ + return R->num_items; +} + +xcb_generic_iterator_t +xcb_input_xi_change_property_items_data_8_end (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->data8 + R->num_items; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint16_t * +xcb_input_xi_change_property_items_data_16 (const xcb_input_xi_change_property_items_t *S) +{ + return S->data16; +} + +int +xcb_input_xi_change_property_items_data_16_length (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S) +{ + return R->num_items; +} + +xcb_generic_iterator_t +xcb_input_xi_change_property_items_data_16_end (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->data16 + R->num_items; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint32_t * +xcb_input_xi_change_property_items_data_32 (const xcb_input_xi_change_property_items_t *S) +{ + return S->data32; +} + +int +xcb_input_xi_change_property_items_data_32_length (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S) +{ + return R->num_items; +} + +xcb_generic_iterator_t +xcb_input_xi_change_property_items_data_32_end (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->data32 + R->num_items; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_xi_change_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_xi_change_property_items_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[9]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data8 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8; + xcb_block_len += num_items * sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data16 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16; + xcb_block_len += num_items * sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data32 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32; + xcb_block_len += num_items * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; i<xcb_parts_idx; i++) { + if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) + memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); + if (0 != xcb_parts[i].iov_len) + xcb_tmp += xcb_parts[i].iov_len; + } + + return xcb_buffer_len; +} + +int +xcb_input_xi_change_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_xi_change_property_items_t *_aux) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data8 */ + _aux->data8 = (uint8_t *)xcb_tmp; + xcb_block_len += num_items * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data16 */ + _aux->data16 = (uint16_t *)xcb_tmp; + xcb_block_len += num_items * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data32 */ + _aux->data32 = (uint32_t *)xcb_tmp; + xcb_block_len += num_items * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + return xcb_buffer_len; +} + +int +xcb_input_xi_change_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format) +{ + xcb_input_xi_change_property_items_t _aux; + return xcb_input_xi_change_property_items_unpack(_buffer, num_items, format, &_aux); +} + +int +xcb_input_xi_change_property_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_change_property_request_t *_aux = (xcb_input_xi_change_property_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_xi_change_property_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* items */ + xcb_block_len += xcb_input_xi_change_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_input_xi_change_property_checked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const void *items) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_PROPERTY, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_change_property_request_t xcb_out; + + xcb_out.deviceid = deviceid; + xcb_out.mode = mode; + xcb_out.format = format; + xcb_out.property = property; + xcb_out.type = type; + xcb_out.num_items = num_items; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_xi_change_property_items_t items */ + xcb_parts[4].iov_base = (char *) items; + xcb_parts[4].iov_len = + xcb_input_xi_change_property_items_sizeof (items, num_items, format); + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_change_property (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const void *items) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_PROPERTY, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_change_property_request_t xcb_out; + + xcb_out.deviceid = deviceid; + xcb_out.mode = mode; + xcb_out.format = format; + xcb_out.property = property; + xcb_out.type = type; + xcb_out.num_items = num_items; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_xi_change_property_items_t items */ + xcb_parts[4].iov_base = (char *) items; + xcb_parts[4].iov_len = + xcb_input_xi_change_property_items_sizeof (items, num_items, format); + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_change_property_aux_checked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const xcb_input_xi_change_property_items_t *items) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_PROPERTY, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_change_property_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.deviceid = deviceid; + xcb_out.mode = mode; + xcb_out.format = format; + xcb_out.property = property; + xcb_out.type = type; + xcb_out.num_items = num_items; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_xi_change_property_items_t items */ + xcb_parts[4].iov_len = + xcb_input_xi_change_property_items_serialize (&xcb_aux0, num_items, format, items); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_change_property_aux (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const xcb_input_xi_change_property_items_t *items) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_PROPERTY, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_change_property_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.deviceid = deviceid; + xcb_out.mode = mode; + xcb_out.format = format; + xcb_out.property = property; + xcb_out.type = type; + xcb_out.num_items = num_items; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_input_xi_change_property_items_t items */ + xcb_parts[4].iov_len = + xcb_input_xi_change_property_items_serialize (&xcb_aux0, num_items, format, items); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +void * +xcb_input_xi_change_property_items (const xcb_input_xi_change_property_request_t *R) +{ + return (void *) (R + 1); +} + +xcb_void_cookie_t +xcb_input_xi_delete_property_checked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + xcb_atom_t property) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_DELETE_PROPERTY, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_delete_property_request_t xcb_out; + + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + xcb_out.property = property; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_input_xi_delete_property (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + xcb_atom_t property) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_DELETE_PROPERTY, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_input_xi_delete_property_request_t xcb_out; + + xcb_out.deviceid = deviceid; + memset(xcb_out.pad0, 0, 2); + xcb_out.property = property; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +uint8_t * +xcb_input_xi_get_property_items_data_8 (const xcb_input_xi_get_property_items_t *S) +{ + return S->data8; +} + +int +xcb_input_xi_get_property_items_data_8_length (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S) +{ + return R->num_items; +} + +xcb_generic_iterator_t +xcb_input_xi_get_property_items_data_8_end (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->data8 + R->num_items; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint16_t * +xcb_input_xi_get_property_items_data_16 (const xcb_input_xi_get_property_items_t *S) +{ + return S->data16; +} + +int +xcb_input_xi_get_property_items_data_16_length (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S) +{ + return R->num_items; +} + +xcb_generic_iterator_t +xcb_input_xi_get_property_items_data_16_end (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->data16 + R->num_items; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint32_t * +xcb_input_xi_get_property_items_data_32 (const xcb_input_xi_get_property_items_t *S) +{ + return S->data32; +} + +int +xcb_input_xi_get_property_items_data_32_length (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S) +{ + return R->num_items; +} + +xcb_generic_iterator_t +xcb_input_xi_get_property_items_data_32_end (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->data32 + R->num_items; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_xi_get_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_xi_get_property_items_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[9]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data8 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8; + xcb_block_len += num_items * sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data16 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16; + xcb_block_len += num_items * sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data32 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32; + xcb_block_len += num_items * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; i<xcb_parts_idx; i++) { + if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) + memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); + if (0 != xcb_parts[i].iov_len) + xcb_tmp += xcb_parts[i].iov_len; + } + + return xcb_buffer_len; +} + +int +xcb_input_xi_get_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_xi_get_property_items_t *_aux) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data8 */ + _aux->data8 = (uint8_t *)xcb_tmp; + xcb_block_len += num_items * sizeof(uint8_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data16 */ + _aux->data16 = (uint16_t *)xcb_tmp; + xcb_block_len += num_items * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* data32 */ + _aux->data32 = (uint32_t *)xcb_tmp; + xcb_block_len += num_items * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + } + /* insert padding */ + xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + return xcb_buffer_len; +} + +int +xcb_input_xi_get_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format) +{ + xcb_input_xi_get_property_items_t _aux; + return xcb_input_xi_get_property_items_unpack(_buffer, num_items, format, &_aux); +} + +int +xcb_input_xi_get_property_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_get_property_reply_t *_aux = (xcb_input_xi_get_property_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_xi_get_property_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* items */ + xcb_block_len += xcb_input_xi_get_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_xi_get_property_cookie_t +xcb_input_xi_get_property (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t _delete, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_PROPERTY, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_get_property_cookie_t xcb_ret; + xcb_input_xi_get_property_request_t xcb_out; + + xcb_out.deviceid = deviceid; + xcb_out._delete = _delete; + xcb_out.pad0 = 0; + xcb_out.property = property; + xcb_out.type = type; + xcb_out.offset = offset; + xcb_out.len = len; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_get_property_cookie_t +xcb_input_xi_get_property_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t _delete, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_PROPERTY, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_get_property_cookie_t xcb_ret; + xcb_input_xi_get_property_request_t xcb_out; + + xcb_out.deviceid = deviceid; + xcb_out._delete = _delete; + xcb_out.pad0 = 0; + xcb_out.property = property; + xcb_out.type = type; + xcb_out.offset = offset; + xcb_out.len = len; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +void * +xcb_input_xi_get_property_items (const xcb_input_xi_get_property_reply_t *R) +{ + return (void *) (R + 1); +} + +xcb_input_xi_get_property_reply_t * +xcb_input_xi_get_property_reply (xcb_connection_t *c, + xcb_input_xi_get_property_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_xi_get_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_xi_get_selected_events_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_get_selected_events_reply_t *_aux = (xcb_input_xi_get_selected_events_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_input_xi_get_selected_events_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* masks */ + for(i=0; i<_aux->num_masks; i++) { + xcb_tmp_len = xcb_input_event_mask_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_input_event_mask_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_xi_get_selected_events_cookie_t +xcb_input_xi_get_selected_events (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_SELECTED_EVENTS, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_get_selected_events_cookie_t xcb_ret; + xcb_input_xi_get_selected_events_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_input_xi_get_selected_events_cookie_t +xcb_input_xi_get_selected_events_unchecked (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_SELECTED_EVENTS, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_input_xi_get_selected_events_cookie_t xcb_ret; + xcb_input_xi_get_selected_events_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_input_xi_get_selected_events_masks_length (const xcb_input_xi_get_selected_events_reply_t *R) +{ + return R->num_masks; +} + +xcb_input_event_mask_iterator_t +xcb_input_xi_get_selected_events_masks_iterator (const xcb_input_xi_get_selected_events_reply_t *R) +{ + xcb_input_event_mask_iterator_t i; + i.data = (xcb_input_event_mask_t *) (R + 1); + i.rem = R->num_masks; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_xi_get_selected_events_reply_t * +xcb_input_xi_get_selected_events_reply (xcb_connection_t *c, + xcb_input_xi_get_selected_events_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_input_xi_get_selected_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_input_device_changed_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_device_changed_event_t *_aux = (xcb_input_device_changed_event_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + unsigned int i; + unsigned int xcb_tmp_len; + + xcb_block_len += sizeof(xcb_input_device_changed_event_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* classes */ + for(i=0; i<_aux->num_classes; i++) { + xcb_tmp_len = xcb_input_device_class_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_input_device_class_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +int +xcb_input_device_changed_classes_length (const xcb_input_device_changed_event_t *R) +{ + return R->num_classes; +} + +xcb_input_device_class_iterator_t +xcb_input_device_changed_classes_iterator (const xcb_input_device_changed_event_t *R) +{ + xcb_input_device_class_iterator_t i; + i.data = (xcb_input_device_class_t *) (R + 1); + i.rem = R->num_classes; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_key_press_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_key_press_event_t *_aux = (xcb_input_key_press_event_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */ + + xcb_block_len += sizeof(xcb_input_key_press_event_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* button_mask */ + xcb_block_len += _aux->buttons_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* valuator_mask */ + xcb_block_len += _aux->valuators_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* axisvalues */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->valuators_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_key_press_valuator_mask(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_4; + xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +uint32_t * +xcb_input_key_press_button_mask (const xcb_input_key_press_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_key_press_button_mask_length (const xcb_input_key_press_event_t *R) +{ + return R->buttons_len; +} + +xcb_generic_iterator_t +xcb_input_key_press_button_mask_end (const xcb_input_key_press_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->buttons_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +uint32_t * +xcb_input_key_press_valuator_mask (const xcb_input_key_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_key_press_button_mask_end(R); + return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); +} + +int +xcb_input_key_press_valuator_mask_length (const xcb_input_key_press_event_t *R) +{ + return R->valuators_len; +} + +xcb_generic_iterator_t +xcb_input_key_press_valuator_mask_end (const xcb_input_key_press_event_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_key_press_button_mask_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->valuators_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_key_press_axisvalues (const xcb_input_key_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_key_press_valuator_mask_end(R); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_key_press_axisvalues_length (const xcb_input_key_press_event_t *R) +{ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_5 = R->valuators_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_key_press_valuator_mask(R); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_8; + xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + return xcb_pre_tmp_7; +} + +xcb_input_fp3232_iterator_t +xcb_input_key_press_axisvalues_iterator (const xcb_input_key_press_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_key_press_valuator_mask_end(R); + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->valuators_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_key_press_valuator_mask(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_12; + xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_11; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_key_release_sizeof (const void *_buffer /**< */) +{ + return xcb_input_key_press_sizeof(_buffer); +} + +int +xcb_input_button_press_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_button_press_event_t *_aux = (xcb_input_button_press_event_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */ + + xcb_block_len += sizeof(xcb_input_button_press_event_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* button_mask */ + xcb_block_len += _aux->buttons_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* valuator_mask */ + xcb_block_len += _aux->valuators_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* axisvalues */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->valuators_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_button_press_valuator_mask(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_4; + xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +uint32_t * +xcb_input_button_press_button_mask (const xcb_input_button_press_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_button_press_button_mask_length (const xcb_input_button_press_event_t *R) +{ + return R->buttons_len; +} + +xcb_generic_iterator_t +xcb_input_button_press_button_mask_end (const xcb_input_button_press_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->buttons_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +uint32_t * +xcb_input_button_press_valuator_mask (const xcb_input_button_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_button_press_button_mask_end(R); + return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); +} + +int +xcb_input_button_press_valuator_mask_length (const xcb_input_button_press_event_t *R) +{ + return R->valuators_len; +} + +xcb_generic_iterator_t +xcb_input_button_press_valuator_mask_end (const xcb_input_button_press_event_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_button_press_button_mask_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->valuators_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_button_press_axisvalues (const xcb_input_button_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_button_press_valuator_mask_end(R); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_button_press_axisvalues_length (const xcb_input_button_press_event_t *R) +{ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_5 = R->valuators_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_button_press_valuator_mask(R); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_8; + xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + return xcb_pre_tmp_7; +} + +xcb_input_fp3232_iterator_t +xcb_input_button_press_axisvalues_iterator (const xcb_input_button_press_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_button_press_valuator_mask_end(R); + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->valuators_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_button_press_valuator_mask(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_12; + xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_11; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_button_release_sizeof (const void *_buffer /**< */) +{ + return xcb_input_button_press_sizeof(_buffer); +} + +int +xcb_input_motion_sizeof (const void *_buffer /**< */) +{ + return xcb_input_button_press_sizeof(_buffer); +} + +int +xcb_input_enter_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_enter_event_t *_aux = (xcb_input_enter_event_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_enter_event_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* buttons */ + xcb_block_len += _aux->buttons_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +uint32_t * +xcb_input_enter_buttons (const xcb_input_enter_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_enter_buttons_length (const xcb_input_enter_event_t *R) +{ + return R->buttons_len; +} + +xcb_generic_iterator_t +xcb_input_enter_buttons_end (const xcb_input_enter_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->buttons_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_leave_sizeof (const void *_buffer /**< */) +{ + return xcb_input_enter_sizeof(_buffer); +} + +int +xcb_input_focus_in_sizeof (const void *_buffer /**< */) +{ + return xcb_input_enter_sizeof(_buffer); +} + +int +xcb_input_focus_out_sizeof (const void *_buffer /**< */) +{ + return xcb_input_enter_sizeof(_buffer); +} + +void +xcb_input_hierarchy_info_next (xcb_input_hierarchy_info_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_input_hierarchy_info_t); +} + +xcb_generic_iterator_t +xcb_input_hierarchy_info_end (xcb_input_hierarchy_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +int +xcb_input_hierarchy_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_hierarchy_event_t *_aux = (xcb_input_hierarchy_event_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_input_hierarchy_event_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* infos */ + xcb_block_len += _aux->num_infos * sizeof(xcb_input_hierarchy_info_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_hierarchy_info_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_input_hierarchy_info_t * +xcb_input_hierarchy_infos (const xcb_input_hierarchy_event_t *R) +{ + return (xcb_input_hierarchy_info_t *) (R + 1); +} + +int +xcb_input_hierarchy_infos_length (const xcb_input_hierarchy_event_t *R) +{ + return R->num_infos; +} + +xcb_input_hierarchy_info_iterator_t +xcb_input_hierarchy_infos_iterator (const xcb_input_hierarchy_event_t *R) +{ + xcb_input_hierarchy_info_iterator_t i; + i.data = (xcb_input_hierarchy_info_t *) (R + 1); + i.rem = R->num_infos; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_raw_key_press_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_raw_key_press_event_t *_aux = (xcb_input_raw_key_press_event_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */ + + xcb_block_len += sizeof(xcb_input_raw_key_press_event_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* valuator_mask */ + xcb_block_len += _aux->valuators_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* axisvalues */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->valuators_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_raw_key_press_valuator_mask(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_4; + xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* axisvalues_raw */ + /* sumof start */ + xcb_pre_tmp_5 = _aux->valuators_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_raw_key_press_valuator_mask(_aux); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_8; + xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + xcb_block_len += xcb_pre_tmp_7 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +uint32_t * +xcb_input_raw_key_press_valuator_mask (const xcb_input_raw_key_press_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_raw_key_press_valuator_mask_length (const xcb_input_raw_key_press_event_t *R) +{ + return R->valuators_len; +} + +xcb_generic_iterator_t +xcb_input_raw_key_press_valuator_mask_end (const xcb_input_raw_key_press_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->valuators_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_raw_key_press_axisvalues (const xcb_input_raw_key_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_raw_key_press_valuator_mask_end(R); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_raw_key_press_axisvalues_length (const xcb_input_raw_key_press_event_t *R) +{ + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->valuators_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_raw_key_press_valuator_mask(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_12; + xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + return xcb_pre_tmp_11; +} + +xcb_input_fp3232_iterator_t +xcb_input_raw_key_press_axisvalues_iterator (const xcb_input_raw_key_press_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_raw_key_press_valuator_mask_end(R); + int xcb_pre_tmp_13; /* sumof length */ + int xcb_pre_tmp_14; /* sumof loop counter */ + int64_t xcb_pre_tmp_15; /* sumof sum */ + const uint32_t* xcb_pre_tmp_16; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_13 = R->valuators_len; + xcb_pre_tmp_15 = 0; + xcb_pre_tmp_16 = xcb_input_raw_key_press_valuator_mask(R); + for (xcb_pre_tmp_14 = 0; xcb_pre_tmp_14 < xcb_pre_tmp_13; xcb_pre_tmp_14++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_16; + xcb_pre_tmp_15 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_16++; + } + /* sumof end. Result is in xcb_pre_tmp_15 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_15; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_raw_key_press_axisvalues_raw (const xcb_input_raw_key_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_key_press_axisvalues_iterator(R)); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_raw_key_press_axisvalues_raw_length (const xcb_input_raw_key_press_event_t *R) +{ + int xcb_pre_tmp_17; /* sumof length */ + int xcb_pre_tmp_18; /* sumof loop counter */ + int64_t xcb_pre_tmp_19; /* sumof sum */ + const uint32_t* xcb_pre_tmp_20; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_17 = R->valuators_len; + xcb_pre_tmp_19 = 0; + xcb_pre_tmp_20 = xcb_input_raw_key_press_valuator_mask(R); + for (xcb_pre_tmp_18 = 0; xcb_pre_tmp_18 < xcb_pre_tmp_17; xcb_pre_tmp_18++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_20; + xcb_pre_tmp_19 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_20++; + } + /* sumof end. Result is in xcb_pre_tmp_19 */ + return xcb_pre_tmp_19; +} + +xcb_input_fp3232_iterator_t +xcb_input_raw_key_press_axisvalues_raw_iterator (const xcb_input_raw_key_press_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_key_press_axisvalues_iterator(R)); + int xcb_pre_tmp_21; /* sumof length */ + int xcb_pre_tmp_22; /* sumof loop counter */ + int64_t xcb_pre_tmp_23; /* sumof sum */ + const uint32_t* xcb_pre_tmp_24; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_21 = R->valuators_len; + xcb_pre_tmp_23 = 0; + xcb_pre_tmp_24 = xcb_input_raw_key_press_valuator_mask(R); + for (xcb_pre_tmp_22 = 0; xcb_pre_tmp_22 < xcb_pre_tmp_21; xcb_pre_tmp_22++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_24; + xcb_pre_tmp_23 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_24++; + } + /* sumof end. Result is in xcb_pre_tmp_23 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_23; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_raw_key_release_sizeof (const void *_buffer /**< */) +{ + return xcb_input_raw_key_press_sizeof(_buffer); +} + +int +xcb_input_raw_button_press_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_raw_button_press_event_t *_aux = (xcb_input_raw_button_press_event_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */ + + xcb_block_len += sizeof(xcb_input_raw_button_press_event_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* valuator_mask */ + xcb_block_len += _aux->valuators_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* axisvalues */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->valuators_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_raw_button_press_valuator_mask(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_4; + xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* axisvalues_raw */ + /* sumof start */ + xcb_pre_tmp_5 = _aux->valuators_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_raw_button_press_valuator_mask(_aux); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_8; + xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + xcb_block_len += xcb_pre_tmp_7 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +uint32_t * +xcb_input_raw_button_press_valuator_mask (const xcb_input_raw_button_press_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_raw_button_press_valuator_mask_length (const xcb_input_raw_button_press_event_t *R) +{ + return R->valuators_len; +} + +xcb_generic_iterator_t +xcb_input_raw_button_press_valuator_mask_end (const xcb_input_raw_button_press_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->valuators_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_raw_button_press_axisvalues (const xcb_input_raw_button_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_raw_button_press_valuator_mask_end(R); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_raw_button_press_axisvalues_length (const xcb_input_raw_button_press_event_t *R) +{ + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->valuators_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_raw_button_press_valuator_mask(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_12; + xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + return xcb_pre_tmp_11; +} + +xcb_input_fp3232_iterator_t +xcb_input_raw_button_press_axisvalues_iterator (const xcb_input_raw_button_press_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_raw_button_press_valuator_mask_end(R); + int xcb_pre_tmp_13; /* sumof length */ + int xcb_pre_tmp_14; /* sumof loop counter */ + int64_t xcb_pre_tmp_15; /* sumof sum */ + const uint32_t* xcb_pre_tmp_16; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_13 = R->valuators_len; + xcb_pre_tmp_15 = 0; + xcb_pre_tmp_16 = xcb_input_raw_button_press_valuator_mask(R); + for (xcb_pre_tmp_14 = 0; xcb_pre_tmp_14 < xcb_pre_tmp_13; xcb_pre_tmp_14++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_16; + xcb_pre_tmp_15 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_16++; + } + /* sumof end. Result is in xcb_pre_tmp_15 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_15; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_raw_button_press_axisvalues_raw (const xcb_input_raw_button_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_button_press_axisvalues_iterator(R)); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_raw_button_press_axisvalues_raw_length (const xcb_input_raw_button_press_event_t *R) +{ + int xcb_pre_tmp_17; /* sumof length */ + int xcb_pre_tmp_18; /* sumof loop counter */ + int64_t xcb_pre_tmp_19; /* sumof sum */ + const uint32_t* xcb_pre_tmp_20; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_17 = R->valuators_len; + xcb_pre_tmp_19 = 0; + xcb_pre_tmp_20 = xcb_input_raw_button_press_valuator_mask(R); + for (xcb_pre_tmp_18 = 0; xcb_pre_tmp_18 < xcb_pre_tmp_17; xcb_pre_tmp_18++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_20; + xcb_pre_tmp_19 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_20++; + } + /* sumof end. Result is in xcb_pre_tmp_19 */ + return xcb_pre_tmp_19; +} + +xcb_input_fp3232_iterator_t +xcb_input_raw_button_press_axisvalues_raw_iterator (const xcb_input_raw_button_press_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_button_press_axisvalues_iterator(R)); + int xcb_pre_tmp_21; /* sumof length */ + int xcb_pre_tmp_22; /* sumof loop counter */ + int64_t xcb_pre_tmp_23; /* sumof sum */ + const uint32_t* xcb_pre_tmp_24; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_21 = R->valuators_len; + xcb_pre_tmp_23 = 0; + xcb_pre_tmp_24 = xcb_input_raw_button_press_valuator_mask(R); + for (xcb_pre_tmp_22 = 0; xcb_pre_tmp_22 < xcb_pre_tmp_21; xcb_pre_tmp_22++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_24; + xcb_pre_tmp_23 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_24++; + } + /* sumof end. Result is in xcb_pre_tmp_23 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_23; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_raw_button_release_sizeof (const void *_buffer /**< */) +{ + return xcb_input_raw_button_press_sizeof(_buffer); +} + +int +xcb_input_raw_motion_sizeof (const void *_buffer /**< */) +{ + return xcb_input_raw_button_press_sizeof(_buffer); +} + +int +xcb_input_touch_begin_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_touch_begin_event_t *_aux = (xcb_input_touch_begin_event_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */ + + xcb_block_len += sizeof(xcb_input_touch_begin_event_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* button_mask */ + xcb_block_len += _aux->buttons_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* valuator_mask */ + xcb_block_len += _aux->valuators_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* axisvalues */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->valuators_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_touch_begin_valuator_mask(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_4; + xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +uint32_t * +xcb_input_touch_begin_button_mask (const xcb_input_touch_begin_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_touch_begin_button_mask_length (const xcb_input_touch_begin_event_t *R) +{ + return R->buttons_len; +} + +xcb_generic_iterator_t +xcb_input_touch_begin_button_mask_end (const xcb_input_touch_begin_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->buttons_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +uint32_t * +xcb_input_touch_begin_valuator_mask (const xcb_input_touch_begin_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_touch_begin_button_mask_end(R); + return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); +} + +int +xcb_input_touch_begin_valuator_mask_length (const xcb_input_touch_begin_event_t *R) +{ + return R->valuators_len; +} + +xcb_generic_iterator_t +xcb_input_touch_begin_valuator_mask_end (const xcb_input_touch_begin_event_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_touch_begin_button_mask_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->valuators_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_touch_begin_axisvalues (const xcb_input_touch_begin_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_touch_begin_valuator_mask_end(R); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_touch_begin_axisvalues_length (const xcb_input_touch_begin_event_t *R) +{ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_5 = R->valuators_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_touch_begin_valuator_mask(R); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_8; + xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + return xcb_pre_tmp_7; +} + +xcb_input_fp3232_iterator_t +xcb_input_touch_begin_axisvalues_iterator (const xcb_input_touch_begin_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_touch_begin_valuator_mask_end(R); + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->valuators_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_touch_begin_valuator_mask(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_12; + xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_11; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_touch_update_sizeof (const void *_buffer /**< */) +{ + return xcb_input_touch_begin_sizeof(_buffer); +} + +int +xcb_input_touch_end_sizeof (const void *_buffer /**< */) +{ + return xcb_input_touch_begin_sizeof(_buffer); +} + +int +xcb_input_raw_touch_begin_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_raw_touch_begin_event_t *_aux = (xcb_input_raw_touch_begin_event_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */ + + xcb_block_len += sizeof(xcb_input_raw_touch_begin_event_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* valuator_mask */ + xcb_block_len += _aux->valuators_len * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* axisvalues */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->valuators_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_raw_touch_begin_valuator_mask(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_4; + xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* axisvalues_raw */ + /* sumof start */ + xcb_pre_tmp_5 = _aux->valuators_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_raw_touch_begin_valuator_mask(_aux); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_8; + xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + xcb_block_len += xcb_pre_tmp_7 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +uint32_t * +xcb_input_raw_touch_begin_valuator_mask (const xcb_input_raw_touch_begin_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_raw_touch_begin_valuator_mask_length (const xcb_input_raw_touch_begin_event_t *R) +{ + return R->valuators_len; +} + +xcb_generic_iterator_t +xcb_input_raw_touch_begin_valuator_mask_end (const xcb_input_raw_touch_begin_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->valuators_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_raw_touch_begin_axisvalues (const xcb_input_raw_touch_begin_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_raw_touch_begin_valuator_mask_end(R); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_raw_touch_begin_axisvalues_length (const xcb_input_raw_touch_begin_event_t *R) +{ + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->valuators_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_raw_touch_begin_valuator_mask(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_12; + xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + return xcb_pre_tmp_11; +} + +xcb_input_fp3232_iterator_t +xcb_input_raw_touch_begin_axisvalues_iterator (const xcb_input_raw_touch_begin_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_raw_touch_begin_valuator_mask_end(R); + int xcb_pre_tmp_13; /* sumof length */ + int xcb_pre_tmp_14; /* sumof loop counter */ + int64_t xcb_pre_tmp_15; /* sumof sum */ + const uint32_t* xcb_pre_tmp_16; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_13 = R->valuators_len; + xcb_pre_tmp_15 = 0; + xcb_pre_tmp_16 = xcb_input_raw_touch_begin_valuator_mask(R); + for (xcb_pre_tmp_14 = 0; xcb_pre_tmp_14 < xcb_pre_tmp_13; xcb_pre_tmp_14++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_16; + xcb_pre_tmp_15 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_16++; + } + /* sumof end. Result is in xcb_pre_tmp_15 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_15; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_raw_touch_begin_axisvalues_raw (const xcb_input_raw_touch_begin_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_touch_begin_axisvalues_iterator(R)); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_raw_touch_begin_axisvalues_raw_length (const xcb_input_raw_touch_begin_event_t *R) +{ + int xcb_pre_tmp_17; /* sumof length */ + int xcb_pre_tmp_18; /* sumof loop counter */ + int64_t xcb_pre_tmp_19; /* sumof sum */ + const uint32_t* xcb_pre_tmp_20; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_17 = R->valuators_len; + xcb_pre_tmp_19 = 0; + xcb_pre_tmp_20 = xcb_input_raw_touch_begin_valuator_mask(R); + for (xcb_pre_tmp_18 = 0; xcb_pre_tmp_18 < xcb_pre_tmp_17; xcb_pre_tmp_18++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_20; + xcb_pre_tmp_19 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_20++; + } + /* sumof end. Result is in xcb_pre_tmp_19 */ + return xcb_pre_tmp_19; +} + +xcb_input_fp3232_iterator_t +xcb_input_raw_touch_begin_axisvalues_raw_iterator (const xcb_input_raw_touch_begin_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_touch_begin_axisvalues_iterator(R)); + int xcb_pre_tmp_21; /* sumof length */ + int xcb_pre_tmp_22; /* sumof loop counter */ + int64_t xcb_pre_tmp_23; /* sumof sum */ + const uint32_t* xcb_pre_tmp_24; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_21 = R->valuators_len; + xcb_pre_tmp_23 = 0; + xcb_pre_tmp_24 = xcb_input_raw_touch_begin_valuator_mask(R); + for (xcb_pre_tmp_22 = 0; xcb_pre_tmp_22 < xcb_pre_tmp_21; xcb_pre_tmp_22++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_24; + xcb_pre_tmp_23 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_24++; + } + /* sumof end. Result is in xcb_pre_tmp_23 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_23; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_raw_touch_update_sizeof (const void *_buffer /**< */) +{ + return xcb_input_raw_touch_begin_sizeof(_buffer); +} + +int +xcb_input_raw_touch_end_sizeof (const void *_buffer /**< */) +{ + return xcb_input_raw_touch_begin_sizeof(_buffer); +} diff --git a/src/3rdparty/xcb/libxcb/xkb.c b/src/3rdparty/xcb/libxcb/xkb.c index ff025f6b60..d55bd76f10 100644 --- a/src/3rdparty/xcb/libxcb/xkb.c +++ b/src/3rdparty/xcb/libxcb/xkb.c @@ -18,15 +18,6 @@ xcb_extension_t xcb_xkb_id = { "XKEYBOARD", 0 }; -int qt_xcb_sumof(uint8_t *list, int len) -{ - int i, s = 0; - for(i=0; i<len; i++) { - s += *list; - list++; - } - return s; -} /***************************************************************************** ** @@ -9034,7 +9025,7 @@ int xcb_xkb_get_names_value_list_kt_level_names_length (const xcb_xkb_get_names_reply_t *R /**< */, const xcb_xkb_get_names_value_list_t *S /**< */) { - return qt_xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); + return xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); } @@ -9052,7 +9043,7 @@ xcb_xkb_get_names_value_list_kt_level_names_end (const xcb_xkb_get_names_reply_t const xcb_xkb_get_names_value_list_t *S /**< */) { xcb_generic_iterator_t i; - i.data = /* valueList */ S->ktLevelNames + qt_xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); + i.data = /* valueList */ S->ktLevelNames + xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; @@ -9517,8 +9508,8 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_block_len = 0; /* ktLevelNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames; - xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); - xcb_parts[xcb_parts_idx].iov_len = qt_xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); + xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); + xcb_parts[xcb_parts_idx].iov_len = xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(xcb_atom_t); } @@ -9771,7 +9762,7 @@ xcb_xkb_get_names_value_list_unpack (const void *_buffer / xcb_block_len = 0; /* ktLevelNames */ _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp; - xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); + xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_atom_t); } @@ -10148,7 +10139,7 @@ int xcb_xkb_set_names_values_kt_level_names_length (const xcb_xkb_set_names_request_t *R /**< */, const xcb_xkb_set_names_values_t *S /**< */) { - return qt_xcb_sumof(/* values */ S->nLevelsPerType, R->nKTLevels); + return xcb_sumof(/* values */ S->nLevelsPerType, R->nKTLevels); } @@ -10166,7 +10157,7 @@ xcb_xkb_set_names_values_kt_level_names_end (const xcb_xkb_set_names_request_t * const xcb_xkb_set_names_values_t *S /**< */) { xcb_generic_iterator_t i; - i.data = /* values */ S->ktLevelNames + qt_xcb_sumof(/* values */ S->nLevelsPerType, R->nKTLevels); + i.data = /* values */ S->ktLevelNames + xcb_sumof(/* values */ S->nLevelsPerType, R->nKTLevels); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; @@ -10616,8 +10607,8 @@ xcb_xkb_set_names_values_serialize (void **_buffer xcb_block_len = 0; /* ktLevelNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames; - xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); - xcb_parts[xcb_parts_idx].iov_len = qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); + xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); + xcb_parts[xcb_parts_idx].iov_len = xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(xcb_atom_t); } @@ -10858,7 +10849,7 @@ xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, xcb_block_len = 0; /* ktLevelNames */ _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp; - xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); + xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_atom_t); } @@ -12881,7 +12872,7 @@ int xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) { - return qt_xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nKTLevels); + return xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nKTLevels); } @@ -12899,7 +12890,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_end (const x const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) { xcb_generic_iterator_t i; - i.data = /* replies */ S->key_names.valueList.ktLevelNames + qt_xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nKTLevels); + i.data = /* replies */ S->key_names.valueList.ktLevelNames + xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nKTLevels); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; @@ -13349,8 +13340,8 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void xcb_block_len = 0; /* ktLevelNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames; - xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); - xcb_parts[xcb_parts_idx].iov_len = qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); + xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); + xcb_parts[xcb_parts_idx].iov_len = xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(xcb_atom_t); } @@ -13591,7 +13582,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void xcb_block_len = 0; /* ktLevelNames */ _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp; - xcb_block_len += qt_xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); + xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nKTLevels) * sizeof(xcb_atom_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_atom_t); } diff --git a/src/3rdparty/xkbcommon.pri b/src/3rdparty/xkbcommon.pri index 1d953d8372..8259a8b8bd 100644 --- a/src/3rdparty/xkbcommon.pri +++ b/src/3rdparty/xkbcommon.pri @@ -1,4 +1,6 @@ -QMAKE_CFLAGS += -std=gnu99 -w +# Requires GNU C extensions +CONFIG -= strict_c + INCLUDEPATH += $$PWD/xkbcommon \ $$PWD/xkbcommon/xkbcommon \ $$PWD/xkbcommon/src \ |