| // Copyright 2021 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // This file was automatically generated with: |
| // ../../ui/gfx/x/gen_xproto.py \ |
| // ../../third_party/xcbproto/src \ |
| // gen/ui/gfx/x \ |
| // bigreq \ |
| // composite \ |
| // damage \ |
| // dpms \ |
| // dri2 \ |
| // dri3 \ |
| // ge \ |
| // glx \ |
| // present \ |
| // randr \ |
| // record \ |
| // render \ |
| // res \ |
| // screensaver \ |
| // shape \ |
| // shm \ |
| // sync \ |
| // xc_misc \ |
| // xevie \ |
| // xf86dri \ |
| // xf86vidmode \ |
| // xfixes \ |
| // xinerama \ |
| // xinput \ |
| // xkb \ |
| // xprint \ |
| // xproto \ |
| // xselinux \ |
| // xtest \ |
| // xv \ |
| // xvmc |
| |
| #ifndef UI_GFX_X_GENERATED_PROTOS_XF86VIDMODE_H_ |
| #define UI_GFX_X_GENERATED_PROTOS_XF86VIDMODE_H_ |
| |
| #include <array> |
| #include <cstddef> |
| #include <cstdint> |
| #include <cstring> |
| #include <vector> |
| |
| #include "base/component_export.h" |
| #include "base/files/scoped_file.h" |
| #include "base/memory/ref_counted_memory.h" |
| #include "base/memory/scoped_refptr.h" |
| #include "third_party/abseil-cpp/absl/types/optional.h" |
| #include "ui/gfx/x/error.h" |
| #include "ui/gfx/x/ref_counted_fd.h" |
| #include "xproto.h" |
| |
| namespace x11 { |
| |
| class Connection; |
| |
| template <typename Reply> |
| struct Response; |
| |
| template <typename Reply> |
| class Future; |
| |
| class COMPONENT_EXPORT(X11) XF86VidMode { |
| public: |
| static constexpr unsigned major_version = 2; |
| static constexpr unsigned minor_version = 2; |
| |
| XF86VidMode(Connection* connection, const x11::QueryExtensionReply& info); |
| |
| uint8_t present() const { return info_.present; } |
| uint8_t major_opcode() const { return info_.major_opcode; } |
| uint8_t first_event() const { return info_.first_event; } |
| uint8_t first_error() const { return info_.first_error; } |
| |
| Connection* connection() const { return connection_; } |
| |
| enum class Syncrange : uint32_t {}; |
| |
| enum class DotClock : uint32_t {}; |
| |
| enum class ModeFlag : int { |
| Positive_HSync = 1 << 0, |
| Negative_HSync = 1 << 1, |
| Positive_VSync = 1 << 2, |
| Negative_VSync = 1 << 3, |
| Interlace = 1 << 4, |
| Composite_Sync = 1 << 5, |
| Positive_CSync = 1 << 6, |
| Negative_CSync = 1 << 7, |
| HSkew = 1 << 8, |
| Broadcast = 1 << 9, |
| Pixmux = 1 << 10, |
| Double_Clock = 1 << 11, |
| Half_Clock = 1 << 12, |
| }; |
| |
| enum class ClockFlag : int { |
| Programable = 1 << 0, |
| }; |
| |
| enum class Permission : int { |
| Read = 1 << 0, |
| Write = 1 << 1, |
| }; |
| |
| struct ModeInfo { |
| DotClock dotclock{}; |
| uint16_t hdisplay{}; |
| uint16_t hsyncstart{}; |
| uint16_t hsyncend{}; |
| uint16_t htotal{}; |
| uint32_t hskew{}; |
| uint16_t vdisplay{}; |
| uint16_t vsyncstart{}; |
| uint16_t vsyncend{}; |
| uint16_t vtotal{}; |
| ModeFlag flags{}; |
| uint32_t privsize{}; |
| }; |
| |
| struct BadClockError : public x11::Error { |
| uint16_t sequence{}; |
| |
| std::string ToString() const override; |
| }; |
| |
| struct BadHTimingsError : public x11::Error { |
| uint16_t sequence{}; |
| |
| std::string ToString() const override; |
| }; |
| |
| struct BadVTimingsError : public x11::Error { |
| uint16_t sequence{}; |
| |
| std::string ToString() const override; |
| }; |
| |
| struct ModeUnsuitableError : public x11::Error { |
| uint16_t sequence{}; |
| |
| std::string ToString() const override; |
| }; |
| |
| struct ExtensionDisabledError : public x11::Error { |
| uint16_t sequence{}; |
| |
| std::string ToString() const override; |
| }; |
| |
| struct ClientNotLocalError : public x11::Error { |
| uint16_t sequence{}; |
| |
| std::string ToString() const override; |
| }; |
| |
| struct ZoomLockedError : public x11::Error { |
| uint16_t sequence{}; |
| |
| std::string ToString() const override; |
| }; |
| |
| struct QueryVersionRequest {}; |
| |
| struct QueryVersionReply { |
| uint16_t sequence{}; |
| uint16_t major_version{}; |
| uint16_t minor_version{}; |
| }; |
| |
| using QueryVersionResponse = Response<QueryVersionReply>; |
| |
| Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request); |
| |
| Future<QueryVersionReply> QueryVersion(); |
| |
| struct GetModeLineRequest { |
| uint16_t screen{}; |
| }; |
| |
| struct GetModeLineReply { |
| uint16_t sequence{}; |
| DotClock dotclock{}; |
| uint16_t hdisplay{}; |
| uint16_t hsyncstart{}; |
| uint16_t hsyncend{}; |
| uint16_t htotal{}; |
| uint16_t hskew{}; |
| uint16_t vdisplay{}; |
| uint16_t vsyncstart{}; |
| uint16_t vsyncend{}; |
| uint16_t vtotal{}; |
| ModeFlag flags{}; |
| std::vector<uint8_t> c_private{}; |
| }; |
| |
| using GetModeLineResponse = Response<GetModeLineReply>; |
| |
| Future<GetModeLineReply> GetModeLine(const GetModeLineRequest& request); |
| |
| Future<GetModeLineReply> GetModeLine(const uint16_t& screen = {}); |
| |
| struct ModModeLineRequest { |
| uint32_t screen{}; |
| uint16_t hdisplay{}; |
| uint16_t hsyncstart{}; |
| uint16_t hsyncend{}; |
| uint16_t htotal{}; |
| uint16_t hskew{}; |
| uint16_t vdisplay{}; |
| uint16_t vsyncstart{}; |
| uint16_t vsyncend{}; |
| uint16_t vtotal{}; |
| ModeFlag flags{}; |
| std::vector<uint8_t> c_private{}; |
| }; |
| |
| using ModModeLineResponse = Response<void>; |
| |
| Future<void> ModModeLine(const ModModeLineRequest& request); |
| |
| Future<void> ModModeLine(const uint32_t& screen = {}, |
| const uint16_t& hdisplay = {}, |
| const uint16_t& hsyncstart = {}, |
| const uint16_t& hsyncend = {}, |
| const uint16_t& htotal = {}, |
| const uint16_t& hskew = {}, |
| const uint16_t& vdisplay = {}, |
| const uint16_t& vsyncstart = {}, |
| const uint16_t& vsyncend = {}, |
| const uint16_t& vtotal = {}, |
| const ModeFlag& flags = {}, |
| const std::vector<uint8_t>& c_private = {}); |
| |
| struct SwitchModeRequest { |
| uint16_t screen{}; |
| uint16_t zoom{}; |
| }; |
| |
| using SwitchModeResponse = Response<void>; |
| |
| Future<void> SwitchMode(const SwitchModeRequest& request); |
| |
| Future<void> SwitchMode(const uint16_t& screen = {}, |
| const uint16_t& zoom = {}); |
| |
| struct GetMonitorRequest { |
| uint16_t screen{}; |
| }; |
| |
| struct GetMonitorReply { |
| uint16_t sequence{}; |
| std::vector<Syncrange> hsync{}; |
| std::vector<Syncrange> vsync{}; |
| std::string vendor{}; |
| scoped_refptr<base::RefCountedMemory> alignment_pad{}; |
| std::string model{}; |
| }; |
| |
| using GetMonitorResponse = Response<GetMonitorReply>; |
| |
| Future<GetMonitorReply> GetMonitor(const GetMonitorRequest& request); |
| |
| Future<GetMonitorReply> GetMonitor(const uint16_t& screen = {}); |
| |
| struct LockModeSwitchRequest { |
| uint16_t screen{}; |
| uint16_t lock{}; |
| }; |
| |
| using LockModeSwitchResponse = Response<void>; |
| |
| Future<void> LockModeSwitch(const LockModeSwitchRequest& request); |
| |
| Future<void> LockModeSwitch(const uint16_t& screen = {}, |
| const uint16_t& lock = {}); |
| |
| struct GetAllModeLinesRequest { |
| uint16_t screen{}; |
| }; |
| |
| struct GetAllModeLinesReply { |
| uint16_t sequence{}; |
| std::vector<ModeInfo> modeinfo{}; |
| }; |
| |
| using GetAllModeLinesResponse = Response<GetAllModeLinesReply>; |
| |
| Future<GetAllModeLinesReply> GetAllModeLines( |
| const GetAllModeLinesRequest& request); |
| |
| Future<GetAllModeLinesReply> GetAllModeLines(const uint16_t& screen = {}); |
| |
| struct AddModeLineRequest { |
| uint32_t screen{}; |
| DotClock dotclock{}; |
| uint16_t hdisplay{}; |
| uint16_t hsyncstart{}; |
| uint16_t hsyncend{}; |
| uint16_t htotal{}; |
| uint16_t hskew{}; |
| uint16_t vdisplay{}; |
| uint16_t vsyncstart{}; |
| uint16_t vsyncend{}; |
| uint16_t vtotal{}; |
| ModeFlag flags{}; |
| DotClock after_dotclock{}; |
| uint16_t after_hdisplay{}; |
| uint16_t after_hsyncstart{}; |
| uint16_t after_hsyncend{}; |
| uint16_t after_htotal{}; |
| uint16_t after_hskew{}; |
| uint16_t after_vdisplay{}; |
| uint16_t after_vsyncstart{}; |
| uint16_t after_vsyncend{}; |
| uint16_t after_vtotal{}; |
| ModeFlag after_flags{}; |
| std::vector<uint8_t> c_private{}; |
| }; |
| |
| using AddModeLineResponse = Response<void>; |
| |
| Future<void> AddModeLine(const AddModeLineRequest& request); |
| |
| Future<void> AddModeLine(const uint32_t& screen = {}, |
| const DotClock& dotclock = {}, |
| const uint16_t& hdisplay = {}, |
| const uint16_t& hsyncstart = {}, |
| const uint16_t& hsyncend = {}, |
| const uint16_t& htotal = {}, |
| const uint16_t& hskew = {}, |
| const uint16_t& vdisplay = {}, |
| const uint16_t& vsyncstart = {}, |
| const uint16_t& vsyncend = {}, |
| const uint16_t& vtotal = {}, |
| const ModeFlag& flags = {}, |
| const DotClock& after_dotclock = {}, |
| const uint16_t& after_hdisplay = {}, |
| const uint16_t& after_hsyncstart = {}, |
| const uint16_t& after_hsyncend = {}, |
| const uint16_t& after_htotal = {}, |
| const uint16_t& after_hskew = {}, |
| const uint16_t& after_vdisplay = {}, |
| const uint16_t& after_vsyncstart = {}, |
| const uint16_t& after_vsyncend = {}, |
| const uint16_t& after_vtotal = {}, |
| const ModeFlag& after_flags = {}, |
| const std::vector<uint8_t>& c_private = {}); |
| |
| struct DeleteModeLineRequest { |
| uint32_t screen{}; |
| DotClock dotclock{}; |
| uint16_t hdisplay{}; |
| uint16_t hsyncstart{}; |
| uint16_t hsyncend{}; |
| uint16_t htotal{}; |
| uint16_t hskew{}; |
| uint16_t vdisplay{}; |
| uint16_t vsyncstart{}; |
| uint16_t vsyncend{}; |
| uint16_t vtotal{}; |
| ModeFlag flags{}; |
| std::vector<uint8_t> c_private{}; |
| }; |
| |
| using DeleteModeLineResponse = Response<void>; |
| |
| Future<void> DeleteModeLine(const DeleteModeLineRequest& request); |
| |
| Future<void> DeleteModeLine(const uint32_t& screen = {}, |
| const DotClock& dotclock = {}, |
| const uint16_t& hdisplay = {}, |
| const uint16_t& hsyncstart = {}, |
| const uint16_t& hsyncend = {}, |
| const uint16_t& htotal = {}, |
| const uint16_t& hskew = {}, |
| const uint16_t& vdisplay = {}, |
| const uint16_t& vsyncstart = {}, |
| const uint16_t& vsyncend = {}, |
| const uint16_t& vtotal = {}, |
| const ModeFlag& flags = {}, |
| const std::vector<uint8_t>& c_private = {}); |
| |
| struct ValidateModeLineRequest { |
| uint32_t screen{}; |
| DotClock dotclock{}; |
| uint16_t hdisplay{}; |
| uint16_t hsyncstart{}; |
| uint16_t hsyncend{}; |
| uint16_t htotal{}; |
| uint16_t hskew{}; |
| uint16_t vdisplay{}; |
| uint16_t vsyncstart{}; |
| uint16_t vsyncend{}; |
| uint16_t vtotal{}; |
| ModeFlag flags{}; |
| std::vector<uint8_t> c_private{}; |
| }; |
| |
| struct ValidateModeLineReply { |
| uint16_t sequence{}; |
| uint32_t status{}; |
| }; |
| |
| using ValidateModeLineResponse = Response<ValidateModeLineReply>; |
| |
| Future<ValidateModeLineReply> ValidateModeLine( |
| const ValidateModeLineRequest& request); |
| |
| Future<ValidateModeLineReply> ValidateModeLine( |
| const uint32_t& screen = {}, |
| const DotClock& dotclock = {}, |
| const uint16_t& hdisplay = {}, |
| const uint16_t& hsyncstart = {}, |
| const uint16_t& hsyncend = {}, |
| const uint16_t& htotal = {}, |
| const uint16_t& hskew = {}, |
| const uint16_t& vdisplay = {}, |
| const uint16_t& vsyncstart = {}, |
| const uint16_t& vsyncend = {}, |
| const uint16_t& vtotal = {}, |
| const ModeFlag& flags = {}, |
| const std::vector<uint8_t>& c_private = {}); |
| |
| struct SwitchToModeRequest { |
| uint32_t screen{}; |
| DotClock dotclock{}; |
| uint16_t hdisplay{}; |
| uint16_t hsyncstart{}; |
| uint16_t hsyncend{}; |
| uint16_t htotal{}; |
| uint16_t hskew{}; |
| uint16_t vdisplay{}; |
| uint16_t vsyncstart{}; |
| uint16_t vsyncend{}; |
| uint16_t vtotal{}; |
| ModeFlag flags{}; |
| std::vector<uint8_t> c_private{}; |
| }; |
| |
| using SwitchToModeResponse = Response<void>; |
| |
| Future<void> SwitchToMode(const SwitchToModeRequest& request); |
| |
| Future<void> SwitchToMode(const uint32_t& screen = {}, |
| const DotClock& dotclock = {}, |
| const uint16_t& hdisplay = {}, |
| const uint16_t& hsyncstart = {}, |
| const uint16_t& hsyncend = {}, |
| const uint16_t& htotal = {}, |
| const uint16_t& hskew = {}, |
| const uint16_t& vdisplay = {}, |
| const uint16_t& vsyncstart = {}, |
| const uint16_t& vsyncend = {}, |
| const uint16_t& vtotal = {}, |
| const ModeFlag& flags = {}, |
| const std::vector<uint8_t>& c_private = {}); |
| |
| struct GetViewPortRequest { |
| uint16_t screen{}; |
| }; |
| |
| struct GetViewPortReply { |
| uint16_t sequence{}; |
| uint32_t x{}; |
| uint32_t y{}; |
| }; |
| |
| using GetViewPortResponse = Response<GetViewPortReply>; |
| |
| Future<GetViewPortReply> GetViewPort(const GetViewPortRequest& request); |
| |
| Future<GetViewPortReply> GetViewPort(const uint16_t& screen = {}); |
| |
| struct SetViewPortRequest { |
| uint16_t screen{}; |
| uint32_t x{}; |
| uint32_t y{}; |
| }; |
| |
| using SetViewPortResponse = Response<void>; |
| |
| Future<void> SetViewPort(const SetViewPortRequest& request); |
| |
| Future<void> SetViewPort(const uint16_t& screen = {}, |
| const uint32_t& x = {}, |
| const uint32_t& y = {}); |
| |
| struct GetDotClocksRequest { |
| uint16_t screen{}; |
| }; |
| |
| struct GetDotClocksReply { |
| uint16_t sequence{}; |
| ClockFlag flags{}; |
| uint32_t clocks{}; |
| uint32_t maxclocks{}; |
| std::vector<uint32_t> clock{}; |
| }; |
| |
| using GetDotClocksResponse = Response<GetDotClocksReply>; |
| |
| Future<GetDotClocksReply> GetDotClocks(const GetDotClocksRequest& request); |
| |
| Future<GetDotClocksReply> GetDotClocks(const uint16_t& screen = {}); |
| |
| struct SetClientVersionRequest { |
| uint16_t major{}; |
| uint16_t minor{}; |
| }; |
| |
| using SetClientVersionResponse = Response<void>; |
| |
| Future<void> SetClientVersion(const SetClientVersionRequest& request); |
| |
| Future<void> SetClientVersion(const uint16_t& major = {}, |
| const uint16_t& minor = {}); |
| |
| struct SetGammaRequest { |
| uint16_t screen{}; |
| uint32_t red{}; |
| uint32_t green{}; |
| uint32_t blue{}; |
| }; |
| |
| using SetGammaResponse = Response<void>; |
| |
| Future<void> SetGamma(const SetGammaRequest& request); |
| |
| Future<void> SetGamma(const uint16_t& screen = {}, |
| const uint32_t& red = {}, |
| const uint32_t& green = {}, |
| const uint32_t& blue = {}); |
| |
| struct GetGammaRequest { |
| uint16_t screen{}; |
| }; |
| |
| struct GetGammaReply { |
| uint16_t sequence{}; |
| uint32_t red{}; |
| uint32_t green{}; |
| uint32_t blue{}; |
| }; |
| |
| using GetGammaResponse = Response<GetGammaReply>; |
| |
| Future<GetGammaReply> GetGamma(const GetGammaRequest& request); |
| |
| Future<GetGammaReply> GetGamma(const uint16_t& screen = {}); |
| |
| struct GetGammaRampRequest { |
| uint16_t screen{}; |
| uint16_t size{}; |
| }; |
| |
| struct GetGammaRampReply { |
| uint16_t sequence{}; |
| uint16_t size{}; |
| std::vector<uint16_t> red{}; |
| std::vector<uint16_t> green{}; |
| std::vector<uint16_t> blue{}; |
| }; |
| |
| using GetGammaRampResponse = Response<GetGammaRampReply>; |
| |
| Future<GetGammaRampReply> GetGammaRamp(const GetGammaRampRequest& request); |
| |
| Future<GetGammaRampReply> GetGammaRamp(const uint16_t& screen = {}, |
| const uint16_t& size = {}); |
| |
| struct SetGammaRampRequest { |
| uint16_t screen{}; |
| uint16_t size{}; |
| std::vector<uint16_t> red{}; |
| std::vector<uint16_t> green{}; |
| std::vector<uint16_t> blue{}; |
| }; |
| |
| using SetGammaRampResponse = Response<void>; |
| |
| Future<void> SetGammaRamp(const SetGammaRampRequest& request); |
| |
| Future<void> SetGammaRamp(const uint16_t& screen = {}, |
| const uint16_t& size = {}, |
| const std::vector<uint16_t>& red = {}, |
| const std::vector<uint16_t>& green = {}, |
| const std::vector<uint16_t>& blue = {}); |
| |
| struct GetGammaRampSizeRequest { |
| uint16_t screen{}; |
| }; |
| |
| struct GetGammaRampSizeReply { |
| uint16_t sequence{}; |
| uint16_t size{}; |
| }; |
| |
| using GetGammaRampSizeResponse = Response<GetGammaRampSizeReply>; |
| |
| Future<GetGammaRampSizeReply> GetGammaRampSize( |
| const GetGammaRampSizeRequest& request); |
| |
| Future<GetGammaRampSizeReply> GetGammaRampSize(const uint16_t& screen = {}); |
| |
| struct GetPermissionsRequest { |
| uint16_t screen{}; |
| }; |
| |
| struct GetPermissionsReply { |
| uint16_t sequence{}; |
| Permission permissions{}; |
| }; |
| |
| using GetPermissionsResponse = Response<GetPermissionsReply>; |
| |
| Future<GetPermissionsReply> GetPermissions( |
| const GetPermissionsRequest& request); |
| |
| Future<GetPermissionsReply> GetPermissions(const uint16_t& screen = {}); |
| |
| private: |
| Connection* const connection_; |
| x11::QueryExtensionReply info_{}; |
| }; |
| |
| } // namespace x11 |
| |
| inline constexpr x11::XF86VidMode::ModeFlag operator|( |
| x11::XF86VidMode::ModeFlag l, |
| x11::XF86VidMode::ModeFlag r) { |
| using T = std::underlying_type_t<x11::XF86VidMode::ModeFlag>; |
| return static_cast<x11::XF86VidMode::ModeFlag>(static_cast<T>(l) | |
| static_cast<T>(r)); |
| } |
| |
| inline constexpr x11::XF86VidMode::ModeFlag operator&( |
| x11::XF86VidMode::ModeFlag l, |
| x11::XF86VidMode::ModeFlag r) { |
| using T = std::underlying_type_t<x11::XF86VidMode::ModeFlag>; |
| return static_cast<x11::XF86VidMode::ModeFlag>(static_cast<T>(l) & |
| static_cast<T>(r)); |
| } |
| |
| inline constexpr x11::XF86VidMode::ClockFlag operator|( |
| x11::XF86VidMode::ClockFlag l, |
| x11::XF86VidMode::ClockFlag r) { |
| using T = std::underlying_type_t<x11::XF86VidMode::ClockFlag>; |
| return static_cast<x11::XF86VidMode::ClockFlag>(static_cast<T>(l) | |
| static_cast<T>(r)); |
| } |
| |
| inline constexpr x11::XF86VidMode::ClockFlag operator&( |
| x11::XF86VidMode::ClockFlag l, |
| x11::XF86VidMode::ClockFlag r) { |
| using T = std::underlying_type_t<x11::XF86VidMode::ClockFlag>; |
| return static_cast<x11::XF86VidMode::ClockFlag>(static_cast<T>(l) & |
| static_cast<T>(r)); |
| } |
| |
| inline constexpr x11::XF86VidMode::Permission operator|( |
| x11::XF86VidMode::Permission l, |
| x11::XF86VidMode::Permission r) { |
| using T = std::underlying_type_t<x11::XF86VidMode::Permission>; |
| return static_cast<x11::XF86VidMode::Permission>(static_cast<T>(l) | |
| static_cast<T>(r)); |
| } |
| |
| inline constexpr x11::XF86VidMode::Permission operator&( |
| x11::XF86VidMode::Permission l, |
| x11::XF86VidMode::Permission r) { |
| using T = std::underlying_type_t<x11::XF86VidMode::Permission>; |
| return static_cast<x11::XF86VidMode::Permission>(static_cast<T>(l) & |
| static_cast<T>(r)); |
| } |
| |
| #endif // UI_GFX_X_GENERATED_PROTOS_XF86VIDMODE_H_ |