| // 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 "xfixes.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 { |
| |
| XFixes::XFixes(Connection* connection, const x11::QueryExtensionReply& info) |
| : connection_(connection), info_(info) {} |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<XFixes::SelectionNotifyEvent>( |
| XFixes::SelectionNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& subtype = (*event_).subtype; |
| auto& sequence = (*event_).sequence; |
| auto& window = (*event_).window; |
| auto& owner = (*event_).owner; |
| auto& selection = (*event_).selection; |
| auto& timestamp = (*event_).timestamp; |
| auto& selection_timestamp = (*event_).selection_timestamp; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // subtype |
| uint8_t tmp0; |
| Read(&tmp0, &buf); |
| subtype = static_cast<XFixes::SelectionEvent>(tmp0); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // owner |
| Read(&owner, &buf); |
| |
| // selection |
| Read(&selection, &buf); |
| |
| // timestamp |
| Read(×tamp, &buf); |
| |
| // selection_timestamp |
| Read(&selection_timestamp, &buf); |
| |
| // pad0 |
| Pad(&buf, 8); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<XFixes::CursorNotifyEvent>(XFixes::CursorNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& subtype = (*event_).subtype; |
| auto& sequence = (*event_).sequence; |
| auto& window = (*event_).window; |
| auto& cursor_serial = (*event_).cursor_serial; |
| auto& timestamp = (*event_).timestamp; |
| auto& name = (*event_).name; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // subtype |
| uint8_t tmp1; |
| Read(&tmp1, &buf); |
| subtype = static_cast<XFixes::CursorNotify>(tmp1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // cursor_serial |
| Read(&cursor_serial, &buf); |
| |
| // timestamp |
| Read(×tamp, &buf); |
| |
| // name |
| Read(&name, &buf); |
| |
| // pad0 |
| Pad(&buf, 12); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| std::string XFixes::BadRegionError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "XFixes::BadRegionError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<XFixes::BadRegionError>(XFixes::BadRegionError* error_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| Future<XFixes::QueryVersionReply> XFixes::QueryVersion( |
| const XFixes::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); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<XFixes::QueryVersionReply>( |
| &buf, "XFixes::QueryVersion", false); |
| } |
| |
| Future<XFixes::QueryVersionReply> XFixes::QueryVersion( |
| const uint32_t& client_major_version, |
| const uint32_t& client_minor_version) { |
| return XFixes::QueryVersion( |
| XFixes::QueryVersionRequest{client_major_version, client_minor_version}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<XFixes::QueryVersionReply> detail::ReadReply< |
| XFixes::QueryVersionReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<XFixes::QueryVersionReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& major_version = (*reply).major_version; |
| auto& minor_version = (*reply).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); |
| |
| // major_version |
| Read(&major_version, &buf); |
| |
| // minor_version |
| Read(&minor_version, &buf); |
| |
| // pad1 |
| Pad(&buf, 16); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XFixes::ChangeSaveSet( |
| const XFixes::ChangeSaveSetRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& mode = request.mode; |
| auto& target = request.target; |
| auto& map = request.map; |
| auto& window = request.window; |
| |
| // 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)); |
| |
| // mode |
| uint8_t tmp2; |
| tmp2 = static_cast<uint8_t>(mode); |
| buf.Write(&tmp2); |
| |
| // target |
| uint8_t tmp3; |
| tmp3 = static_cast<uint8_t>(target); |
| buf.Write(&tmp3); |
| |
| // map |
| uint8_t tmp4; |
| tmp4 = static_cast<uint8_t>(map); |
| buf.Write(&tmp4); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::ChangeSaveSet", false); |
| } |
| |
| Future<void> XFixes::ChangeSaveSet(const SaveSetMode& mode, |
| const SaveSetTarget& target, |
| const SaveSetMapping& map, |
| const Window& window) { |
| return XFixes::ChangeSaveSet( |
| XFixes::ChangeSaveSetRequest{mode, target, map, window}); |
| } |
| |
| Future<void> XFixes::SelectSelectionInput( |
| const XFixes::SelectSelectionInputRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| auto& selection = request.selection; |
| 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)); |
| |
| // window |
| buf.Write(&window); |
| |
| // selection |
| buf.Write(&selection); |
| |
| // event_mask |
| uint32_t tmp5; |
| tmp5 = static_cast<uint32_t>(event_mask); |
| buf.Write(&tmp5); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::SelectSelectionInput", |
| false); |
| } |
| |
| Future<void> XFixes::SelectSelectionInput( |
| const Window& window, |
| const Atom& selection, |
| const SelectionEventMask& event_mask) { |
| return XFixes::SelectSelectionInput( |
| XFixes::SelectSelectionInputRequest{window, selection, event_mask}); |
| } |
| |
| Future<void> XFixes::SelectCursorInput( |
| const XFixes::SelectCursorInputRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| 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 = 3; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| // event_mask |
| uint32_t tmp6; |
| tmp6 = static_cast<uint32_t>(event_mask); |
| buf.Write(&tmp6); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::SelectCursorInput", |
| false); |
| } |
| |
| Future<void> XFixes::SelectCursorInput(const Window& window, |
| const CursorNotifyMask& event_mask) { |
| return XFixes::SelectCursorInput( |
| XFixes::SelectCursorInputRequest{window, event_mask}); |
| } |
| |
| Future<XFixes::GetCursorImageReply> XFixes::GetCursorImage( |
| const XFixes::GetCursorImageRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // 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)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<XFixes::GetCursorImageReply>( |
| &buf, "XFixes::GetCursorImage", false); |
| } |
| |
| Future<XFixes::GetCursorImageReply> XFixes::GetCursorImage() { |
| return XFixes::GetCursorImage(XFixes::GetCursorImageRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<XFixes::GetCursorImageReply> detail::ReadReply< |
| XFixes::GetCursorImageReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<XFixes::GetCursorImageReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& x = (*reply).x; |
| auto& y = (*reply).y; |
| auto& width = (*reply).width; |
| auto& height = (*reply).height; |
| auto& xhot = (*reply).xhot; |
| auto& yhot = (*reply).yhot; |
| auto& cursor_serial = (*reply).cursor_serial; |
| auto& cursor_image = (*reply).cursor_image; |
| size_t cursor_image_len = cursor_image.size(); |
| |
| // 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); |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| |
| // width |
| Read(&width, &buf); |
| |
| // height |
| Read(&height, &buf); |
| |
| // xhot |
| Read(&xhot, &buf); |
| |
| // yhot |
| Read(&yhot, &buf); |
| |
| // cursor_serial |
| Read(&cursor_serial, &buf); |
| |
| // pad1 |
| Pad(&buf, 8); |
| |
| // cursor_image |
| cursor_image.resize((width) * (height)); |
| for (auto& cursor_image_elem : cursor_image) { |
| // cursor_image_elem |
| Read(&cursor_image_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XFixes::CreateRegion(const XFixes::CreateRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& region = request.region; |
| auto& rectangles = request.rectangles; |
| size_t rectangles_len = rectangles.size(); |
| |
| // 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)); |
| |
| // region |
| buf.Write(®ion); |
| |
| // rectangles |
| DCHECK_EQ(static_cast<size_t>(rectangles_len), rectangles.size()); |
| for (auto& rectangles_elem : rectangles) { |
| // rectangles_elem |
| { |
| auto& x = rectangles_elem.x; |
| auto& y = rectangles_elem.y; |
| auto& width = rectangles_elem.width; |
| auto& height = rectangles_elem.height; |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::CreateRegion", false); |
| } |
| |
| Future<void> XFixes::CreateRegion(const Region& region, |
| const std::vector<Rectangle>& rectangles) { |
| return XFixes::CreateRegion(XFixes::CreateRegionRequest{region, rectangles}); |
| } |
| |
| Future<void> XFixes::CreateRegionFromBitmap( |
| const XFixes::CreateRegionFromBitmapRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& region = request.region; |
| auto& bitmap = request.bitmap; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 6; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // region |
| buf.Write(®ion); |
| |
| // bitmap |
| buf.Write(&bitmap); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::CreateRegionFromBitmap", |
| false); |
| } |
| |
| Future<void> XFixes::CreateRegionFromBitmap(const Region& region, |
| const Pixmap& bitmap) { |
| return XFixes::CreateRegionFromBitmap( |
| XFixes::CreateRegionFromBitmapRequest{region, bitmap}); |
| } |
| |
| Future<void> XFixes::CreateRegionFromWindow( |
| const XFixes::CreateRegionFromWindowRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& region = request.region; |
| auto& window = request.window; |
| auto& kind = request.kind; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 7; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // region |
| buf.Write(®ion); |
| |
| // window |
| buf.Write(&window); |
| |
| // kind |
| uint8_t tmp7; |
| tmp7 = static_cast<uint8_t>(kind); |
| buf.Write(&tmp7); |
| |
| // pad0 |
| Pad(&buf, 3); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::CreateRegionFromWindow", |
| false); |
| } |
| |
| Future<void> XFixes::CreateRegionFromWindow(const Region& region, |
| const Window& window, |
| const Shape::Sk& kind) { |
| return XFixes::CreateRegionFromWindow( |
| XFixes::CreateRegionFromWindowRequest{region, window, kind}); |
| } |
| |
| Future<void> XFixes::CreateRegionFromGC( |
| const XFixes::CreateRegionFromGCRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& region = request.region; |
| auto& gc = request.gc; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 8; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // region |
| buf.Write(®ion); |
| |
| // gc |
| buf.Write(&gc); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::CreateRegionFromGC", |
| false); |
| } |
| |
| Future<void> XFixes::CreateRegionFromGC(const Region& region, |
| const GraphicsContext& gc) { |
| return XFixes::CreateRegionFromGC( |
| XFixes::CreateRegionFromGCRequest{region, gc}); |
| } |
| |
| Future<void> XFixes::CreateRegionFromPicture( |
| const XFixes::CreateRegionFromPictureRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& region = request.region; |
| auto& picture = request.picture; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 9; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // region |
| buf.Write(®ion); |
| |
| // picture |
| buf.Write(&picture); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::CreateRegionFromPicture", |
| false); |
| } |
| |
| Future<void> XFixes::CreateRegionFromPicture(const Region& region, |
| const Render::Picture& picture) { |
| return XFixes::CreateRegionFromPicture( |
| XFixes::CreateRegionFromPictureRequest{region, picture}); |
| } |
| |
| Future<void> XFixes::DestroyRegion( |
| const XFixes::DestroyRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& region = request.region; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 10; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // region |
| buf.Write(®ion); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::DestroyRegion", false); |
| } |
| |
| Future<void> XFixes::DestroyRegion(const Region& region) { |
| return XFixes::DestroyRegion(XFixes::DestroyRegionRequest{region}); |
| } |
| |
| Future<void> XFixes::SetRegion(const XFixes::SetRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& region = request.region; |
| auto& rectangles = request.rectangles; |
| size_t rectangles_len = rectangles.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 11; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // region |
| buf.Write(®ion); |
| |
| // rectangles |
| DCHECK_EQ(static_cast<size_t>(rectangles_len), rectangles.size()); |
| for (auto& rectangles_elem : rectangles) { |
| // rectangles_elem |
| { |
| auto& x = rectangles_elem.x; |
| auto& y = rectangles_elem.y; |
| auto& width = rectangles_elem.width; |
| auto& height = rectangles_elem.height; |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::SetRegion", false); |
| } |
| |
| Future<void> XFixes::SetRegion(const Region& region, |
| const std::vector<Rectangle>& rectangles) { |
| return XFixes::SetRegion(XFixes::SetRegionRequest{region, rectangles}); |
| } |
| |
| Future<void> XFixes::CopyRegion(const XFixes::CopyRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& source = request.source; |
| auto& destination = request.destination; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 12; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // source |
| buf.Write(&source); |
| |
| // destination |
| buf.Write(&destination); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::CopyRegion", false); |
| } |
| |
| Future<void> XFixes::CopyRegion(const Region& source, |
| const Region& destination) { |
| return XFixes::CopyRegion(XFixes::CopyRegionRequest{source, destination}); |
| } |
| |
| Future<void> XFixes::UnionRegion(const XFixes::UnionRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& source1 = request.source1; |
| auto& source2 = request.source2; |
| auto& destination = request.destination; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 13; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // source1 |
| buf.Write(&source1); |
| |
| // source2 |
| buf.Write(&source2); |
| |
| // destination |
| buf.Write(&destination); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::UnionRegion", false); |
| } |
| |
| Future<void> XFixes::UnionRegion(const Region& source1, |
| const Region& source2, |
| const Region& destination) { |
| return XFixes::UnionRegion( |
| XFixes::UnionRegionRequest{source1, source2, destination}); |
| } |
| |
| Future<void> XFixes::IntersectRegion( |
| const XFixes::IntersectRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& source1 = request.source1; |
| auto& source2 = request.source2; |
| auto& destination = request.destination; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 14; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // source1 |
| buf.Write(&source1); |
| |
| // source2 |
| buf.Write(&source2); |
| |
| // destination |
| buf.Write(&destination); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::IntersectRegion", false); |
| } |
| |
| Future<void> XFixes::IntersectRegion(const Region& source1, |
| const Region& source2, |
| const Region& destination) { |
| return XFixes::IntersectRegion( |
| XFixes::IntersectRegionRequest{source1, source2, destination}); |
| } |
| |
| Future<void> XFixes::SubtractRegion( |
| const XFixes::SubtractRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& source1 = request.source1; |
| auto& source2 = request.source2; |
| auto& destination = request.destination; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 15; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // source1 |
| buf.Write(&source1); |
| |
| // source2 |
| buf.Write(&source2); |
| |
| // destination |
| buf.Write(&destination); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::SubtractRegion", false); |
| } |
| |
| Future<void> XFixes::SubtractRegion(const Region& source1, |
| const Region& source2, |
| const Region& destination) { |
| return XFixes::SubtractRegion( |
| XFixes::SubtractRegionRequest{source1, source2, destination}); |
| } |
| |
| Future<void> XFixes::InvertRegion(const XFixes::InvertRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& source = request.source; |
| auto& bounds = request.bounds; |
| auto& destination = request.destination; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 16; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // source |
| buf.Write(&source); |
| |
| // bounds |
| { |
| auto& x = bounds.x; |
| auto& y = bounds.y; |
| auto& width = bounds.width; |
| auto& height = bounds.height; |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| } |
| |
| // destination |
| buf.Write(&destination); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::InvertRegion", false); |
| } |
| |
| Future<void> XFixes::InvertRegion(const Region& source, |
| const Rectangle& bounds, |
| const Region& destination) { |
| return XFixes::InvertRegion( |
| XFixes::InvertRegionRequest{source, bounds, destination}); |
| } |
| |
| Future<void> XFixes::TranslateRegion( |
| const XFixes::TranslateRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& region = request.region; |
| auto& dx = request.dx; |
| auto& dy = request.dy; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 17; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // region |
| buf.Write(®ion); |
| |
| // dx |
| buf.Write(&dx); |
| |
| // dy |
| buf.Write(&dy); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::TranslateRegion", false); |
| } |
| |
| Future<void> XFixes::TranslateRegion(const Region& region, |
| const int16_t& dx, |
| const int16_t& dy) { |
| return XFixes::TranslateRegion( |
| XFixes::TranslateRegionRequest{region, dx, dy}); |
| } |
| |
| Future<void> XFixes::RegionExtents( |
| const XFixes::RegionExtentsRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& source = request.source; |
| auto& destination = request.destination; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 18; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // source |
| buf.Write(&source); |
| |
| // destination |
| buf.Write(&destination); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::RegionExtents", false); |
| } |
| |
| Future<void> XFixes::RegionExtents(const Region& source, |
| const Region& destination) { |
| return XFixes::RegionExtents( |
| XFixes::RegionExtentsRequest{source, destination}); |
| } |
| |
| Future<XFixes::FetchRegionReply> XFixes::FetchRegion( |
| const XFixes::FetchRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& region = request.region; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 19; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // region |
| buf.Write(®ion); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<XFixes::FetchRegionReply>( |
| &buf, "XFixes::FetchRegion", false); |
| } |
| |
| Future<XFixes::FetchRegionReply> XFixes::FetchRegion(const Region& region) { |
| return XFixes::FetchRegion(XFixes::FetchRegionRequest{region}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<XFixes::FetchRegionReply> detail::ReadReply< |
| XFixes::FetchRegionReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<XFixes::FetchRegionReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& extents = (*reply).extents; |
| auto& rectangles = (*reply).rectangles; |
| size_t rectangles_len = rectangles.size(); |
| |
| // 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); |
| |
| // extents |
| { |
| auto& x = extents.x; |
| auto& y = extents.y; |
| auto& width = extents.width; |
| auto& height = extents.height; |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| |
| // width |
| Read(&width, &buf); |
| |
| // height |
| Read(&height, &buf); |
| } |
| |
| // pad1 |
| Pad(&buf, 16); |
| |
| // rectangles |
| rectangles.resize((length) / (2)); |
| for (auto& rectangles_elem : rectangles) { |
| // rectangles_elem |
| { |
| auto& x = rectangles_elem.x; |
| auto& y = rectangles_elem.y; |
| auto& width = rectangles_elem.width; |
| auto& height = rectangles_elem.height; |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| |
| // width |
| Read(&width, &buf); |
| |
| // height |
| Read(&height, &buf); |
| } |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XFixes::SetGCClipRegion( |
| const XFixes::SetGCClipRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& gc = request.gc; |
| auto& region = request.region; |
| auto& x_origin = request.x_origin; |
| auto& y_origin = request.y_origin; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 20; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // region |
| buf.Write(®ion); |
| |
| // x_origin |
| buf.Write(&x_origin); |
| |
| // y_origin |
| buf.Write(&y_origin); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::SetGCClipRegion", false); |
| } |
| |
| Future<void> XFixes::SetGCClipRegion(const GraphicsContext& gc, |
| const Region& region, |
| const int16_t& x_origin, |
| const int16_t& y_origin) { |
| return XFixes::SetGCClipRegion( |
| XFixes::SetGCClipRegionRequest{gc, region, x_origin, y_origin}); |
| } |
| |
| Future<void> XFixes::SetWindowShapeRegion( |
| const XFixes::SetWindowShapeRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& dest = request.dest; |
| auto& dest_kind = request.dest_kind; |
| auto& x_offset = request.x_offset; |
| auto& y_offset = request.y_offset; |
| auto& region = request.region; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 21; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // dest |
| buf.Write(&dest); |
| |
| // dest_kind |
| uint8_t tmp8; |
| tmp8 = static_cast<uint8_t>(dest_kind); |
| buf.Write(&tmp8); |
| |
| // pad0 |
| Pad(&buf, 3); |
| |
| // x_offset |
| buf.Write(&x_offset); |
| |
| // y_offset |
| buf.Write(&y_offset); |
| |
| // region |
| buf.Write(®ion); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::SetWindowShapeRegion", |
| false); |
| } |
| |
| Future<void> XFixes::SetWindowShapeRegion(const Window& dest, |
| const Shape::Sk& dest_kind, |
| const int16_t& x_offset, |
| const int16_t& y_offset, |
| const Region& region) { |
| return XFixes::SetWindowShapeRegion(XFixes::SetWindowShapeRegionRequest{ |
| dest, dest_kind, x_offset, y_offset, region}); |
| } |
| |
| Future<void> XFixes::SetPictureClipRegion( |
| const XFixes::SetPictureClipRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& picture = request.picture; |
| auto& region = request.region; |
| auto& x_origin = request.x_origin; |
| auto& y_origin = request.y_origin; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 22; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // picture |
| buf.Write(&picture); |
| |
| // region |
| buf.Write(®ion); |
| |
| // x_origin |
| buf.Write(&x_origin); |
| |
| // y_origin |
| buf.Write(&y_origin); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::SetPictureClipRegion", |
| false); |
| } |
| |
| Future<void> XFixes::SetPictureClipRegion(const Render::Picture& picture, |
| const Region& region, |
| const int16_t& x_origin, |
| const int16_t& y_origin) { |
| return XFixes::SetPictureClipRegion( |
| XFixes::SetPictureClipRegionRequest{picture, region, x_origin, y_origin}); |
| } |
| |
| Future<void> XFixes::SetCursorName( |
| const XFixes::SetCursorNameRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cursor = request.cursor; |
| uint16_t nbytes{}; |
| auto& name = request.name; |
| size_t name_len = name.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 23; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cursor |
| buf.Write(&cursor); |
| |
| // nbytes |
| nbytes = name.size(); |
| buf.Write(&nbytes); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| // name |
| DCHECK_EQ(static_cast<size_t>(nbytes), name.size()); |
| for (auto& name_elem : name) { |
| // name_elem |
| buf.Write(&name_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::SetCursorName", false); |
| } |
| |
| Future<void> XFixes::SetCursorName(const Cursor& cursor, |
| const std::string& name) { |
| return XFixes::SetCursorName(XFixes::SetCursorNameRequest{cursor, name}); |
| } |
| |
| Future<XFixes::GetCursorNameReply> XFixes::GetCursorName( |
| const XFixes::GetCursorNameRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cursor = request.cursor; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 24; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cursor |
| buf.Write(&cursor); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<XFixes::GetCursorNameReply>( |
| &buf, "XFixes::GetCursorName", false); |
| } |
| |
| Future<XFixes::GetCursorNameReply> XFixes::GetCursorName(const Cursor& cursor) { |
| return XFixes::GetCursorName(XFixes::GetCursorNameRequest{cursor}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<XFixes::GetCursorNameReply> detail::ReadReply< |
| XFixes::GetCursorNameReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<XFixes::GetCursorNameReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& atom = (*reply).atom; |
| uint16_t nbytes{}; |
| auto& name = (*reply).name; |
| size_t name_len = name.size(); |
| |
| // 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); |
| |
| // atom |
| Read(&atom, &buf); |
| |
| // nbytes |
| Read(&nbytes, &buf); |
| |
| // pad1 |
| Pad(&buf, 18); |
| |
| // name |
| name.resize(nbytes); |
| for (auto& name_elem : name) { |
| // name_elem |
| Read(&name_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<XFixes::GetCursorImageAndNameReply> XFixes::GetCursorImageAndName( |
| const XFixes::GetCursorImageAndNameRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 25; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<XFixes::GetCursorImageAndNameReply>( |
| &buf, "XFixes::GetCursorImageAndName", false); |
| } |
| |
| Future<XFixes::GetCursorImageAndNameReply> XFixes::GetCursorImageAndName() { |
| return XFixes::GetCursorImageAndName(XFixes::GetCursorImageAndNameRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<XFixes::GetCursorImageAndNameReply> detail::ReadReply< |
| XFixes::GetCursorImageAndNameReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<XFixes::GetCursorImageAndNameReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& x = (*reply).x; |
| auto& y = (*reply).y; |
| auto& width = (*reply).width; |
| auto& height = (*reply).height; |
| auto& xhot = (*reply).xhot; |
| auto& yhot = (*reply).yhot; |
| auto& cursor_serial = (*reply).cursor_serial; |
| auto& cursor_atom = (*reply).cursor_atom; |
| uint16_t nbytes{}; |
| auto& cursor_image = (*reply).cursor_image; |
| size_t cursor_image_len = cursor_image.size(); |
| auto& name = (*reply).name; |
| size_t name_len = name.size(); |
| |
| // 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); |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| |
| // width |
| Read(&width, &buf); |
| |
| // height |
| Read(&height, &buf); |
| |
| // xhot |
| Read(&xhot, &buf); |
| |
| // yhot |
| Read(&yhot, &buf); |
| |
| // cursor_serial |
| Read(&cursor_serial, &buf); |
| |
| // cursor_atom |
| Read(&cursor_atom, &buf); |
| |
| // nbytes |
| Read(&nbytes, &buf); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| // cursor_image |
| cursor_image.resize((width) * (height)); |
| for (auto& cursor_image_elem : cursor_image) { |
| // cursor_image_elem |
| Read(&cursor_image_elem, &buf); |
| } |
| |
| // name |
| name.resize(nbytes); |
| for (auto& name_elem : name) { |
| // name_elem |
| Read(&name_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XFixes::ChangeCursor(const XFixes::ChangeCursorRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& source = request.source; |
| auto& destination = request.destination; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 26; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // source |
| buf.Write(&source); |
| |
| // destination |
| buf.Write(&destination); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::ChangeCursor", false); |
| } |
| |
| Future<void> XFixes::ChangeCursor(const Cursor& source, |
| const Cursor& destination) { |
| return XFixes::ChangeCursor(XFixes::ChangeCursorRequest{source, destination}); |
| } |
| |
| Future<void> XFixes::ChangeCursorByName( |
| const XFixes::ChangeCursorByNameRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& src = request.src; |
| uint16_t nbytes{}; |
| auto& name = request.name; |
| size_t name_len = name.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 27; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // src |
| buf.Write(&src); |
| |
| // nbytes |
| nbytes = name.size(); |
| buf.Write(&nbytes); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| // name |
| DCHECK_EQ(static_cast<size_t>(nbytes), name.size()); |
| for (auto& name_elem : name) { |
| // name_elem |
| buf.Write(&name_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::ChangeCursorByName", |
| false); |
| } |
| |
| Future<void> XFixes::ChangeCursorByName(const Cursor& src, |
| const std::string& name) { |
| return XFixes::ChangeCursorByName( |
| XFixes::ChangeCursorByNameRequest{src, name}); |
| } |
| |
| Future<void> XFixes::ExpandRegion(const XFixes::ExpandRegionRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& source = request.source; |
| auto& destination = request.destination; |
| auto& left = request.left; |
| auto& right = request.right; |
| auto& top = request.top; |
| auto& bottom = request.bottom; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 28; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // source |
| buf.Write(&source); |
| |
| // destination |
| buf.Write(&destination); |
| |
| // left |
| buf.Write(&left); |
| |
| // right |
| buf.Write(&right); |
| |
| // top |
| buf.Write(&top); |
| |
| // bottom |
| buf.Write(&bottom); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::ExpandRegion", false); |
| } |
| |
| Future<void> XFixes::ExpandRegion(const Region& source, |
| const Region& destination, |
| const uint16_t& left, |
| const uint16_t& right, |
| const uint16_t& top, |
| const uint16_t& bottom) { |
| return XFixes::ExpandRegion(XFixes::ExpandRegionRequest{ |
| source, destination, left, right, top, bottom}); |
| } |
| |
| Future<void> XFixes::HideCursor(const XFixes::HideCursorRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 29; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::HideCursor", false); |
| } |
| |
| Future<void> XFixes::HideCursor(const Window& window) { |
| return XFixes::HideCursor(XFixes::HideCursorRequest{window}); |
| } |
| |
| Future<void> XFixes::ShowCursor(const XFixes::ShowCursorRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 30; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::ShowCursor", false); |
| } |
| |
| Future<void> XFixes::ShowCursor(const Window& window) { |
| return XFixes::ShowCursor(XFixes::ShowCursorRequest{window}); |
| } |
| |
| Future<void> XFixes::CreatePointerBarrier( |
| const XFixes::CreatePointerBarrierRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& barrier = request.barrier; |
| auto& window = request.window; |
| auto& x1 = request.x1; |
| auto& y1 = request.y1; |
| auto& x2 = request.x2; |
| auto& y2 = request.y2; |
| auto& directions = request.directions; |
| uint16_t num_devices{}; |
| auto& devices = request.devices; |
| size_t devices_len = devices.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 31; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // barrier |
| buf.Write(&barrier); |
| |
| // window |
| buf.Write(&window); |
| |
| // x1 |
| buf.Write(&x1); |
| |
| // y1 |
| buf.Write(&y1); |
| |
| // x2 |
| buf.Write(&x2); |
| |
| // y2 |
| buf.Write(&y2); |
| |
| // directions |
| uint32_t tmp9; |
| tmp9 = static_cast<uint32_t>(directions); |
| buf.Write(&tmp9); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| // num_devices |
| num_devices = devices.size(); |
| buf.Write(&num_devices); |
| |
| // devices |
| DCHECK_EQ(static_cast<size_t>(num_devices), devices.size()); |
| for (auto& devices_elem : devices) { |
| // devices_elem |
| buf.Write(&devices_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::CreatePointerBarrier", |
| false); |
| } |
| |
| Future<void> XFixes::CreatePointerBarrier( |
| const Barrier& barrier, |
| const Window& window, |
| const uint16_t& x1, |
| const uint16_t& y1, |
| const uint16_t& x2, |
| const uint16_t& y2, |
| const BarrierDirections& directions, |
| const std::vector<uint16_t>& devices) { |
| return XFixes::CreatePointerBarrier(XFixes::CreatePointerBarrierRequest{ |
| barrier, window, x1, y1, x2, y2, directions, devices}); |
| } |
| |
| Future<void> XFixes::DeletePointerBarrier( |
| const XFixes::DeletePointerBarrierRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& barrier = request.barrier; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 32; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // barrier |
| buf.Write(&barrier); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "XFixes::DeletePointerBarrier", |
| false); |
| } |
| |
| Future<void> XFixes::DeletePointerBarrier(const Barrier& barrier) { |
| return XFixes::DeletePointerBarrier( |
| XFixes::DeletePointerBarrierRequest{barrier}); |
| } |
| |
| } // namespace x11 |