| // 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 |
| |
| #include "screensaver.h" |
| |
| #include <xcb/xcb.h> |
| #include <xcb/xcbext.h> |
| |
| #include "base/logging.h" |
| #include "base/posix/eintr_wrapper.h" |
| #include "ui/gfx/x/xproto_internal.h" |
| |
| namespace x11 { |
| |
| ScreenSaver::ScreenSaver(Connection* connection, |
| const x11::QueryExtensionReply& info) |
| : connection_(connection), info_(info) {} |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<ScreenSaver::NotifyEvent>(ScreenSaver::NotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& state = (*event_).state; |
| auto& sequence = (*event_).sequence; |
| auto& time = (*event_).time; |
| auto& root = (*event_).root; |
| auto& window = (*event_).window; |
| auto& kind = (*event_).kind; |
| auto& forced = (*event_).forced; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // state |
| uint8_t tmp0; |
| Read(&tmp0, &buf); |
| state = static_cast<ScreenSaver::State>(tmp0); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // time |
| Read(&time, &buf); |
| |
| // root |
| Read(&root, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // kind |
| uint8_t tmp1; |
| Read(&tmp1, &buf); |
| kind = static_cast<ScreenSaver::Kind>(tmp1); |
| |
| // forced |
| Read(&forced, &buf); |
| |
| // pad0 |
| Pad(&buf, 14); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| Future<ScreenSaver::QueryVersionReply> ScreenSaver::QueryVersion( |
| const ScreenSaver::QueryVersionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& client_major_version = request.client_major_version; |
| auto& client_minor_version = request.client_minor_version; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 0; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // client_major_version |
| buf.Write(&client_major_version); |
| |
| // client_minor_version |
| buf.Write(&client_minor_version); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<ScreenSaver::QueryVersionReply>( |
| &buf, "ScreenSaver::QueryVersion", false); |
| } |
| |
| Future<ScreenSaver::QueryVersionReply> ScreenSaver::QueryVersion( |
| const uint8_t& client_major_version, |
| const uint8_t& client_minor_version) { |
| return ScreenSaver::QueryVersion(ScreenSaver::QueryVersionRequest{ |
| client_major_version, client_minor_version}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<ScreenSaver::QueryVersionReply> detail::ReadReply< |
| ScreenSaver::QueryVersionReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<ScreenSaver::QueryVersionReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& server_major_version = (*reply).server_major_version; |
| auto& server_minor_version = (*reply).server_minor_version; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // server_major_version |
| Read(&server_major_version, &buf); |
| |
| // server_minor_version |
| Read(&server_minor_version, &buf); |
| |
| // pad1 |
| Pad(&buf, 20); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<ScreenSaver::QueryInfoReply> ScreenSaver::QueryInfo( |
| const ScreenSaver::QueryInfoRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 1; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<ScreenSaver::QueryInfoReply>( |
| &buf, "ScreenSaver::QueryInfo", false); |
| } |
| |
| Future<ScreenSaver::QueryInfoReply> ScreenSaver::QueryInfo( |
| const Drawable& drawable) { |
| return ScreenSaver::QueryInfo(ScreenSaver::QueryInfoRequest{drawable}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<ScreenSaver::QueryInfoReply> detail::ReadReply< |
| ScreenSaver::QueryInfoReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<ScreenSaver::QueryInfoReply>(); |
| |
| auto& state = (*reply).state; |
| auto& sequence = (*reply).sequence; |
| auto& saver_window = (*reply).saver_window; |
| auto& ms_until_server = (*reply).ms_until_server; |
| auto& ms_since_user_input = (*reply).ms_since_user_input; |
| auto& event_mask = (*reply).event_mask; |
| auto& kind = (*reply).kind; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // state |
| Read(&state, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // saver_window |
| Read(&saver_window, &buf); |
| |
| // ms_until_server |
| Read(&ms_until_server, &buf); |
| |
| // ms_since_user_input |
| Read(&ms_since_user_input, &buf); |
| |
| // event_mask |
| Read(&event_mask, &buf); |
| |
| // kind |
| uint8_t tmp2; |
| Read(&tmp2, &buf); |
| kind = static_cast<ScreenSaver::Kind>(tmp2); |
| |
| // pad0 |
| Pad(&buf, 7); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> ScreenSaver::SelectInput( |
| const ScreenSaver::SelectInputRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| auto& event_mask = request.event_mask; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 2; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // event_mask |
| uint32_t tmp3; |
| tmp3 = static_cast<uint32_t>(event_mask); |
| buf.Write(&tmp3); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ScreenSaver::SelectInput", |
| false); |
| } |
| |
| Future<void> ScreenSaver::SelectInput(const Drawable& drawable, |
| const Event& event_mask) { |
| return ScreenSaver::SelectInput( |
| ScreenSaver::SelectInputRequest{drawable, event_mask}); |
| } |
| |
| Future<void> ScreenSaver::SetAttributes( |
| const ScreenSaver::SetAttributesRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| auto& x = request.x; |
| auto& y = request.y; |
| auto& width = request.width; |
| auto& height = request.height; |
| auto& border_width = request.border_width; |
| auto& c_class = request.c_class; |
| auto& depth = request.depth; |
| auto& visual = request.visual; |
| CreateWindowAttribute value_mask{}; |
| auto& value_list = request; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 3; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| |
| // border_width |
| buf.Write(&border_width); |
| |
| // c_class |
| uint8_t tmp4; |
| tmp4 = static_cast<uint8_t>(c_class); |
| buf.Write(&tmp4); |
| |
| // depth |
| buf.Write(&depth); |
| |
| // visual |
| buf.Write(&visual); |
| |
| // value_mask |
| SwitchVar(CreateWindowAttribute::BackPixmap, |
| value_list.background_pixmap.has_value(), true, &value_mask); |
| SwitchVar(CreateWindowAttribute::BackPixel, |
| value_list.background_pixel.has_value(), true, &value_mask); |
| SwitchVar(CreateWindowAttribute::BorderPixmap, |
| value_list.border_pixmap.has_value(), true, &value_mask); |
| SwitchVar(CreateWindowAttribute::BorderPixel, |
| value_list.border_pixel.has_value(), true, &value_mask); |
| SwitchVar(CreateWindowAttribute::BitGravity, |
| value_list.bit_gravity.has_value(), true, &value_mask); |
| SwitchVar(CreateWindowAttribute::WinGravity, |
| value_list.win_gravity.has_value(), true, &value_mask); |
| SwitchVar(CreateWindowAttribute::BackingStore, |
| value_list.backing_store.has_value(), true, &value_mask); |
| SwitchVar(CreateWindowAttribute::BackingPlanes, |
| value_list.backing_planes.has_value(), true, &value_mask); |
| SwitchVar(CreateWindowAttribute::BackingPixel, |
| value_list.backing_pixel.has_value(), true, &value_mask); |
| SwitchVar(CreateWindowAttribute::OverrideRedirect, |
| value_list.override_redirect.has_value(), true, &value_mask); |
| SwitchVar(CreateWindowAttribute::SaveUnder, value_list.save_under.has_value(), |
| true, &value_mask); |
| SwitchVar(CreateWindowAttribute::EventMask, value_list.event_mask.has_value(), |
| true, &value_mask); |
| SwitchVar(CreateWindowAttribute::DontPropagate, |
| value_list.do_not_propogate_mask.has_value(), true, &value_mask); |
| SwitchVar(CreateWindowAttribute::Colormap, value_list.colormap.has_value(), |
| true, &value_mask); |
| SwitchVar(CreateWindowAttribute::Cursor, value_list.cursor.has_value(), true, |
| &value_mask); |
| uint32_t tmp5; |
| tmp5 = static_cast<uint32_t>(value_mask); |
| buf.Write(&tmp5); |
| |
| // value_list |
| auto value_list_expr = value_mask; |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::BackPixmap)) { |
| auto& background_pixmap = *value_list.background_pixmap; |
| |
| // background_pixmap |
| buf.Write(&background_pixmap); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::BackPixel)) { |
| auto& background_pixel = *value_list.background_pixel; |
| |
| // background_pixel |
| buf.Write(&background_pixel); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::BorderPixmap)) { |
| auto& border_pixmap = *value_list.border_pixmap; |
| |
| // border_pixmap |
| buf.Write(&border_pixmap); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::BorderPixel)) { |
| auto& border_pixel = *value_list.border_pixel; |
| |
| // border_pixel |
| buf.Write(&border_pixel); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::BitGravity)) { |
| auto& bit_gravity = *value_list.bit_gravity; |
| |
| // bit_gravity |
| uint32_t tmp6; |
| tmp6 = static_cast<uint32_t>(bit_gravity); |
| buf.Write(&tmp6); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::WinGravity)) { |
| auto& win_gravity = *value_list.win_gravity; |
| |
| // win_gravity |
| uint32_t tmp7; |
| tmp7 = static_cast<uint32_t>(win_gravity); |
| buf.Write(&tmp7); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingStore)) { |
| auto& backing_store = *value_list.backing_store; |
| |
| // backing_store |
| uint32_t tmp8; |
| tmp8 = static_cast<uint32_t>(backing_store); |
| buf.Write(&tmp8); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingPlanes)) { |
| auto& backing_planes = *value_list.backing_planes; |
| |
| // backing_planes |
| buf.Write(&backing_planes); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingPixel)) { |
| auto& backing_pixel = *value_list.backing_pixel; |
| |
| // backing_pixel |
| buf.Write(&backing_pixel); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::OverrideRedirect)) { |
| auto& override_redirect = *value_list.override_redirect; |
| |
| // override_redirect |
| buf.Write(&override_redirect); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::SaveUnder)) { |
| auto& save_under = *value_list.save_under; |
| |
| // save_under |
| buf.Write(&save_under); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::EventMask)) { |
| auto& event_mask = *value_list.event_mask; |
| |
| // event_mask |
| uint32_t tmp9; |
| tmp9 = static_cast<uint32_t>(event_mask); |
| buf.Write(&tmp9); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::DontPropagate)) { |
| auto& do_not_propogate_mask = *value_list.do_not_propogate_mask; |
| |
| // do_not_propogate_mask |
| uint32_t tmp10; |
| tmp10 = static_cast<uint32_t>(do_not_propogate_mask); |
| buf.Write(&tmp10); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::Colormap)) { |
| auto& colormap = *value_list.colormap; |
| |
| // colormap |
| buf.Write(&colormap); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::Cursor)) { |
| auto& cursor = *value_list.cursor; |
| |
| // cursor |
| buf.Write(&cursor); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ScreenSaver::SetAttributes", |
| false); |
| } |
| |
| Future<void> ScreenSaver::SetAttributes( |
| const Drawable& drawable, |
| const int16_t& x, |
| const int16_t& y, |
| const uint16_t& width, |
| const uint16_t& height, |
| const uint16_t& border_width, |
| const WindowClass& c_class, |
| const uint8_t& depth, |
| const VisualId& visual, |
| const absl::optional<Pixmap>& background_pixmap, |
| const absl::optional<uint32_t>& background_pixel, |
| const absl::optional<Pixmap>& border_pixmap, |
| const absl::optional<uint32_t>& border_pixel, |
| const absl::optional<Gravity>& bit_gravity, |
| const absl::optional<Gravity>& win_gravity, |
| const absl::optional<BackingStore>& backing_store, |
| const absl::optional<uint32_t>& backing_planes, |
| const absl::optional<uint32_t>& backing_pixel, |
| const absl::optional<Bool32>& override_redirect, |
| const absl::optional<Bool32>& save_under, |
| const absl::optional<EventMask>& event_mask, |
| const absl::optional<EventMask>& do_not_propogate_mask, |
| const absl::optional<ColorMap>& colormap, |
| const absl::optional<Cursor>& cursor) { |
| return ScreenSaver::SetAttributes( |
| ScreenSaver::SetAttributesRequest{drawable, |
| x, |
| y, |
| width, |
| height, |
| border_width, |
| c_class, |
| depth, |
| visual, |
| background_pixmap, |
| background_pixel, |
| border_pixmap, |
| border_pixel, |
| bit_gravity, |
| win_gravity, |
| backing_store, |
| backing_planes, |
| backing_pixel, |
| override_redirect, |
| save_under, |
| event_mask, |
| do_not_propogate_mask, |
| colormap, |
| cursor}); |
| } |
| |
| Future<void> ScreenSaver::UnsetAttributes( |
| const ScreenSaver::UnsetAttributesRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 4; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ScreenSaver::UnsetAttributes", |
| false); |
| } |
| |
| Future<void> ScreenSaver::UnsetAttributes(const Drawable& drawable) { |
| return ScreenSaver::UnsetAttributes( |
| ScreenSaver::UnsetAttributesRequest{drawable}); |
| } |
| |
| Future<void> ScreenSaver::Suspend(const ScreenSaver::SuspendRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& suspend = request.suspend; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 5; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // suspend |
| buf.Write(&suspend); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ScreenSaver::Suspend", false); |
| } |
| |
| Future<void> ScreenSaver::Suspend(const uint32_t& suspend) { |
| return ScreenSaver::Suspend(ScreenSaver::SuspendRequest{suspend}); |
| } |
| |
| } // namespace x11 |