| // 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 "xproto.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 { |
| |
| XProto::XProto(Connection* connection) : connection_(connection) {} |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| Setup Read<Setup>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| Setup obj; |
| |
| auto& status = obj.status; |
| auto& protocol_major_version = obj.protocol_major_version; |
| auto& protocol_minor_version = obj.protocol_minor_version; |
| auto& length = obj.length; |
| auto& release_number = obj.release_number; |
| auto& resource_id_base = obj.resource_id_base; |
| auto& resource_id_mask = obj.resource_id_mask; |
| auto& motion_buffer_size = obj.motion_buffer_size; |
| uint16_t vendor_len{}; |
| auto& maximum_request_length = obj.maximum_request_length; |
| uint8_t roots_len{}; |
| uint8_t pixmap_formats_len{}; |
| auto& image_byte_order = obj.image_byte_order; |
| auto& bitmap_format_bit_order = obj.bitmap_format_bit_order; |
| auto& bitmap_format_scanline_unit = obj.bitmap_format_scanline_unit; |
| auto& bitmap_format_scanline_pad = obj.bitmap_format_scanline_pad; |
| auto& min_keycode = obj.min_keycode; |
| auto& max_keycode = obj.max_keycode; |
| auto& vendor = obj.vendor; |
| auto& pixmap_formats = obj.pixmap_formats; |
| auto& roots = obj.roots; |
| |
| // status |
| Read(&status, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // protocol_major_version |
| Read(&protocol_major_version, &buf); |
| |
| // protocol_minor_version |
| Read(&protocol_minor_version, &buf); |
| |
| // length |
| Read(&length, &buf); |
| |
| // release_number |
| Read(&release_number, &buf); |
| |
| // resource_id_base |
| Read(&resource_id_base, &buf); |
| |
| // resource_id_mask |
| Read(&resource_id_mask, &buf); |
| |
| // motion_buffer_size |
| Read(&motion_buffer_size, &buf); |
| |
| // vendor_len |
| Read(&vendor_len, &buf); |
| |
| // maximum_request_length |
| Read(&maximum_request_length, &buf); |
| |
| // roots_len |
| Read(&roots_len, &buf); |
| |
| // pixmap_formats_len |
| Read(&pixmap_formats_len, &buf); |
| |
| // image_byte_order |
| uint8_t tmp0; |
| Read(&tmp0, &buf); |
| image_byte_order = static_cast<ImageOrder>(tmp0); |
| |
| // bitmap_format_bit_order |
| uint8_t tmp1; |
| Read(&tmp1, &buf); |
| bitmap_format_bit_order = static_cast<ImageOrder>(tmp1); |
| |
| // bitmap_format_scanline_unit |
| Read(&bitmap_format_scanline_unit, &buf); |
| |
| // bitmap_format_scanline_pad |
| Read(&bitmap_format_scanline_pad, &buf); |
| |
| // min_keycode |
| Read(&min_keycode, &buf); |
| |
| // max_keycode |
| Read(&max_keycode, &buf); |
| |
| // pad1 |
| Pad(&buf, 4); |
| |
| // vendor |
| vendor.resize(vendor_len); |
| for (auto& vendor_elem : vendor) { |
| // vendor_elem |
| Read(&vendor_elem, &buf); |
| } |
| |
| // pad2 |
| Align(&buf, 4); |
| |
| // pixmap_formats |
| pixmap_formats.resize(pixmap_formats_len); |
| for (auto& pixmap_formats_elem : pixmap_formats) { |
| // pixmap_formats_elem |
| { |
| auto& depth = pixmap_formats_elem.depth; |
| auto& bits_per_pixel = pixmap_formats_elem.bits_per_pixel; |
| auto& scanline_pad = pixmap_formats_elem.scanline_pad; |
| |
| // depth |
| Read(&depth, &buf); |
| |
| // bits_per_pixel |
| Read(&bits_per_pixel, &buf); |
| |
| // scanline_pad |
| Read(&scanline_pad, &buf); |
| |
| // pad0 |
| Pad(&buf, 5); |
| } |
| } |
| |
| // roots |
| roots.resize(roots_len); |
| for (auto& roots_elem : roots) { |
| // roots_elem |
| { |
| auto& root = roots_elem.root; |
| auto& default_colormap = roots_elem.default_colormap; |
| auto& white_pixel = roots_elem.white_pixel; |
| auto& black_pixel = roots_elem.black_pixel; |
| auto& current_input_masks = roots_elem.current_input_masks; |
| auto& width_in_pixels = roots_elem.width_in_pixels; |
| auto& height_in_pixels = roots_elem.height_in_pixels; |
| auto& width_in_millimeters = roots_elem.width_in_millimeters; |
| auto& height_in_millimeters = roots_elem.height_in_millimeters; |
| auto& min_installed_maps = roots_elem.min_installed_maps; |
| auto& max_installed_maps = roots_elem.max_installed_maps; |
| auto& root_visual = roots_elem.root_visual; |
| auto& backing_stores = roots_elem.backing_stores; |
| auto& save_unders = roots_elem.save_unders; |
| auto& root_depth = roots_elem.root_depth; |
| uint8_t allowed_depths_len{}; |
| auto& allowed_depths = roots_elem.allowed_depths; |
| |
| // root |
| Read(&root, &buf); |
| |
| // default_colormap |
| Read(&default_colormap, &buf); |
| |
| // white_pixel |
| Read(&white_pixel, &buf); |
| |
| // black_pixel |
| Read(&black_pixel, &buf); |
| |
| // current_input_masks |
| uint32_t tmp2; |
| Read(&tmp2, &buf); |
| current_input_masks = static_cast<EventMask>(tmp2); |
| |
| // width_in_pixels |
| Read(&width_in_pixels, &buf); |
| |
| // height_in_pixels |
| Read(&height_in_pixels, &buf); |
| |
| // width_in_millimeters |
| Read(&width_in_millimeters, &buf); |
| |
| // height_in_millimeters |
| Read(&height_in_millimeters, &buf); |
| |
| // min_installed_maps |
| Read(&min_installed_maps, &buf); |
| |
| // max_installed_maps |
| Read(&max_installed_maps, &buf); |
| |
| // root_visual |
| Read(&root_visual, &buf); |
| |
| // backing_stores |
| uint8_t tmp3; |
| Read(&tmp3, &buf); |
| backing_stores = static_cast<BackingStore>(tmp3); |
| |
| // save_unders |
| Read(&save_unders, &buf); |
| |
| // root_depth |
| Read(&root_depth, &buf); |
| |
| // allowed_depths_len |
| Read(&allowed_depths_len, &buf); |
| |
| // allowed_depths |
| allowed_depths.resize(allowed_depths_len); |
| for (auto& allowed_depths_elem : allowed_depths) { |
| // allowed_depths_elem |
| { |
| auto& depth = allowed_depths_elem.depth; |
| uint16_t visuals_len{}; |
| auto& visuals = allowed_depths_elem.visuals; |
| |
| // depth |
| Read(&depth, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // visuals_len |
| Read(&visuals_len, &buf); |
| |
| // pad1 |
| Pad(&buf, 4); |
| |
| // visuals |
| visuals.resize(visuals_len); |
| for (auto& visuals_elem : visuals) { |
| // visuals_elem |
| { |
| auto& visual_id = visuals_elem.visual_id; |
| auto& c_class = visuals_elem.c_class; |
| auto& bits_per_rgb_value = visuals_elem.bits_per_rgb_value; |
| auto& colormap_entries = visuals_elem.colormap_entries; |
| auto& red_mask = visuals_elem.red_mask; |
| auto& green_mask = visuals_elem.green_mask; |
| auto& blue_mask = visuals_elem.blue_mask; |
| |
| // visual_id |
| Read(&visual_id, &buf); |
| |
| // c_class |
| uint8_t tmp4; |
| Read(&tmp4, &buf); |
| c_class = static_cast<VisualClass>(tmp4); |
| |
| // bits_per_rgb_value |
| Read(&bits_per_rgb_value, &buf); |
| |
| // colormap_entries |
| Read(&colormap_entries, &buf); |
| |
| // red_mask |
| Read(&red_mask, &buf); |
| |
| // green_mask |
| Read(&green_mask, &buf); |
| |
| // blue_mask |
| Read(&blue_mask, &buf); |
| |
| // pad0 |
| Pad(&buf, 4); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return obj; |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| WriteBuffer Write<KeyEvent>(const KeyEvent& obj) { |
| WriteBuffer buf; |
| |
| auto& detail = obj.detail; |
| auto& sequence = obj.sequence; |
| auto& time = obj.time; |
| auto& root = obj.root; |
| auto& event = obj.event; |
| auto& child = obj.child; |
| auto& root_x = obj.root_x; |
| auto& root_y = obj.root_y; |
| auto& event_x = obj.event_x; |
| auto& event_y = obj.event_y; |
| auto& state = obj.state; |
| auto& same_screen = obj.same_screen; |
| |
| // response_type |
| uint8_t response_type = obj.opcode; |
| buf.Write(&response_type); |
| |
| // detail |
| buf.Write(&detail); |
| |
| // sequence |
| buf.Write(&sequence); |
| |
| // time |
| buf.Write(&time); |
| |
| // root |
| buf.Write(&root); |
| |
| // event |
| buf.Write(&event); |
| |
| // child |
| buf.Write(&child); |
| |
| // root_x |
| buf.Write(&root_x); |
| |
| // root_y |
| buf.Write(&root_y); |
| |
| // event_x |
| buf.Write(&event_x); |
| |
| // event_y |
| buf.Write(&event_y); |
| |
| // state |
| uint16_t tmp5; |
| tmp5 = static_cast<uint16_t>(state); |
| buf.Write(&tmp5); |
| |
| // same_screen |
| buf.Write(&same_screen); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| return buf; |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<KeyEvent>(KeyEvent* event_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& detail = (*event_).detail; |
| auto& sequence = (*event_).sequence; |
| auto& time = (*event_).time; |
| auto& root = (*event_).root; |
| auto& event = (*event_).event; |
| auto& child = (*event_).child; |
| auto& root_x = (*event_).root_x; |
| auto& root_y = (*event_).root_y; |
| auto& event_x = (*event_).event_x; |
| auto& event_y = (*event_).event_y; |
| auto& state = (*event_).state; |
| auto& same_screen = (*event_).same_screen; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // detail |
| Read(&detail, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // time |
| Read(&time, &buf); |
| |
| // root |
| Read(&root, &buf); |
| |
| // event |
| Read(&event, &buf); |
| |
| // child |
| Read(&child, &buf); |
| |
| // root_x |
| Read(&root_x, &buf); |
| |
| // root_y |
| Read(&root_y, &buf); |
| |
| // event_x |
| Read(&event_x, &buf); |
| |
| // event_y |
| Read(&event_y, &buf); |
| |
| // state |
| uint16_t tmp6; |
| Read(&tmp6, &buf); |
| state = static_cast<KeyButMask>(tmp6); |
| |
| // same_screen |
| Read(&same_screen, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| WriteBuffer Write<ButtonEvent>(const ButtonEvent& obj) { |
| WriteBuffer buf; |
| |
| auto& detail = obj.detail; |
| auto& sequence = obj.sequence; |
| auto& time = obj.time; |
| auto& root = obj.root; |
| auto& event = obj.event; |
| auto& child = obj.child; |
| auto& root_x = obj.root_x; |
| auto& root_y = obj.root_y; |
| auto& event_x = obj.event_x; |
| auto& event_y = obj.event_y; |
| auto& state = obj.state; |
| auto& same_screen = obj.same_screen; |
| |
| // response_type |
| uint8_t response_type = obj.opcode; |
| buf.Write(&response_type); |
| |
| // detail |
| buf.Write(&detail); |
| |
| // sequence |
| buf.Write(&sequence); |
| |
| // time |
| buf.Write(&time); |
| |
| // root |
| buf.Write(&root); |
| |
| // event |
| buf.Write(&event); |
| |
| // child |
| buf.Write(&child); |
| |
| // root_x |
| buf.Write(&root_x); |
| |
| // root_y |
| buf.Write(&root_y); |
| |
| // event_x |
| buf.Write(&event_x); |
| |
| // event_y |
| buf.Write(&event_y); |
| |
| // state |
| uint16_t tmp7; |
| tmp7 = static_cast<uint16_t>(state); |
| buf.Write(&tmp7); |
| |
| // same_screen |
| buf.Write(&same_screen); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| return buf; |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<ButtonEvent>(ButtonEvent* event_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& detail = (*event_).detail; |
| auto& sequence = (*event_).sequence; |
| auto& time = (*event_).time; |
| auto& root = (*event_).root; |
| auto& event = (*event_).event; |
| auto& child = (*event_).child; |
| auto& root_x = (*event_).root_x; |
| auto& root_y = (*event_).root_y; |
| auto& event_x = (*event_).event_x; |
| auto& event_y = (*event_).event_y; |
| auto& state = (*event_).state; |
| auto& same_screen = (*event_).same_screen; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // detail |
| Read(&detail, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // time |
| Read(&time, &buf); |
| |
| // root |
| Read(&root, &buf); |
| |
| // event |
| Read(&event, &buf); |
| |
| // child |
| Read(&child, &buf); |
| |
| // root_x |
| Read(&root_x, &buf); |
| |
| // root_y |
| Read(&root_y, &buf); |
| |
| // event_x |
| Read(&event_x, &buf); |
| |
| // event_y |
| Read(&event_y, &buf); |
| |
| // state |
| uint16_t tmp8; |
| Read(&tmp8, &buf); |
| state = static_cast<KeyButMask>(tmp8); |
| |
| // same_screen |
| Read(&same_screen, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| WriteBuffer Write<MotionNotifyEvent>(const MotionNotifyEvent& obj) { |
| WriteBuffer buf; |
| |
| auto& detail = obj.detail; |
| auto& sequence = obj.sequence; |
| auto& time = obj.time; |
| auto& root = obj.root; |
| auto& event = obj.event; |
| auto& child = obj.child; |
| auto& root_x = obj.root_x; |
| auto& root_y = obj.root_y; |
| auto& event_x = obj.event_x; |
| auto& event_y = obj.event_y; |
| auto& state = obj.state; |
| auto& same_screen = obj.same_screen; |
| |
| // response_type |
| uint8_t response_type = 6; |
| buf.Write(&response_type); |
| |
| // detail |
| uint8_t tmp9; |
| tmp9 = static_cast<uint8_t>(detail); |
| buf.Write(&tmp9); |
| |
| // sequence |
| buf.Write(&sequence); |
| |
| // time |
| buf.Write(&time); |
| |
| // root |
| buf.Write(&root); |
| |
| // event |
| buf.Write(&event); |
| |
| // child |
| buf.Write(&child); |
| |
| // root_x |
| buf.Write(&root_x); |
| |
| // root_y |
| buf.Write(&root_y); |
| |
| // event_x |
| buf.Write(&event_x); |
| |
| // event_y |
| buf.Write(&event_y); |
| |
| // state |
| uint16_t tmp10; |
| tmp10 = static_cast<uint16_t>(state); |
| buf.Write(&tmp10); |
| |
| // same_screen |
| buf.Write(&same_screen); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| return buf; |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<MotionNotifyEvent>(MotionNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& detail = (*event_).detail; |
| auto& sequence = (*event_).sequence; |
| auto& time = (*event_).time; |
| auto& root = (*event_).root; |
| auto& event = (*event_).event; |
| auto& child = (*event_).child; |
| auto& root_x = (*event_).root_x; |
| auto& root_y = (*event_).root_y; |
| auto& event_x = (*event_).event_x; |
| auto& event_y = (*event_).event_y; |
| auto& state = (*event_).state; |
| auto& same_screen = (*event_).same_screen; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // detail |
| uint8_t tmp11; |
| Read(&tmp11, &buf); |
| detail = static_cast<Motion>(tmp11); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // time |
| Read(&time, &buf); |
| |
| // root |
| Read(&root, &buf); |
| |
| // event |
| Read(&event, &buf); |
| |
| // child |
| Read(&child, &buf); |
| |
| // root_x |
| Read(&root_x, &buf); |
| |
| // root_y |
| Read(&root_y, &buf); |
| |
| // event_x |
| Read(&event_x, &buf); |
| |
| // event_y |
| Read(&event_y, &buf); |
| |
| // state |
| uint16_t tmp12; |
| Read(&tmp12, &buf); |
| state = static_cast<KeyButMask>(tmp12); |
| |
| // same_screen |
| Read(&same_screen, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<CrossingEvent>(CrossingEvent* event_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& detail = (*event_).detail; |
| auto& sequence = (*event_).sequence; |
| auto& time = (*event_).time; |
| auto& root = (*event_).root; |
| auto& event = (*event_).event; |
| auto& child = (*event_).child; |
| auto& root_x = (*event_).root_x; |
| auto& root_y = (*event_).root_y; |
| auto& event_x = (*event_).event_x; |
| auto& event_y = (*event_).event_y; |
| auto& state = (*event_).state; |
| auto& mode = (*event_).mode; |
| auto& same_screen_focus = (*event_).same_screen_focus; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // detail |
| uint8_t tmp13; |
| Read(&tmp13, &buf); |
| detail = static_cast<NotifyDetail>(tmp13); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // time |
| Read(&time, &buf); |
| |
| // root |
| Read(&root, &buf); |
| |
| // event |
| Read(&event, &buf); |
| |
| // child |
| Read(&child, &buf); |
| |
| // root_x |
| Read(&root_x, &buf); |
| |
| // root_y |
| Read(&root_y, &buf); |
| |
| // event_x |
| Read(&event_x, &buf); |
| |
| // event_y |
| Read(&event_y, &buf); |
| |
| // state |
| uint16_t tmp14; |
| Read(&tmp14, &buf); |
| state = static_cast<KeyButMask>(tmp14); |
| |
| // mode |
| uint8_t tmp15; |
| Read(&tmp15, &buf); |
| mode = static_cast<NotifyMode>(tmp15); |
| |
| // same_screen_focus |
| Read(&same_screen_focus, &buf); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<FocusEvent>(FocusEvent* event_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& detail = (*event_).detail; |
| auto& sequence = (*event_).sequence; |
| auto& event = (*event_).event; |
| auto& mode = (*event_).mode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // detail |
| uint8_t tmp16; |
| Read(&tmp16, &buf); |
| detail = static_cast<NotifyDetail>(tmp16); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // event |
| Read(&event, &buf); |
| |
| // mode |
| uint8_t tmp17; |
| Read(&tmp17, &buf); |
| mode = static_cast<NotifyMode>(tmp17); |
| |
| // pad0 |
| Pad(&buf, 3); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<KeymapNotifyEvent>(KeymapNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& keys = (*event_).keys; |
| size_t keys_len = keys.size(); |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // keys |
| for (auto& keys_elem : keys) { |
| // keys_elem |
| Read(&keys_elem, &buf); |
| } |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| WriteBuffer Write<ExposeEvent>(const ExposeEvent& obj) { |
| WriteBuffer buf; |
| |
| auto& sequence = obj.sequence; |
| auto& window = obj.window; |
| auto& x = obj.x; |
| auto& y = obj.y; |
| auto& width = obj.width; |
| auto& height = obj.height; |
| auto& count = obj.count; |
| |
| // response_type |
| uint8_t response_type = 12; |
| buf.Write(&response_type); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| buf.Write(&sequence); |
| |
| // window |
| buf.Write(&window); |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| |
| // count |
| buf.Write(&count); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| return buf; |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<ExposeEvent>(ExposeEvent* event_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& window = (*event_).window; |
| auto& x = (*event_).x; |
| auto& y = (*event_).y; |
| auto& width = (*event_).width; |
| auto& height = (*event_).height; |
| auto& count = (*event_).count; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| |
| // width |
| Read(&width, &buf); |
| |
| // height |
| Read(&height, &buf); |
| |
| // count |
| Read(&count, &buf); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<GraphicsExposureEvent>(GraphicsExposureEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& drawable = (*event_).drawable; |
| auto& x = (*event_).x; |
| auto& y = (*event_).y; |
| auto& width = (*event_).width; |
| auto& height = (*event_).height; |
| auto& minor_opcode = (*event_).minor_opcode; |
| auto& count = (*event_).count; |
| auto& major_opcode = (*event_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // drawable |
| Read(&drawable, &buf); |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| |
| // width |
| Read(&width, &buf); |
| |
| // height |
| Read(&height, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // count |
| Read(&count, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad1 |
| Pad(&buf, 3); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<NoExposureEvent>(NoExposureEvent* event_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& drawable = (*event_).drawable; |
| auto& minor_opcode = (*event_).minor_opcode; |
| auto& major_opcode = (*event_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // drawable |
| Read(&drawable, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad1 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<VisibilityNotifyEvent>(VisibilityNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& window = (*event_).window; |
| auto& state = (*event_).state; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // state |
| uint8_t tmp18; |
| Read(&tmp18, &buf); |
| state = static_cast<Visibility>(tmp18); |
| |
| // pad1 |
| Pad(&buf, 3); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<CreateNotifyEvent>(CreateNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& parent = (*event_).parent; |
| auto& window = (*event_).window; |
| auto& x = (*event_).x; |
| auto& y = (*event_).y; |
| auto& width = (*event_).width; |
| auto& height = (*event_).height; |
| auto& border_width = (*event_).border_width; |
| auto& override_redirect = (*event_).override_redirect; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // parent |
| Read(&parent, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| |
| // width |
| Read(&width, &buf); |
| |
| // height |
| Read(&height, &buf); |
| |
| // border_width |
| Read(&border_width, &buf); |
| |
| // override_redirect |
| Read(&override_redirect, &buf); |
| |
| // pad1 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<DestroyNotifyEvent>(DestroyNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& event = (*event_).event; |
| auto& window = (*event_).window; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // event |
| Read(&event, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| WriteBuffer Write<UnmapNotifyEvent>(const UnmapNotifyEvent& obj) { |
| WriteBuffer buf; |
| |
| auto& sequence = obj.sequence; |
| auto& event = obj.event; |
| auto& window = obj.window; |
| auto& from_configure = obj.from_configure; |
| |
| // response_type |
| uint8_t response_type = 18; |
| buf.Write(&response_type); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| buf.Write(&sequence); |
| |
| // event |
| buf.Write(&event); |
| |
| // window |
| buf.Write(&window); |
| |
| // from_configure |
| buf.Write(&from_configure); |
| |
| // pad1 |
| Pad(&buf, 3); |
| |
| return buf; |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<UnmapNotifyEvent>(UnmapNotifyEvent* event_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& event = (*event_).event; |
| auto& window = (*event_).window; |
| auto& from_configure = (*event_).from_configure; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // event |
| Read(&event, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // from_configure |
| Read(&from_configure, &buf); |
| |
| // pad1 |
| Pad(&buf, 3); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<MapNotifyEvent>(MapNotifyEvent* event_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& event = (*event_).event; |
| auto& window = (*event_).window; |
| auto& override_redirect = (*event_).override_redirect; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // event |
| Read(&event, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // override_redirect |
| Read(&override_redirect, &buf); |
| |
| // pad1 |
| Pad(&buf, 3); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<MapRequestEvent>(MapRequestEvent* event_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& parent = (*event_).parent; |
| auto& window = (*event_).window; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // parent |
| Read(&parent, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<ReparentNotifyEvent>(ReparentNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& event = (*event_).event; |
| auto& window = (*event_).window; |
| auto& parent = (*event_).parent; |
| auto& x = (*event_).x; |
| auto& y = (*event_).y; |
| auto& override_redirect = (*event_).override_redirect; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // event |
| Read(&event, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // parent |
| Read(&parent, &buf); |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| |
| // override_redirect |
| Read(&override_redirect, &buf); |
| |
| // pad1 |
| Pad(&buf, 3); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<ConfigureNotifyEvent>(ConfigureNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& event = (*event_).event; |
| auto& window = (*event_).window; |
| auto& above_sibling = (*event_).above_sibling; |
| auto& x = (*event_).x; |
| auto& y = (*event_).y; |
| auto& width = (*event_).width; |
| auto& height = (*event_).height; |
| auto& border_width = (*event_).border_width; |
| auto& override_redirect = (*event_).override_redirect; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // event |
| Read(&event, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // above_sibling |
| Read(&above_sibling, &buf); |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| |
| // width |
| Read(&width, &buf); |
| |
| // height |
| Read(&height, &buf); |
| |
| // border_width |
| Read(&border_width, &buf); |
| |
| // override_redirect |
| Read(&override_redirect, &buf); |
| |
| // pad1 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<ConfigureRequestEvent>(ConfigureRequestEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& stack_mode = (*event_).stack_mode; |
| auto& sequence = (*event_).sequence; |
| auto& parent = (*event_).parent; |
| auto& window = (*event_).window; |
| auto& sibling = (*event_).sibling; |
| auto& x = (*event_).x; |
| auto& y = (*event_).y; |
| auto& width = (*event_).width; |
| auto& height = (*event_).height; |
| auto& border_width = (*event_).border_width; |
| auto& value_mask = (*event_).value_mask; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // stack_mode |
| uint8_t tmp19; |
| Read(&tmp19, &buf); |
| stack_mode = static_cast<StackMode>(tmp19); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // parent |
| Read(&parent, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // sibling |
| Read(&sibling, &buf); |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| |
| // width |
| Read(&width, &buf); |
| |
| // height |
| Read(&height, &buf); |
| |
| // border_width |
| Read(&border_width, &buf); |
| |
| // value_mask |
| uint16_t tmp20; |
| Read(&tmp20, &buf); |
| value_mask = static_cast<ConfigWindow>(tmp20); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<GravityNotifyEvent>(GravityNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& event = (*event_).event; |
| auto& window = (*event_).window; |
| auto& x = (*event_).x; |
| auto& y = (*event_).y; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // event |
| Read(&event, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<ResizeRequestEvent>(ResizeRequestEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& window = (*event_).window; |
| auto& width = (*event_).width; |
| auto& height = (*event_).height; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // width |
| Read(&width, &buf); |
| |
| // height |
| Read(&height, &buf); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<CirculateEvent>(CirculateEvent* event_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& event = (*event_).event; |
| auto& window = (*event_).window; |
| auto& place = (*event_).place; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // event |
| Read(&event, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // pad1 |
| Pad(&buf, 4); |
| |
| // place |
| uint8_t tmp21; |
| Read(&tmp21, &buf); |
| place = static_cast<Place>(tmp21); |
| |
| // pad2 |
| Pad(&buf, 3); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| WriteBuffer Write<PropertyNotifyEvent>(const PropertyNotifyEvent& obj) { |
| WriteBuffer buf; |
| |
| auto& sequence = obj.sequence; |
| auto& window = obj.window; |
| auto& atom = obj.atom; |
| auto& time = obj.time; |
| auto& state = obj.state; |
| |
| // response_type |
| uint8_t response_type = 28; |
| buf.Write(&response_type); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| buf.Write(&sequence); |
| |
| // window |
| buf.Write(&window); |
| |
| // atom |
| buf.Write(&atom); |
| |
| // time |
| buf.Write(&time); |
| |
| // state |
| uint8_t tmp22; |
| tmp22 = static_cast<uint8_t>(state); |
| buf.Write(&tmp22); |
| |
| // pad1 |
| Pad(&buf, 3); |
| |
| return buf; |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<PropertyNotifyEvent>(PropertyNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& window = (*event_).window; |
| auto& atom = (*event_).atom; |
| auto& time = (*event_).time; |
| auto& state = (*event_).state; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // atom |
| Read(&atom, &buf); |
| |
| // time |
| Read(&time, &buf); |
| |
| // state |
| uint8_t tmp23; |
| Read(&tmp23, &buf); |
| state = static_cast<Property>(tmp23); |
| |
| // pad1 |
| Pad(&buf, 3); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<SelectionClearEvent>(SelectionClearEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& time = (*event_).time; |
| auto& owner = (*event_).owner; |
| auto& selection = (*event_).selection; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // time |
| Read(&time, &buf); |
| |
| // owner |
| Read(&owner, &buf); |
| |
| // selection |
| Read(&selection, &buf); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<SelectionRequestEvent>(SelectionRequestEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& time = (*event_).time; |
| auto& owner = (*event_).owner; |
| auto& requestor = (*event_).requestor; |
| auto& selection = (*event_).selection; |
| auto& target = (*event_).target; |
| auto& property = (*event_).property; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // time |
| Read(&time, &buf); |
| |
| // owner |
| Read(&owner, &buf); |
| |
| // requestor |
| Read(&requestor, &buf); |
| |
| // selection |
| Read(&selection, &buf); |
| |
| // target |
| Read(&target, &buf); |
| |
| // property |
| Read(&property, &buf); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| WriteBuffer Write<SelectionNotifyEvent>(const SelectionNotifyEvent& obj) { |
| WriteBuffer buf; |
| |
| auto& sequence = obj.sequence; |
| auto& time = obj.time; |
| auto& requestor = obj.requestor; |
| auto& selection = obj.selection; |
| auto& target = obj.target; |
| auto& property = obj.property; |
| |
| // response_type |
| uint8_t response_type = 31; |
| buf.Write(&response_type); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| buf.Write(&sequence); |
| |
| // time |
| buf.Write(&time); |
| |
| // requestor |
| buf.Write(&requestor); |
| |
| // selection |
| buf.Write(&selection); |
| |
| // target |
| buf.Write(&target); |
| |
| // property |
| buf.Write(&property); |
| |
| return buf; |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<SelectionNotifyEvent>(SelectionNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& time = (*event_).time; |
| auto& requestor = (*event_).requestor; |
| auto& selection = (*event_).selection; |
| auto& target = (*event_).target; |
| auto& property = (*event_).property; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // time |
| Read(&time, &buf); |
| |
| // requestor |
| Read(&requestor, &buf); |
| |
| // selection |
| Read(&selection, &buf); |
| |
| // target |
| Read(&target, &buf); |
| |
| // property |
| Read(&property, &buf); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<ColormapNotifyEvent>(ColormapNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& window = (*event_).window; |
| auto& colormap = (*event_).colormap; |
| auto& c_new = (*event_).c_new; |
| auto& state = (*event_).state; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // colormap |
| Read(&colormap, &buf); |
| |
| // c_new |
| Read(&c_new, &buf); |
| |
| // state |
| uint8_t tmp24; |
| Read(&tmp24, &buf); |
| state = static_cast<ColormapState>(tmp24); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| WriteBuffer Write<ClientMessageEvent>(const ClientMessageEvent& obj) { |
| WriteBuffer buf; |
| |
| auto& format = obj.format; |
| auto& sequence = obj.sequence; |
| auto& window = obj.window; |
| auto& type = obj.type; |
| auto& data = obj.data; |
| |
| // response_type |
| uint8_t response_type = 33; |
| buf.Write(&response_type); |
| |
| // format |
| buf.Write(&format); |
| |
| // sequence |
| buf.Write(&sequence); |
| |
| // window |
| buf.Write(&window); |
| |
| // type |
| buf.Write(&type); |
| |
| // data |
| buf.Write(&data); |
| |
| return buf; |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<ClientMessageEvent>(ClientMessageEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& format = (*event_).format; |
| auto& sequence = (*event_).sequence; |
| auto& window = (*event_).window; |
| auto& type = (*event_).type; |
| auto& data = (*event_).data; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // format |
| Read(&format, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // window |
| Read(&window, &buf); |
| |
| // type |
| Read(&type, &buf); |
| |
| // data |
| Read(&data, &buf); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<MappingNotifyEvent>(MappingNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| auto& request = (*event_).request; |
| auto& first_keycode = (*event_).first_keycode; |
| auto& count = (*event_).count; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // request |
| uint8_t tmp25; |
| Read(&tmp25, &buf); |
| request = static_cast<Mapping>(tmp25); |
| |
| // first_keycode |
| Read(&first_keycode, &buf); |
| |
| // count |
| Read(&count, &buf); |
| |
| // pad1 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<GeGenericEvent>(GeGenericEvent* event_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*event_).sequence; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // extension |
| uint8_t extension; |
| Read(&extension, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // event_type |
| uint16_t event_type; |
| Read(&event_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 22); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset, 32 + 4 * length); |
| } |
| |
| std::string RequestError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "RequestError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<RequestError>(RequestError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string ValueError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "ValueError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<ValueError>(ValueError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string WindowError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "WindowError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<WindowError>(WindowError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string PixmapError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "PixmapError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<PixmapError>(PixmapError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string AtomError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "AtomError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<AtomError>(AtomError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string CursorError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "CursorError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<CursorError>(CursorError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string FontError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "FontError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<FontError>(FontError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string MatchError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "MatchError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<MatchError>(MatchError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string DrawableError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "DrawableError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<DrawableError>(DrawableError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string AccessError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "AccessError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<AccessError>(AccessError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string AllocError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "AllocError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<AllocError>(AllocError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string ColormapError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "ColormapError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<ColormapError>(ColormapError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string GContextError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "GContextError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<GContextError>(GContextError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string IDChoiceError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "IDChoiceError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<IDChoiceError>(IDChoiceError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string NameError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "NameError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<NameError>(NameError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string LengthError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "LengthError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<LengthError>(LengthError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string ImplementationError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "ImplementationError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<ImplementationError>(ImplementationError* error_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_value = (*error_).bad_value; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_value |
| Read(&bad_value, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| Future<void> XProto::CreateWindow(const CreateWindowRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& depth = request.depth; |
| auto& wid = request.wid; |
| auto& parent = request.parent; |
| 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& visual = request.visual; |
| CreateWindowAttribute value_mask{}; |
| auto& value_list = request; |
| |
| // major_opcode |
| uint8_t major_opcode = 1; |
| buf.Write(&major_opcode); |
| |
| // depth |
| buf.Write(&depth); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // wid |
| buf.Write(&wid); |
| |
| // parent |
| buf.Write(&parent); |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| |
| // border_width |
| buf.Write(&border_width); |
| |
| // c_class |
| uint16_t tmp26; |
| tmp26 = static_cast<uint16_t>(c_class); |
| buf.Write(&tmp26); |
| |
| // 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 tmp27; |
| tmp27 = static_cast<uint32_t>(value_mask); |
| buf.Write(&tmp27); |
| |
| // 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 tmp28; |
| tmp28 = static_cast<uint32_t>(bit_gravity); |
| buf.Write(&tmp28); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::WinGravity)) { |
| auto& win_gravity = *value_list.win_gravity; |
| |
| // win_gravity |
| uint32_t tmp29; |
| tmp29 = static_cast<uint32_t>(win_gravity); |
| buf.Write(&tmp29); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingStore)) { |
| auto& backing_store = *value_list.backing_store; |
| |
| // backing_store |
| uint32_t tmp30; |
| tmp30 = static_cast<uint32_t>(backing_store); |
| buf.Write(&tmp30); |
| } |
| 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 tmp31; |
| tmp31 = static_cast<uint32_t>(event_mask); |
| buf.Write(&tmp31); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::DontPropagate)) { |
| auto& do_not_propogate_mask = *value_list.do_not_propogate_mask; |
| |
| // do_not_propogate_mask |
| uint32_t tmp32; |
| tmp32 = static_cast<uint32_t>(do_not_propogate_mask); |
| buf.Write(&tmp32); |
| } |
| 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, "CreateWindow", false); |
| } |
| |
| Future<void> XProto::CreateWindow( |
| const uint8_t& depth, |
| const Window& wid, |
| const Window& parent, |
| 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 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 XProto::CreateWindow(CreateWindowRequest{depth, |
| wid, |
| parent, |
| x, |
| y, |
| width, |
| height, |
| border_width, |
| c_class, |
| 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> XProto::ChangeWindowAttributes( |
| const ChangeWindowAttributesRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| CreateWindowAttribute value_mask{}; |
| auto& value_list = request; |
| |
| // major_opcode |
| uint8_t major_opcode = 2; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| // 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 tmp33; |
| tmp33 = static_cast<uint32_t>(value_mask); |
| buf.Write(&tmp33); |
| |
| // 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 tmp34; |
| tmp34 = static_cast<uint32_t>(bit_gravity); |
| buf.Write(&tmp34); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::WinGravity)) { |
| auto& win_gravity = *value_list.win_gravity; |
| |
| // win_gravity |
| uint32_t tmp35; |
| tmp35 = static_cast<uint32_t>(win_gravity); |
| buf.Write(&tmp35); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingStore)) { |
| auto& backing_store = *value_list.backing_store; |
| |
| // backing_store |
| uint32_t tmp36; |
| tmp36 = static_cast<uint32_t>(backing_store); |
| buf.Write(&tmp36); |
| } |
| 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 tmp37; |
| tmp37 = static_cast<uint32_t>(event_mask); |
| buf.Write(&tmp37); |
| } |
| if (CaseAnd(value_list_expr, CreateWindowAttribute::DontPropagate)) { |
| auto& do_not_propogate_mask = *value_list.do_not_propogate_mask; |
| |
| // do_not_propogate_mask |
| uint32_t tmp38; |
| tmp38 = static_cast<uint32_t>(do_not_propogate_mask); |
| buf.Write(&tmp38); |
| } |
| 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, "ChangeWindowAttributes", false); |
| } |
| |
| Future<void> XProto::ChangeWindowAttributes( |
| const Window& window, |
| 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 XProto::ChangeWindowAttributes(ChangeWindowAttributesRequest{ |
| window, 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<GetWindowAttributesReply> XProto::GetWindowAttributes( |
| const GetWindowAttributesRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 3; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetWindowAttributesReply>( |
| &buf, "GetWindowAttributes", false); |
| } |
| |
| Future<GetWindowAttributesReply> XProto::GetWindowAttributes( |
| const Window& window) { |
| return XProto::GetWindowAttributes(GetWindowAttributesRequest{window}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetWindowAttributesReply> detail::ReadReply< |
| GetWindowAttributesReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetWindowAttributesReply>(); |
| |
| auto& backing_store = (*reply).backing_store; |
| auto& sequence = (*reply).sequence; |
| auto& visual = (*reply).visual; |
| auto& c_class = (*reply).c_class; |
| auto& bit_gravity = (*reply).bit_gravity; |
| auto& win_gravity = (*reply).win_gravity; |
| auto& backing_planes = (*reply).backing_planes; |
| auto& backing_pixel = (*reply).backing_pixel; |
| auto& save_under = (*reply).save_under; |
| auto& map_is_installed = (*reply).map_is_installed; |
| auto& map_state = (*reply).map_state; |
| auto& override_redirect = (*reply).override_redirect; |
| auto& colormap = (*reply).colormap; |
| auto& all_event_masks = (*reply).all_event_masks; |
| auto& your_event_mask = (*reply).your_event_mask; |
| auto& do_not_propagate_mask = (*reply).do_not_propagate_mask; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // backing_store |
| uint8_t tmp39; |
| Read(&tmp39, &buf); |
| backing_store = static_cast<BackingStore>(tmp39); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // visual |
| Read(&visual, &buf); |
| |
| // c_class |
| uint16_t tmp40; |
| Read(&tmp40, &buf); |
| c_class = static_cast<WindowClass>(tmp40); |
| |
| // bit_gravity |
| uint8_t tmp41; |
| Read(&tmp41, &buf); |
| bit_gravity = static_cast<Gravity>(tmp41); |
| |
| // win_gravity |
| uint8_t tmp42; |
| Read(&tmp42, &buf); |
| win_gravity = static_cast<Gravity>(tmp42); |
| |
| // backing_planes |
| Read(&backing_planes, &buf); |
| |
| // backing_pixel |
| Read(&backing_pixel, &buf); |
| |
| // save_under |
| Read(&save_under, &buf); |
| |
| // map_is_installed |
| Read(&map_is_installed, &buf); |
| |
| // map_state |
| uint8_t tmp43; |
| Read(&tmp43, &buf); |
| map_state = static_cast<MapState>(tmp43); |
| |
| // override_redirect |
| Read(&override_redirect, &buf); |
| |
| // colormap |
| Read(&colormap, &buf); |
| |
| // all_event_masks |
| uint32_t tmp44; |
| Read(&tmp44, &buf); |
| all_event_masks = static_cast<EventMask>(tmp44); |
| |
| // your_event_mask |
| uint32_t tmp45; |
| Read(&tmp45, &buf); |
| your_event_mask = static_cast<EventMask>(tmp45); |
| |
| // do_not_propagate_mask |
| uint16_t tmp46; |
| Read(&tmp46, &buf); |
| do_not_propagate_mask = static_cast<EventMask>(tmp46); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::DestroyWindow(const DestroyWindowRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 4; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "DestroyWindow", false); |
| } |
| |
| Future<void> XProto::DestroyWindow(const Window& window) { |
| return XProto::DestroyWindow(DestroyWindowRequest{window}); |
| } |
| |
| Future<void> XProto::DestroySubwindows( |
| const DestroySubwindowsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 5; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "DestroySubwindows", false); |
| } |
| |
| Future<void> XProto::DestroySubwindows(const Window& window) { |
| return XProto::DestroySubwindows(DestroySubwindowsRequest{window}); |
| } |
| |
| Future<void> XProto::ChangeSaveSet(const ChangeSaveSetRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& mode = request.mode; |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 6; |
| buf.Write(&major_opcode); |
| |
| // mode |
| uint8_t tmp47; |
| tmp47 = static_cast<uint8_t>(mode); |
| buf.Write(&tmp47); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ChangeSaveSet", false); |
| } |
| |
| Future<void> XProto::ChangeSaveSet(const SetMode& mode, const Window& window) { |
| return XProto::ChangeSaveSet(ChangeSaveSetRequest{mode, window}); |
| } |
| |
| Future<void> XProto::ReparentWindow(const ReparentWindowRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| auto& parent = request.parent; |
| auto& x = request.x; |
| auto& y = request.y; |
| |
| // major_opcode |
| uint8_t major_opcode = 7; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| // parent |
| buf.Write(&parent); |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ReparentWindow", false); |
| } |
| |
| Future<void> XProto::ReparentWindow(const Window& window, |
| const Window& parent, |
| const int16_t& x, |
| const int16_t& y) { |
| return XProto::ReparentWindow(ReparentWindowRequest{window, parent, x, y}); |
| } |
| |
| Future<void> XProto::MapWindow(const MapWindowRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 8; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "MapWindow", false); |
| } |
| |
| Future<void> XProto::MapWindow(const Window& window) { |
| return XProto::MapWindow(MapWindowRequest{window}); |
| } |
| |
| Future<void> XProto::MapSubwindows(const MapSubwindowsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 9; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "MapSubwindows", false); |
| } |
| |
| Future<void> XProto::MapSubwindows(const Window& window) { |
| return XProto::MapSubwindows(MapSubwindowsRequest{window}); |
| } |
| |
| Future<void> XProto::UnmapWindow(const UnmapWindowRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 10; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "UnmapWindow", false); |
| } |
| |
| Future<void> XProto::UnmapWindow(const Window& window) { |
| return XProto::UnmapWindow(UnmapWindowRequest{window}); |
| } |
| |
| Future<void> XProto::UnmapSubwindows(const UnmapSubwindowsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 11; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "UnmapSubwindows", false); |
| } |
| |
| Future<void> XProto::UnmapSubwindows(const Window& window) { |
| return XProto::UnmapSubwindows(UnmapSubwindowsRequest{window}); |
| } |
| |
| Future<void> XProto::ConfigureWindow(const ConfigureWindowRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| ConfigWindow value_mask{}; |
| auto& value_list = request; |
| |
| // major_opcode |
| uint8_t major_opcode = 12; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| // value_mask |
| SwitchVar(ConfigWindow::X, value_list.x.has_value(), true, &value_mask); |
| SwitchVar(ConfigWindow::Y, value_list.y.has_value(), true, &value_mask); |
| SwitchVar(ConfigWindow::Width, value_list.width.has_value(), true, |
| &value_mask); |
| SwitchVar(ConfigWindow::Height, value_list.height.has_value(), true, |
| &value_mask); |
| SwitchVar(ConfigWindow::BorderWidth, value_list.border_width.has_value(), |
| true, &value_mask); |
| SwitchVar(ConfigWindow::Sibling, value_list.sibling.has_value(), true, |
| &value_mask); |
| SwitchVar(ConfigWindow::StackMode, value_list.stack_mode.has_value(), true, |
| &value_mask); |
| uint16_t tmp48; |
| tmp48 = static_cast<uint16_t>(value_mask); |
| buf.Write(&tmp48); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| // value_list |
| auto value_list_expr = value_mask; |
| if (CaseAnd(value_list_expr, ConfigWindow::X)) { |
| auto& x = *value_list.x; |
| |
| // x |
| buf.Write(&x); |
| } |
| if (CaseAnd(value_list_expr, ConfigWindow::Y)) { |
| auto& y = *value_list.y; |
| |
| // y |
| buf.Write(&y); |
| } |
| if (CaseAnd(value_list_expr, ConfigWindow::Width)) { |
| auto& width = *value_list.width; |
| |
| // width |
| buf.Write(&width); |
| } |
| if (CaseAnd(value_list_expr, ConfigWindow::Height)) { |
| auto& height = *value_list.height; |
| |
| // height |
| buf.Write(&height); |
| } |
| if (CaseAnd(value_list_expr, ConfigWindow::BorderWidth)) { |
| auto& border_width = *value_list.border_width; |
| |
| // border_width |
| buf.Write(&border_width); |
| } |
| if (CaseAnd(value_list_expr, ConfigWindow::Sibling)) { |
| auto& sibling = *value_list.sibling; |
| |
| // sibling |
| buf.Write(&sibling); |
| } |
| if (CaseAnd(value_list_expr, ConfigWindow::StackMode)) { |
| auto& stack_mode = *value_list.stack_mode; |
| |
| // stack_mode |
| uint32_t tmp49; |
| tmp49 = static_cast<uint32_t>(stack_mode); |
| buf.Write(&tmp49); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ConfigureWindow", false); |
| } |
| |
| Future<void> XProto::ConfigureWindow( |
| const Window& window, |
| const absl::optional<int32_t>& x, |
| const absl::optional<int32_t>& y, |
| const absl::optional<uint32_t>& width, |
| const absl::optional<uint32_t>& height, |
| const absl::optional<uint32_t>& border_width, |
| const absl::optional<Window>& sibling, |
| const absl::optional<StackMode>& stack_mode) { |
| return XProto::ConfigureWindow(ConfigureWindowRequest{ |
| window, x, y, width, height, border_width, sibling, stack_mode}); |
| } |
| |
| Future<void> XProto::CirculateWindow(const CirculateWindowRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& direction = request.direction; |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 13; |
| buf.Write(&major_opcode); |
| |
| // direction |
| uint8_t tmp50; |
| tmp50 = static_cast<uint8_t>(direction); |
| buf.Write(&tmp50); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "CirculateWindow", false); |
| } |
| |
| Future<void> XProto::CirculateWindow(const Circulate& direction, |
| const Window& window) { |
| return XProto::CirculateWindow(CirculateWindowRequest{direction, window}); |
| } |
| |
| Future<GetGeometryReply> XProto::GetGeometry( |
| const GetGeometryRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| |
| // major_opcode |
| uint8_t major_opcode = 14; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetGeometryReply>(&buf, "GetGeometry", false); |
| } |
| |
| Future<GetGeometryReply> XProto::GetGeometry(const Drawable& drawable) { |
| return XProto::GetGeometry(GetGeometryRequest{drawable}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetGeometryReply> detail::ReadReply<GetGeometryReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetGeometryReply>(); |
| |
| auto& depth = (*reply).depth; |
| auto& sequence = (*reply).sequence; |
| auto& root = (*reply).root; |
| auto& x = (*reply).x; |
| auto& y = (*reply).y; |
| auto& width = (*reply).width; |
| auto& height = (*reply).height; |
| auto& border_width = (*reply).border_width; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // depth |
| Read(&depth, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // root |
| Read(&root, &buf); |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| |
| // width |
| Read(&width, &buf); |
| |
| // height |
| Read(&height, &buf); |
| |
| // border_width |
| Read(&border_width, &buf); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<QueryTreeReply> XProto::QueryTree(const QueryTreeRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 15; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<QueryTreeReply>(&buf, "QueryTree", false); |
| } |
| |
| Future<QueryTreeReply> XProto::QueryTree(const Window& window) { |
| return XProto::QueryTree(QueryTreeRequest{window}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<QueryTreeReply> detail::ReadReply<QueryTreeReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<QueryTreeReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& root = (*reply).root; |
| auto& parent = (*reply).parent; |
| uint16_t children_len{}; |
| auto& children = (*reply).children; |
| |
| // 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); |
| |
| // root |
| Read(&root, &buf); |
| |
| // parent |
| Read(&parent, &buf); |
| |
| // children_len |
| Read(&children_len, &buf); |
| |
| // pad1 |
| Pad(&buf, 14); |
| |
| // children |
| children.resize(children_len); |
| for (auto& children_elem : children) { |
| // children_elem |
| Read(&children_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<InternAtomReply> XProto::InternAtom(const InternAtomRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& only_if_exists = request.only_if_exists; |
| uint16_t name_len{}; |
| auto& name = request.name; |
| |
| // major_opcode |
| uint8_t major_opcode = 16; |
| buf.Write(&major_opcode); |
| |
| // only_if_exists |
| buf.Write(&only_if_exists); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // name_len |
| name_len = name.size(); |
| buf.Write(&name_len); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| // name |
| DCHECK_EQ(static_cast<size_t>(name_len), name.size()); |
| for (auto& name_elem : name) { |
| // name_elem |
| buf.Write(&name_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<InternAtomReply>(&buf, "InternAtom", false); |
| } |
| |
| Future<InternAtomReply> XProto::InternAtom(const uint8_t& only_if_exists, |
| const std::string& name) { |
| return XProto::InternAtom(InternAtomRequest{only_if_exists, name}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<InternAtomReply> detail::ReadReply<InternAtomReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<InternAtomReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& atom = (*reply).atom; |
| |
| // 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); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<GetAtomNameReply> XProto::GetAtomName( |
| const GetAtomNameRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& atom = request.atom; |
| |
| // major_opcode |
| uint8_t major_opcode = 17; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // atom |
| buf.Write(&atom); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetAtomNameReply>(&buf, "GetAtomName", false); |
| } |
| |
| Future<GetAtomNameReply> XProto::GetAtomName(const Atom& atom) { |
| return XProto::GetAtomName(GetAtomNameRequest{atom}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetAtomNameReply> detail::ReadReply<GetAtomNameReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetAtomNameReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| uint16_t name_len{}; |
| auto& name = (*reply).name; |
| |
| // 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); |
| |
| // name_len |
| Read(&name_len, &buf); |
| |
| // pad1 |
| Pad(&buf, 22); |
| |
| // name |
| name.resize(name_len); |
| 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> XProto::ChangeProperty(const ChangePropertyRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& mode = request.mode; |
| auto& window = request.window; |
| auto& property = request.property; |
| auto& type = request.type; |
| auto& format = request.format; |
| auto& data_len = request.data_len; |
| auto& data = request.data; |
| |
| // major_opcode |
| uint8_t major_opcode = 18; |
| buf.Write(&major_opcode); |
| |
| // mode |
| uint8_t tmp51; |
| tmp51 = static_cast<uint8_t>(mode); |
| buf.Write(&tmp51); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| // property |
| buf.Write(&property); |
| |
| // type |
| buf.Write(&type); |
| |
| // format |
| buf.Write(&format); |
| |
| // pad0 |
| Pad(&buf, 3); |
| |
| // data_len |
| buf.Write(&data_len); |
| |
| // data |
| buf.AppendBuffer(data, ((data_len) * (format)) / (8)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ChangeProperty", false); |
| } |
| |
| Future<void> XProto::ChangeProperty( |
| const PropMode& mode, |
| const Window& window, |
| const Atom& property, |
| const Atom& type, |
| const uint8_t& format, |
| const uint32_t& data_len, |
| const scoped_refptr<base::RefCountedMemory>& data) { |
| return XProto::ChangeProperty(ChangePropertyRequest{ |
| mode, window, property, type, format, data_len, data}); |
| } |
| |
| Future<void> XProto::DeleteProperty(const DeletePropertyRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| auto& property = request.property; |
| |
| // major_opcode |
| uint8_t major_opcode = 19; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| // property |
| buf.Write(&property); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "DeleteProperty", false); |
| } |
| |
| Future<void> XProto::DeleteProperty(const Window& window, |
| const Atom& property) { |
| return XProto::DeleteProperty(DeletePropertyRequest{window, property}); |
| } |
| |
| Future<GetPropertyReply> XProto::GetProperty( |
| const GetPropertyRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& c_delete = request.c_delete; |
| auto& window = request.window; |
| auto& property = request.property; |
| auto& type = request.type; |
| auto& long_offset = request.long_offset; |
| auto& long_length = request.long_length; |
| |
| // major_opcode |
| uint8_t major_opcode = 20; |
| buf.Write(&major_opcode); |
| |
| // c_delete |
| buf.Write(&c_delete); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| // property |
| buf.Write(&property); |
| |
| // type |
| buf.Write(&type); |
| |
| // long_offset |
| buf.Write(&long_offset); |
| |
| // long_length |
| buf.Write(&long_length); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetPropertyReply>(&buf, "GetProperty", false); |
| } |
| |
| Future<GetPropertyReply> XProto::GetProperty(const uint8_t& c_delete, |
| const Window& window, |
| const Atom& property, |
| const Atom& type, |
| const uint32_t& long_offset, |
| const uint32_t& long_length) { |
| return XProto::GetProperty(GetPropertyRequest{ |
| c_delete, window, property, type, long_offset, long_length}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetPropertyReply> detail::ReadReply<GetPropertyReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetPropertyReply>(); |
| |
| auto& format = (*reply).format; |
| auto& sequence = (*reply).sequence; |
| auto& type = (*reply).type; |
| auto& bytes_after = (*reply).bytes_after; |
| auto& value_len = (*reply).value_len; |
| auto& value = (*reply).value; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // format |
| Read(&format, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // type |
| Read(&type, &buf); |
| |
| // bytes_after |
| Read(&bytes_after, &buf); |
| |
| // value_len |
| Read(&value_len, &buf); |
| |
| // pad0 |
| Pad(&buf, 12); |
| |
| // value |
| value = buffer->ReadAndAdvance((value_len) * ((format) / (8))); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<ListPropertiesReply> XProto::ListProperties( |
| const ListPropertiesRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 21; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<ListPropertiesReply>(&buf, "ListProperties", |
| false); |
| } |
| |
| Future<ListPropertiesReply> XProto::ListProperties(const Window& window) { |
| return XProto::ListProperties(ListPropertiesRequest{window}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<ListPropertiesReply> detail::ReadReply<ListPropertiesReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<ListPropertiesReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| uint16_t atoms_len{}; |
| auto& atoms = (*reply).atoms; |
| |
| // 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); |
| |
| // atoms_len |
| Read(&atoms_len, &buf); |
| |
| // pad1 |
| Pad(&buf, 22); |
| |
| // atoms |
| atoms.resize(atoms_len); |
| for (auto& atoms_elem : atoms) { |
| // atoms_elem |
| Read(&atoms_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::SetSelectionOwner( |
| const SetSelectionOwnerRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& owner = request.owner; |
| auto& selection = request.selection; |
| auto& time = request.time; |
| |
| // major_opcode |
| uint8_t major_opcode = 22; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // owner |
| buf.Write(&owner); |
| |
| // selection |
| buf.Write(&selection); |
| |
| // time |
| buf.Write(&time); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "SetSelectionOwner", false); |
| } |
| |
| Future<void> XProto::SetSelectionOwner(const Window& owner, |
| const Atom& selection, |
| const Time& time) { |
| return XProto::SetSelectionOwner( |
| SetSelectionOwnerRequest{owner, selection, time}); |
| } |
| |
| Future<GetSelectionOwnerReply> XProto::GetSelectionOwner( |
| const GetSelectionOwnerRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& selection = request.selection; |
| |
| // major_opcode |
| uint8_t major_opcode = 23; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // selection |
| buf.Write(&selection); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetSelectionOwnerReply>( |
| &buf, "GetSelectionOwner", false); |
| } |
| |
| Future<GetSelectionOwnerReply> XProto::GetSelectionOwner( |
| const Atom& selection) { |
| return XProto::GetSelectionOwner(GetSelectionOwnerRequest{selection}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetSelectionOwnerReply> detail::ReadReply< |
| GetSelectionOwnerReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetSelectionOwnerReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& owner = (*reply).owner; |
| |
| // 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); |
| |
| // owner |
| Read(&owner, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::ConvertSelection(const ConvertSelectionRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& requestor = request.requestor; |
| auto& selection = request.selection; |
| auto& target = request.target; |
| auto& property = request.property; |
| auto& time = request.time; |
| |
| // major_opcode |
| uint8_t major_opcode = 24; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // requestor |
| buf.Write(&requestor); |
| |
| // selection |
| buf.Write(&selection); |
| |
| // target |
| buf.Write(&target); |
| |
| // property |
| buf.Write(&property); |
| |
| // time |
| buf.Write(&time); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ConvertSelection", false); |
| } |
| |
| Future<void> XProto::ConvertSelection(const Window& requestor, |
| const Atom& selection, |
| const Atom& target, |
| const Atom& property, |
| const Time& time) { |
| return XProto::ConvertSelection( |
| ConvertSelectionRequest{requestor, selection, target, property, time}); |
| } |
| |
| Future<void> XProto::SendEvent(const SendEventRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& propagate = request.propagate; |
| auto& destination = request.destination; |
| auto& event_mask = request.event_mask; |
| auto& event = request.event; |
| size_t event_len = event.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 25; |
| buf.Write(&major_opcode); |
| |
| // propagate |
| buf.Write(&propagate); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // destination |
| buf.Write(&destination); |
| |
| // event_mask |
| uint32_t tmp52; |
| tmp52 = static_cast<uint32_t>(event_mask); |
| buf.Write(&tmp52); |
| |
| // event |
| for (auto& event_elem : event) { |
| // event_elem |
| buf.Write(&event_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "SendEvent", false); |
| } |
| |
| Future<void> XProto::SendEvent(const uint8_t& propagate, |
| const Window& destination, |
| const EventMask& event_mask, |
| const std::array<char, 32>& event) { |
| return XProto::SendEvent( |
| SendEventRequest{propagate, destination, event_mask, event}); |
| } |
| |
| Future<GrabPointerReply> XProto::GrabPointer( |
| const GrabPointerRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& owner_events = request.owner_events; |
| auto& grab_window = request.grab_window; |
| auto& event_mask = request.event_mask; |
| auto& pointer_mode = request.pointer_mode; |
| auto& keyboard_mode = request.keyboard_mode; |
| auto& confine_to = request.confine_to; |
| auto& cursor = request.cursor; |
| auto& time = request.time; |
| |
| // major_opcode |
| uint8_t major_opcode = 26; |
| buf.Write(&major_opcode); |
| |
| // owner_events |
| buf.Write(&owner_events); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // grab_window |
| buf.Write(&grab_window); |
| |
| // event_mask |
| uint16_t tmp53; |
| tmp53 = static_cast<uint16_t>(event_mask); |
| buf.Write(&tmp53); |
| |
| // pointer_mode |
| uint8_t tmp54; |
| tmp54 = static_cast<uint8_t>(pointer_mode); |
| buf.Write(&tmp54); |
| |
| // keyboard_mode |
| uint8_t tmp55; |
| tmp55 = static_cast<uint8_t>(keyboard_mode); |
| buf.Write(&tmp55); |
| |
| // confine_to |
| buf.Write(&confine_to); |
| |
| // cursor |
| buf.Write(&cursor); |
| |
| // time |
| buf.Write(&time); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GrabPointerReply>(&buf, "GrabPointer", false); |
| } |
| |
| Future<GrabPointerReply> XProto::GrabPointer(const uint8_t& owner_events, |
| const Window& grab_window, |
| const EventMask& event_mask, |
| const GrabMode& pointer_mode, |
| const GrabMode& keyboard_mode, |
| const Window& confine_to, |
| const Cursor& cursor, |
| const Time& time) { |
| return XProto::GrabPointer( |
| GrabPointerRequest{owner_events, grab_window, event_mask, pointer_mode, |
| keyboard_mode, confine_to, cursor, time}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GrabPointerReply> detail::ReadReply<GrabPointerReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GrabPointerReply>(); |
| |
| auto& status = (*reply).status; |
| auto& sequence = (*reply).sequence; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // status |
| uint8_t tmp56; |
| Read(&tmp56, &buf); |
| status = static_cast<GrabStatus>(tmp56); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::UngrabPointer(const UngrabPointerRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& time = request.time; |
| |
| // major_opcode |
| uint8_t major_opcode = 27; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // time |
| buf.Write(&time); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "UngrabPointer", false); |
| } |
| |
| Future<void> XProto::UngrabPointer(const Time& time) { |
| return XProto::UngrabPointer(UngrabPointerRequest{time}); |
| } |
| |
| Future<void> XProto::GrabButton(const GrabButtonRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& owner_events = request.owner_events; |
| auto& grab_window = request.grab_window; |
| auto& event_mask = request.event_mask; |
| auto& pointer_mode = request.pointer_mode; |
| auto& keyboard_mode = request.keyboard_mode; |
| auto& confine_to = request.confine_to; |
| auto& cursor = request.cursor; |
| auto& button = request.button; |
| auto& modifiers = request.modifiers; |
| |
| // major_opcode |
| uint8_t major_opcode = 28; |
| buf.Write(&major_opcode); |
| |
| // owner_events |
| buf.Write(&owner_events); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // grab_window |
| buf.Write(&grab_window); |
| |
| // event_mask |
| uint16_t tmp57; |
| tmp57 = static_cast<uint16_t>(event_mask); |
| buf.Write(&tmp57); |
| |
| // pointer_mode |
| uint8_t tmp58; |
| tmp58 = static_cast<uint8_t>(pointer_mode); |
| buf.Write(&tmp58); |
| |
| // keyboard_mode |
| uint8_t tmp59; |
| tmp59 = static_cast<uint8_t>(keyboard_mode); |
| buf.Write(&tmp59); |
| |
| // confine_to |
| buf.Write(&confine_to); |
| |
| // cursor |
| buf.Write(&cursor); |
| |
| // button |
| uint8_t tmp60; |
| tmp60 = static_cast<uint8_t>(button); |
| buf.Write(&tmp60); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // modifiers |
| uint16_t tmp61; |
| tmp61 = static_cast<uint16_t>(modifiers); |
| buf.Write(&tmp61); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "GrabButton", false); |
| } |
| |
| Future<void> XProto::GrabButton(const uint8_t& owner_events, |
| const Window& grab_window, |
| const EventMask& event_mask, |
| const GrabMode& pointer_mode, |
| const GrabMode& keyboard_mode, |
| const Window& confine_to, |
| const Cursor& cursor, |
| const ButtonIndex& button, |
| const ModMask& modifiers) { |
| return XProto::GrabButton( |
| GrabButtonRequest{owner_events, grab_window, event_mask, pointer_mode, |
| keyboard_mode, confine_to, cursor, button, modifiers}); |
| } |
| |
| Future<void> XProto::UngrabButton(const UngrabButtonRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& button = request.button; |
| auto& grab_window = request.grab_window; |
| auto& modifiers = request.modifiers; |
| |
| // major_opcode |
| uint8_t major_opcode = 29; |
| buf.Write(&major_opcode); |
| |
| // button |
| uint8_t tmp62; |
| tmp62 = static_cast<uint8_t>(button); |
| buf.Write(&tmp62); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // grab_window |
| buf.Write(&grab_window); |
| |
| // modifiers |
| uint16_t tmp63; |
| tmp63 = static_cast<uint16_t>(modifiers); |
| buf.Write(&tmp63); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "UngrabButton", false); |
| } |
| |
| Future<void> XProto::UngrabButton(const ButtonIndex& button, |
| const Window& grab_window, |
| const ModMask& modifiers) { |
| return XProto::UngrabButton( |
| UngrabButtonRequest{button, grab_window, modifiers}); |
| } |
| |
| Future<void> XProto::ChangeActivePointerGrab( |
| const ChangeActivePointerGrabRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cursor = request.cursor; |
| auto& time = request.time; |
| auto& event_mask = request.event_mask; |
| |
| // major_opcode |
| uint8_t major_opcode = 30; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cursor |
| buf.Write(&cursor); |
| |
| // time |
| buf.Write(&time); |
| |
| // event_mask |
| uint16_t tmp64; |
| tmp64 = static_cast<uint16_t>(event_mask); |
| buf.Write(&tmp64); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ChangeActivePointerGrab", false); |
| } |
| |
| Future<void> XProto::ChangeActivePointerGrab(const Cursor& cursor, |
| const Time& time, |
| const EventMask& event_mask) { |
| return XProto::ChangeActivePointerGrab( |
| ChangeActivePointerGrabRequest{cursor, time, event_mask}); |
| } |
| |
| Future<GrabKeyboardReply> XProto::GrabKeyboard( |
| const GrabKeyboardRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& owner_events = request.owner_events; |
| auto& grab_window = request.grab_window; |
| auto& time = request.time; |
| auto& pointer_mode = request.pointer_mode; |
| auto& keyboard_mode = request.keyboard_mode; |
| |
| // major_opcode |
| uint8_t major_opcode = 31; |
| buf.Write(&major_opcode); |
| |
| // owner_events |
| buf.Write(&owner_events); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // grab_window |
| buf.Write(&grab_window); |
| |
| // time |
| buf.Write(&time); |
| |
| // pointer_mode |
| uint8_t tmp65; |
| tmp65 = static_cast<uint8_t>(pointer_mode); |
| buf.Write(&tmp65); |
| |
| // keyboard_mode |
| uint8_t tmp66; |
| tmp66 = static_cast<uint8_t>(keyboard_mode); |
| buf.Write(&tmp66); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GrabKeyboardReply>(&buf, "GrabKeyboard", |
| false); |
| } |
| |
| Future<GrabKeyboardReply> XProto::GrabKeyboard(const uint8_t& owner_events, |
| const Window& grab_window, |
| const Time& time, |
| const GrabMode& pointer_mode, |
| const GrabMode& keyboard_mode) { |
| return XProto::GrabKeyboard(GrabKeyboardRequest{ |
| owner_events, grab_window, time, pointer_mode, keyboard_mode}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GrabKeyboardReply> detail::ReadReply<GrabKeyboardReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GrabKeyboardReply>(); |
| |
| auto& status = (*reply).status; |
| auto& sequence = (*reply).sequence; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // status |
| uint8_t tmp67; |
| Read(&tmp67, &buf); |
| status = static_cast<GrabStatus>(tmp67); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::UngrabKeyboard(const UngrabKeyboardRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& time = request.time; |
| |
| // major_opcode |
| uint8_t major_opcode = 32; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // time |
| buf.Write(&time); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "UngrabKeyboard", false); |
| } |
| |
| Future<void> XProto::UngrabKeyboard(const Time& time) { |
| return XProto::UngrabKeyboard(UngrabKeyboardRequest{time}); |
| } |
| |
| Future<void> XProto::GrabKey(const GrabKeyRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& owner_events = request.owner_events; |
| auto& grab_window = request.grab_window; |
| auto& modifiers = request.modifiers; |
| auto& key = request.key; |
| auto& pointer_mode = request.pointer_mode; |
| auto& keyboard_mode = request.keyboard_mode; |
| |
| // major_opcode |
| uint8_t major_opcode = 33; |
| buf.Write(&major_opcode); |
| |
| // owner_events |
| buf.Write(&owner_events); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // grab_window |
| buf.Write(&grab_window); |
| |
| // modifiers |
| uint16_t tmp68; |
| tmp68 = static_cast<uint16_t>(modifiers); |
| buf.Write(&tmp68); |
| |
| // key |
| buf.Write(&key); |
| |
| // pointer_mode |
| uint8_t tmp69; |
| tmp69 = static_cast<uint8_t>(pointer_mode); |
| buf.Write(&tmp69); |
| |
| // keyboard_mode |
| uint8_t tmp70; |
| tmp70 = static_cast<uint8_t>(keyboard_mode); |
| buf.Write(&tmp70); |
| |
| // pad0 |
| Pad(&buf, 3); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "GrabKey", false); |
| } |
| |
| Future<void> XProto::GrabKey(const uint8_t& owner_events, |
| const Window& grab_window, |
| const ModMask& modifiers, |
| const KeyCode& key, |
| const GrabMode& pointer_mode, |
| const GrabMode& keyboard_mode) { |
| return XProto::GrabKey(GrabKeyRequest{owner_events, grab_window, modifiers, |
| key, pointer_mode, keyboard_mode}); |
| } |
| |
| Future<void> XProto::UngrabKey(const UngrabKeyRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& key = request.key; |
| auto& grab_window = request.grab_window; |
| auto& modifiers = request.modifiers; |
| |
| // major_opcode |
| uint8_t major_opcode = 34; |
| buf.Write(&major_opcode); |
| |
| // key |
| buf.Write(&key); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // grab_window |
| buf.Write(&grab_window); |
| |
| // modifiers |
| uint16_t tmp71; |
| tmp71 = static_cast<uint16_t>(modifiers); |
| buf.Write(&tmp71); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "UngrabKey", false); |
| } |
| |
| Future<void> XProto::UngrabKey(const KeyCode& key, |
| const Window& grab_window, |
| const ModMask& modifiers) { |
| return XProto::UngrabKey(UngrabKeyRequest{key, grab_window, modifiers}); |
| } |
| |
| Future<void> XProto::AllowEvents(const AllowEventsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& mode = request.mode; |
| auto& time = request.time; |
| |
| // major_opcode |
| uint8_t major_opcode = 35; |
| buf.Write(&major_opcode); |
| |
| // mode |
| uint8_t tmp72; |
| tmp72 = static_cast<uint8_t>(mode); |
| buf.Write(&tmp72); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // time |
| buf.Write(&time); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "AllowEvents", false); |
| } |
| |
| Future<void> XProto::AllowEvents(const Allow& mode, const Time& time) { |
| return XProto::AllowEvents(AllowEventsRequest{mode, time}); |
| } |
| |
| Future<void> XProto::GrabServer(const GrabServerRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 36; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "GrabServer", false); |
| } |
| |
| Future<void> XProto::GrabServer() { |
| return XProto::GrabServer(GrabServerRequest{}); |
| } |
| |
| Future<void> XProto::UngrabServer(const UngrabServerRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 37; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "UngrabServer", false); |
| } |
| |
| Future<void> XProto::UngrabServer() { |
| return XProto::UngrabServer(UngrabServerRequest{}); |
| } |
| |
| Future<QueryPointerReply> XProto::QueryPointer( |
| const QueryPointerRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 38; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<QueryPointerReply>(&buf, "QueryPointer", |
| false); |
| } |
| |
| Future<QueryPointerReply> XProto::QueryPointer(const Window& window) { |
| return XProto::QueryPointer(QueryPointerRequest{window}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<QueryPointerReply> detail::ReadReply<QueryPointerReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<QueryPointerReply>(); |
| |
| auto& same_screen = (*reply).same_screen; |
| auto& sequence = (*reply).sequence; |
| auto& root = (*reply).root; |
| auto& child = (*reply).child; |
| auto& root_x = (*reply).root_x; |
| auto& root_y = (*reply).root_y; |
| auto& win_x = (*reply).win_x; |
| auto& win_y = (*reply).win_y; |
| auto& mask = (*reply).mask; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // same_screen |
| Read(&same_screen, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // root |
| Read(&root, &buf); |
| |
| // child |
| Read(&child, &buf); |
| |
| // root_x |
| Read(&root_x, &buf); |
| |
| // root_y |
| Read(&root_y, &buf); |
| |
| // win_x |
| Read(&win_x, &buf); |
| |
| // win_y |
| Read(&win_y, &buf); |
| |
| // mask |
| uint16_t tmp73; |
| Read(&tmp73, &buf); |
| mask = static_cast<KeyButMask>(tmp73); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<GetMotionEventsReply> XProto::GetMotionEvents( |
| const GetMotionEventsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| auto& start = request.start; |
| auto& stop = request.stop; |
| |
| // major_opcode |
| uint8_t major_opcode = 39; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| // start |
| buf.Write(&start); |
| |
| // stop |
| buf.Write(&stop); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetMotionEventsReply>(&buf, "GetMotionEvents", |
| false); |
| } |
| |
| Future<GetMotionEventsReply> XProto::GetMotionEvents(const Window& window, |
| const Time& start, |
| const Time& stop) { |
| return XProto::GetMotionEvents(GetMotionEventsRequest{window, start, stop}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetMotionEventsReply> detail::ReadReply<GetMotionEventsReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetMotionEventsReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| uint32_t events_len{}; |
| auto& events = (*reply).events; |
| |
| // 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); |
| |
| // events_len |
| Read(&events_len, &buf); |
| |
| // pad1 |
| Pad(&buf, 20); |
| |
| // events |
| events.resize(events_len); |
| for (auto& events_elem : events) { |
| // events_elem |
| { |
| auto& time = events_elem.time; |
| auto& x = events_elem.x; |
| auto& y = events_elem.y; |
| |
| // time |
| Read(&time, &buf); |
| |
| // x |
| Read(&x, &buf); |
| |
| // y |
| Read(&y, &buf); |
| } |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<TranslateCoordinatesReply> XProto::TranslateCoordinates( |
| const TranslateCoordinatesRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& src_window = request.src_window; |
| auto& dst_window = request.dst_window; |
| auto& src_x = request.src_x; |
| auto& src_y = request.src_y; |
| |
| // major_opcode |
| uint8_t major_opcode = 40; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // src_window |
| buf.Write(&src_window); |
| |
| // dst_window |
| buf.Write(&dst_window); |
| |
| // src_x |
| buf.Write(&src_x); |
| |
| // src_y |
| buf.Write(&src_y); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<TranslateCoordinatesReply>( |
| &buf, "TranslateCoordinates", false); |
| } |
| |
| Future<TranslateCoordinatesReply> XProto::TranslateCoordinates( |
| const Window& src_window, |
| const Window& dst_window, |
| const int16_t& src_x, |
| const int16_t& src_y) { |
| return XProto::TranslateCoordinates( |
| TranslateCoordinatesRequest{src_window, dst_window, src_x, src_y}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<TranslateCoordinatesReply> detail::ReadReply< |
| TranslateCoordinatesReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<TranslateCoordinatesReply>(); |
| |
| auto& same_screen = (*reply).same_screen; |
| auto& sequence = (*reply).sequence; |
| auto& child = (*reply).child; |
| auto& dst_x = (*reply).dst_x; |
| auto& dst_y = (*reply).dst_y; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // same_screen |
| Read(&same_screen, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // child |
| Read(&child, &buf); |
| |
| // dst_x |
| Read(&dst_x, &buf); |
| |
| // dst_y |
| Read(&dst_y, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::WarpPointer(const WarpPointerRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& src_window = request.src_window; |
| auto& dst_window = request.dst_window; |
| auto& src_x = request.src_x; |
| auto& src_y = request.src_y; |
| auto& src_width = request.src_width; |
| auto& src_height = request.src_height; |
| auto& dst_x = request.dst_x; |
| auto& dst_y = request.dst_y; |
| |
| // major_opcode |
| uint8_t major_opcode = 41; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // src_window |
| buf.Write(&src_window); |
| |
| // dst_window |
| buf.Write(&dst_window); |
| |
| // src_x |
| buf.Write(&src_x); |
| |
| // src_y |
| buf.Write(&src_y); |
| |
| // src_width |
| buf.Write(&src_width); |
| |
| // src_height |
| buf.Write(&src_height); |
| |
| // dst_x |
| buf.Write(&dst_x); |
| |
| // dst_y |
| buf.Write(&dst_y); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "WarpPointer", false); |
| } |
| |
| Future<void> XProto::WarpPointer(const Window& src_window, |
| const Window& dst_window, |
| const int16_t& src_x, |
| const int16_t& src_y, |
| const uint16_t& src_width, |
| const uint16_t& src_height, |
| const int16_t& dst_x, |
| const int16_t& dst_y) { |
| return XProto::WarpPointer(WarpPointerRequest{src_window, dst_window, src_x, |
| src_y, src_width, src_height, |
| dst_x, dst_y}); |
| } |
| |
| Future<void> XProto::SetInputFocus(const SetInputFocusRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& revert_to = request.revert_to; |
| auto& focus = request.focus; |
| auto& time = request.time; |
| |
| // major_opcode |
| uint8_t major_opcode = 42; |
| buf.Write(&major_opcode); |
| |
| // revert_to |
| uint8_t tmp74; |
| tmp74 = static_cast<uint8_t>(revert_to); |
| buf.Write(&tmp74); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // focus |
| buf.Write(&focus); |
| |
| // time |
| buf.Write(&time); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "SetInputFocus", false); |
| } |
| |
| Future<void> XProto::SetInputFocus(const InputFocus& revert_to, |
| const Window& focus, |
| const Time& time) { |
| return XProto::SetInputFocus(SetInputFocusRequest{revert_to, focus, time}); |
| } |
| |
| Future<GetInputFocusReply> XProto::GetInputFocus( |
| const GetInputFocusRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 43; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetInputFocusReply>(&buf, "GetInputFocus", |
| false); |
| } |
| |
| Future<GetInputFocusReply> XProto::GetInputFocus() { |
| return XProto::GetInputFocus(GetInputFocusRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetInputFocusReply> detail::ReadReply<GetInputFocusReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetInputFocusReply>(); |
| |
| auto& revert_to = (*reply).revert_to; |
| auto& sequence = (*reply).sequence; |
| auto& focus = (*reply).focus; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // revert_to |
| uint8_t tmp75; |
| Read(&tmp75, &buf); |
| revert_to = static_cast<InputFocus>(tmp75); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // focus |
| Read(&focus, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<QueryKeymapReply> XProto::QueryKeymap( |
| const QueryKeymapRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 44; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<QueryKeymapReply>(&buf, "QueryKeymap", false); |
| } |
| |
| Future<QueryKeymapReply> XProto::QueryKeymap() { |
| return XProto::QueryKeymap(QueryKeymapRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<QueryKeymapReply> detail::ReadReply<QueryKeymapReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<QueryKeymapReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& keys = (*reply).keys; |
| size_t keys_len = keys.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); |
| |
| // keys |
| for (auto& keys_elem : keys) { |
| // keys_elem |
| Read(&keys_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::OpenFont(const OpenFontRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& fid = request.fid; |
| uint16_t name_len{}; |
| auto& name = request.name; |
| |
| // major_opcode |
| uint8_t major_opcode = 45; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // fid |
| buf.Write(&fid); |
| |
| // name_len |
| name_len = name.size(); |
| buf.Write(&name_len); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| // name |
| DCHECK_EQ(static_cast<size_t>(name_len), name.size()); |
| for (auto& name_elem : name) { |
| // name_elem |
| buf.Write(&name_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "OpenFont", false); |
| } |
| |
| Future<void> XProto::OpenFont(const Font& fid, const std::string& name) { |
| return XProto::OpenFont(OpenFontRequest{fid, name}); |
| } |
| |
| Future<void> XProto::CloseFont(const CloseFontRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& font = request.font; |
| |
| // major_opcode |
| uint8_t major_opcode = 46; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // font |
| buf.Write(&font); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "CloseFont", false); |
| } |
| |
| Future<void> XProto::CloseFont(const Font& font) { |
| return XProto::CloseFont(CloseFontRequest{font}); |
| } |
| |
| Future<QueryFontReply> XProto::QueryFont(const QueryFontRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& font = request.font; |
| |
| // major_opcode |
| uint8_t major_opcode = 47; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // font |
| buf.Write(&font); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<QueryFontReply>(&buf, "QueryFont", false); |
| } |
| |
| Future<QueryFontReply> XProto::QueryFont(const Fontable& font) { |
| return XProto::QueryFont(QueryFontRequest{font}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<QueryFontReply> detail::ReadReply<QueryFontReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<QueryFontReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& min_bounds = (*reply).min_bounds; |
| auto& max_bounds = (*reply).max_bounds; |
| auto& min_char_or_byte2 = (*reply).min_char_or_byte2; |
| auto& max_char_or_byte2 = (*reply).max_char_or_byte2; |
| auto& default_char = (*reply).default_char; |
| uint16_t properties_len{}; |
| auto& draw_direction = (*reply).draw_direction; |
| auto& min_byte1 = (*reply).min_byte1; |
| auto& max_byte1 = (*reply).max_byte1; |
| auto& all_chars_exist = (*reply).all_chars_exist; |
| auto& font_ascent = (*reply).font_ascent; |
| auto& font_descent = (*reply).font_descent; |
| uint32_t char_infos_len{}; |
| auto& properties = (*reply).properties; |
| auto& char_infos = (*reply).char_infos; |
| |
| // 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); |
| |
| // min_bounds |
| { |
| auto& left_side_bearing = min_bounds.left_side_bearing; |
| auto& right_side_bearing = min_bounds.right_side_bearing; |
| auto& character_width = min_bounds.character_width; |
| auto& ascent = min_bounds.ascent; |
| auto& descent = min_bounds.descent; |
| auto& attributes = min_bounds.attributes; |
| |
| // left_side_bearing |
| Read(&left_side_bearing, &buf); |
| |
| // right_side_bearing |
| Read(&right_side_bearing, &buf); |
| |
| // character_width |
| Read(&character_width, &buf); |
| |
| // ascent |
| Read(&ascent, &buf); |
| |
| // descent |
| Read(&descent, &buf); |
| |
| // attributes |
| Read(&attributes, &buf); |
| } |
| |
| // pad1 |
| Pad(&buf, 4); |
| |
| // max_bounds |
| { |
| auto& left_side_bearing = max_bounds.left_side_bearing; |
| auto& right_side_bearing = max_bounds.right_side_bearing; |
| auto& character_width = max_bounds.character_width; |
| auto& ascent = max_bounds.ascent; |
| auto& descent = max_bounds.descent; |
| auto& attributes = max_bounds.attributes; |
| |
| // left_side_bearing |
| Read(&left_side_bearing, &buf); |
| |
| // right_side_bearing |
| Read(&right_side_bearing, &buf); |
| |
| // character_width |
| Read(&character_width, &buf); |
| |
| // ascent |
| Read(&ascent, &buf); |
| |
| // descent |
| Read(&descent, &buf); |
| |
| // attributes |
| Read(&attributes, &buf); |
| } |
| |
| // pad2 |
| Pad(&buf, 4); |
| |
| // min_char_or_byte2 |
| Read(&min_char_or_byte2, &buf); |
| |
| // max_char_or_byte2 |
| Read(&max_char_or_byte2, &buf); |
| |
| // default_char |
| Read(&default_char, &buf); |
| |
| // properties_len |
| Read(&properties_len, &buf); |
| |
| // draw_direction |
| uint8_t tmp76; |
| Read(&tmp76, &buf); |
| draw_direction = static_cast<FontDraw>(tmp76); |
| |
| // min_byte1 |
| Read(&min_byte1, &buf); |
| |
| // max_byte1 |
| Read(&max_byte1, &buf); |
| |
| // all_chars_exist |
| Read(&all_chars_exist, &buf); |
| |
| // font_ascent |
| Read(&font_ascent, &buf); |
| |
| // font_descent |
| Read(&font_descent, &buf); |
| |
| // char_infos_len |
| Read(&char_infos_len, &buf); |
| |
| // properties |
| properties.resize(properties_len); |
| for (auto& properties_elem : properties) { |
| // properties_elem |
| { |
| auto& name = properties_elem.name; |
| auto& value = properties_elem.value; |
| |
| // name |
| Read(&name, &buf); |
| |
| // value |
| Read(&value, &buf); |
| } |
| } |
| |
| // char_infos |
| char_infos.resize(char_infos_len); |
| for (auto& char_infos_elem : char_infos) { |
| // char_infos_elem |
| { |
| auto& left_side_bearing = char_infos_elem.left_side_bearing; |
| auto& right_side_bearing = char_infos_elem.right_side_bearing; |
| auto& character_width = char_infos_elem.character_width; |
| auto& ascent = char_infos_elem.ascent; |
| auto& descent = char_infos_elem.descent; |
| auto& attributes = char_infos_elem.attributes; |
| |
| // left_side_bearing |
| Read(&left_side_bearing, &buf); |
| |
| // right_side_bearing |
| Read(&right_side_bearing, &buf); |
| |
| // character_width |
| Read(&character_width, &buf); |
| |
| // ascent |
| Read(&ascent, &buf); |
| |
| // descent |
| Read(&descent, &buf); |
| |
| // attributes |
| Read(&attributes, &buf); |
| } |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<QueryTextExtentsReply> XProto::QueryTextExtents( |
| const QueryTextExtentsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& font = request.font; |
| auto& string = request.string; |
| size_t string_len = string.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 48; |
| buf.Write(&major_opcode); |
| |
| // odd_length |
| uint8_t odd_length = BitAnd(string_len, 1); |
| buf.Write(&odd_length); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // font |
| buf.Write(&font); |
| |
| // string |
| DCHECK_EQ(static_cast<size_t>(string_len), string.size()); |
| for (auto& string_elem : string) { |
| // string_elem |
| { |
| auto& byte1 = string_elem.byte1; |
| auto& byte2 = string_elem.byte2; |
| |
| // byte1 |
| buf.Write(&byte1); |
| |
| // byte2 |
| buf.Write(&byte2); |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<QueryTextExtentsReply>( |
| &buf, "QueryTextExtents", false); |
| } |
| |
| Future<QueryTextExtentsReply> XProto::QueryTextExtents( |
| const Fontable& font, |
| const std::vector<Char16>& string) { |
| return XProto::QueryTextExtents(QueryTextExtentsRequest{font, string}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<QueryTextExtentsReply> detail::ReadReply<QueryTextExtentsReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<QueryTextExtentsReply>(); |
| |
| auto& draw_direction = (*reply).draw_direction; |
| auto& sequence = (*reply).sequence; |
| auto& font_ascent = (*reply).font_ascent; |
| auto& font_descent = (*reply).font_descent; |
| auto& overall_ascent = (*reply).overall_ascent; |
| auto& overall_descent = (*reply).overall_descent; |
| auto& overall_width = (*reply).overall_width; |
| auto& overall_left = (*reply).overall_left; |
| auto& overall_right = (*reply).overall_right; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // draw_direction |
| uint8_t tmp77; |
| Read(&tmp77, &buf); |
| draw_direction = static_cast<FontDraw>(tmp77); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // font_ascent |
| Read(&font_ascent, &buf); |
| |
| // font_descent |
| Read(&font_descent, &buf); |
| |
| // overall_ascent |
| Read(&overall_ascent, &buf); |
| |
| // overall_descent |
| Read(&overall_descent, &buf); |
| |
| // overall_width |
| Read(&overall_width, &buf); |
| |
| // overall_left |
| Read(&overall_left, &buf); |
| |
| // overall_right |
| Read(&overall_right, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<ListFontsReply> XProto::ListFonts(const ListFontsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& max_names = request.max_names; |
| uint16_t pattern_len{}; |
| auto& pattern = request.pattern; |
| |
| // major_opcode |
| uint8_t major_opcode = 49; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // max_names |
| buf.Write(&max_names); |
| |
| // pattern_len |
| pattern_len = pattern.size(); |
| buf.Write(&pattern_len); |
| |
| // pattern |
| DCHECK_EQ(static_cast<size_t>(pattern_len), pattern.size()); |
| for (auto& pattern_elem : pattern) { |
| // pattern_elem |
| buf.Write(&pattern_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<ListFontsReply>(&buf, "ListFonts", false); |
| } |
| |
| Future<ListFontsReply> XProto::ListFonts(const uint16_t& max_names, |
| const std::string& pattern) { |
| return XProto::ListFonts(ListFontsRequest{max_names, pattern}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<ListFontsReply> detail::ReadReply<ListFontsReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<ListFontsReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| uint16_t names_len{}; |
| auto& names = (*reply).names; |
| |
| // 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); |
| |
| // names_len |
| Read(&names_len, &buf); |
| |
| // pad1 |
| Pad(&buf, 22); |
| |
| // names |
| names.resize(names_len); |
| for (auto& names_elem : names) { |
| // names_elem |
| { |
| uint8_t name_len{}; |
| auto& name = names_elem.name; |
| |
| // name_len |
| Read(&name_len, &buf); |
| |
| // name |
| name.resize(name_len); |
| 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<ListFontsWithInfoReply> XProto::ListFontsWithInfo( |
| const ListFontsWithInfoRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& max_names = request.max_names; |
| uint16_t pattern_len{}; |
| auto& pattern = request.pattern; |
| |
| // major_opcode |
| uint8_t major_opcode = 50; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // max_names |
| buf.Write(&max_names); |
| |
| // pattern_len |
| pattern_len = pattern.size(); |
| buf.Write(&pattern_len); |
| |
| // pattern |
| DCHECK_EQ(static_cast<size_t>(pattern_len), pattern.size()); |
| for (auto& pattern_elem : pattern) { |
| // pattern_elem |
| buf.Write(&pattern_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<ListFontsWithInfoReply>( |
| &buf, "ListFontsWithInfo", false); |
| } |
| |
| Future<ListFontsWithInfoReply> XProto::ListFontsWithInfo( |
| const uint16_t& max_names, |
| const std::string& pattern) { |
| return XProto::ListFontsWithInfo( |
| ListFontsWithInfoRequest{max_names, pattern}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<ListFontsWithInfoReply> detail::ReadReply< |
| ListFontsWithInfoReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<ListFontsWithInfoReply>(); |
| |
| uint8_t name_len{}; |
| auto& sequence = (*reply).sequence; |
| auto& min_bounds = (*reply).min_bounds; |
| auto& max_bounds = (*reply).max_bounds; |
| auto& min_char_or_byte2 = (*reply).min_char_or_byte2; |
| auto& max_char_or_byte2 = (*reply).max_char_or_byte2; |
| auto& default_char = (*reply).default_char; |
| uint16_t properties_len{}; |
| auto& draw_direction = (*reply).draw_direction; |
| auto& min_byte1 = (*reply).min_byte1; |
| auto& max_byte1 = (*reply).max_byte1; |
| auto& all_chars_exist = (*reply).all_chars_exist; |
| auto& font_ascent = (*reply).font_ascent; |
| auto& font_descent = (*reply).font_descent; |
| auto& replies_hint = (*reply).replies_hint; |
| auto& properties = (*reply).properties; |
| auto& name = (*reply).name; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // name_len |
| Read(&name_len, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // min_bounds |
| { |
| auto& left_side_bearing = min_bounds.left_side_bearing; |
| auto& right_side_bearing = min_bounds.right_side_bearing; |
| auto& character_width = min_bounds.character_width; |
| auto& ascent = min_bounds.ascent; |
| auto& descent = min_bounds.descent; |
| auto& attributes = min_bounds.attributes; |
| |
| // left_side_bearing |
| Read(&left_side_bearing, &buf); |
| |
| // right_side_bearing |
| Read(&right_side_bearing, &buf); |
| |
| // character_width |
| Read(&character_width, &buf); |
| |
| // ascent |
| Read(&ascent, &buf); |
| |
| // descent |
| Read(&descent, &buf); |
| |
| // attributes |
| Read(&attributes, &buf); |
| } |
| |
| // pad0 |
| Pad(&buf, 4); |
| |
| // max_bounds |
| { |
| auto& left_side_bearing = max_bounds.left_side_bearing; |
| auto& right_side_bearing = max_bounds.right_side_bearing; |
| auto& character_width = max_bounds.character_width; |
| auto& ascent = max_bounds.ascent; |
| auto& descent = max_bounds.descent; |
| auto& attributes = max_bounds.attributes; |
| |
| // left_side_bearing |
| Read(&left_side_bearing, &buf); |
| |
| // right_side_bearing |
| Read(&right_side_bearing, &buf); |
| |
| // character_width |
| Read(&character_width, &buf); |
| |
| // ascent |
| Read(&ascent, &buf); |
| |
| // descent |
| Read(&descent, &buf); |
| |
| // attributes |
| Read(&attributes, &buf); |
| } |
| |
| // pad1 |
| Pad(&buf, 4); |
| |
| // min_char_or_byte2 |
| Read(&min_char_or_byte2, &buf); |
| |
| // max_char_or_byte2 |
| Read(&max_char_or_byte2, &buf); |
| |
| // default_char |
| Read(&default_char, &buf); |
| |
| // properties_len |
| Read(&properties_len, &buf); |
| |
| // draw_direction |
| uint8_t tmp78; |
| Read(&tmp78, &buf); |
| draw_direction = static_cast<FontDraw>(tmp78); |
| |
| // min_byte1 |
| Read(&min_byte1, &buf); |
| |
| // max_byte1 |
| Read(&max_byte1, &buf); |
| |
| // all_chars_exist |
| Read(&all_chars_exist, &buf); |
| |
| // font_ascent |
| Read(&font_ascent, &buf); |
| |
| // font_descent |
| Read(&font_descent, &buf); |
| |
| // replies_hint |
| Read(&replies_hint, &buf); |
| |
| // properties |
| properties.resize(properties_len); |
| for (auto& properties_elem : properties) { |
| // properties_elem |
| { |
| auto& name = properties_elem.name; |
| auto& value = properties_elem.value; |
| |
| // name |
| Read(&name, &buf); |
| |
| // value |
| Read(&value, &buf); |
| } |
| } |
| |
| // name |
| name.resize(name_len); |
| 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> XProto::SetFontPath(const SetFontPathRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| uint16_t font_qty{}; |
| auto& font = request.font; |
| size_t font_len = font.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 51; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // font_qty |
| font_qty = font.size(); |
| buf.Write(&font_qty); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| // font |
| DCHECK_EQ(static_cast<size_t>(font_qty), font.size()); |
| for (auto& font_elem : font) { |
| // font_elem |
| { |
| uint8_t name_len{}; |
| auto& name = font_elem.name; |
| |
| // name_len |
| name_len = name.size(); |
| buf.Write(&name_len); |
| |
| // name |
| DCHECK_EQ(static_cast<size_t>(name_len), name.size()); |
| for (auto& name_elem : name) { |
| // name_elem |
| buf.Write(&name_elem); |
| } |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "SetFontPath", false); |
| } |
| |
| Future<void> XProto::SetFontPath(const std::vector<Str>& font) { |
| return XProto::SetFontPath(SetFontPathRequest{font}); |
| } |
| |
| Future<GetFontPathReply> XProto::GetFontPath( |
| const GetFontPathRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 52; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetFontPathReply>(&buf, "GetFontPath", false); |
| } |
| |
| Future<GetFontPathReply> XProto::GetFontPath() { |
| return XProto::GetFontPath(GetFontPathRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetFontPathReply> detail::ReadReply<GetFontPathReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetFontPathReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| uint16_t path_len{}; |
| auto& path = (*reply).path; |
| |
| // 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); |
| |
| // path_len |
| Read(&path_len, &buf); |
| |
| // pad1 |
| Pad(&buf, 22); |
| |
| // path |
| path.resize(path_len); |
| for (auto& path_elem : path) { |
| // path_elem |
| { |
| uint8_t name_len{}; |
| auto& name = path_elem.name; |
| |
| // name_len |
| Read(&name_len, &buf); |
| |
| // name |
| name.resize(name_len); |
| 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> XProto::CreatePixmap(const CreatePixmapRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& depth = request.depth; |
| auto& pid = request.pid; |
| auto& drawable = request.drawable; |
| auto& width = request.width; |
| auto& height = request.height; |
| |
| // major_opcode |
| uint8_t major_opcode = 53; |
| buf.Write(&major_opcode); |
| |
| // depth |
| buf.Write(&depth); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // pid |
| buf.Write(&pid); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "CreatePixmap", false); |
| } |
| |
| Future<void> XProto::CreatePixmap(const uint8_t& depth, |
| const Pixmap& pid, |
| const Drawable& drawable, |
| const uint16_t& width, |
| const uint16_t& height) { |
| return XProto::CreatePixmap( |
| CreatePixmapRequest{depth, pid, drawable, width, height}); |
| } |
| |
| Future<void> XProto::FreePixmap(const FreePixmapRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& pixmap = request.pixmap; |
| |
| // major_opcode |
| uint8_t major_opcode = 54; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // pixmap |
| buf.Write(&pixmap); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "FreePixmap", false); |
| } |
| |
| Future<void> XProto::FreePixmap(const Pixmap& pixmap) { |
| return XProto::FreePixmap(FreePixmapRequest{pixmap}); |
| } |
| |
| Future<void> XProto::CreateGC(const CreateGCRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cid = request.cid; |
| auto& drawable = request.drawable; |
| GraphicsContextAttribute value_mask{}; |
| auto& value_list = request; |
| |
| // major_opcode |
| uint8_t major_opcode = 55; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cid |
| buf.Write(&cid); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // value_mask |
| SwitchVar(GraphicsContextAttribute::Function, value_list.function.has_value(), |
| true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::PlaneMask, |
| value_list.plane_mask.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::Foreground, |
| value_list.foreground.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::Background, |
| value_list.background.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::LineWidth, |
| value_list.line_width.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::LineStyle, |
| value_list.line_style.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::CapStyle, |
| value_list.cap_style.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::JoinStyle, |
| value_list.join_style.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::FillStyle, |
| value_list.fill_style.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::FillRule, |
| value_list.fill_rule.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::Tile, value_list.tile.has_value(), true, |
| &value_mask); |
| SwitchVar(GraphicsContextAttribute::Stipple, value_list.stipple.has_value(), |
| true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::TileStippleOriginX, |
| value_list.tile_stipple_x_origin.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::TileStippleOriginY, |
| value_list.tile_stipple_y_origin.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::Font, value_list.font.has_value(), true, |
| &value_mask); |
| SwitchVar(GraphicsContextAttribute::SubwindowMode, |
| value_list.subwindow_mode.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::GraphicsExposures, |
| value_list.graphics_exposures.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::ClipOriginX, |
| value_list.clip_x_origin.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::ClipOriginY, |
| value_list.clip_y_origin.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::ClipMask, |
| value_list.clip_mask.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::DashOffset, |
| value_list.dash_offset.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::DashList, value_list.dashes.has_value(), |
| true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::ArcMode, value_list.arc_mode.has_value(), |
| true, &value_mask); |
| uint32_t tmp79; |
| tmp79 = static_cast<uint32_t>(value_mask); |
| buf.Write(&tmp79); |
| |
| // value_list |
| auto value_list_expr = value_mask; |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::Function)) { |
| auto& function = *value_list.function; |
| |
| // function |
| uint32_t tmp80; |
| tmp80 = static_cast<uint32_t>(function); |
| buf.Write(&tmp80); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::PlaneMask)) { |
| auto& plane_mask = *value_list.plane_mask; |
| |
| // plane_mask |
| buf.Write(&plane_mask); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::Foreground)) { |
| auto& foreground = *value_list.foreground; |
| |
| // foreground |
| buf.Write(&foreground); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::Background)) { |
| auto& background = *value_list.background; |
| |
| // background |
| buf.Write(&background); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::LineWidth)) { |
| auto& line_width = *value_list.line_width; |
| |
| // line_width |
| buf.Write(&line_width); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::LineStyle)) { |
| auto& line_style = *value_list.line_style; |
| |
| // line_style |
| uint32_t tmp81; |
| tmp81 = static_cast<uint32_t>(line_style); |
| buf.Write(&tmp81); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::CapStyle)) { |
| auto& cap_style = *value_list.cap_style; |
| |
| // cap_style |
| uint32_t tmp82; |
| tmp82 = static_cast<uint32_t>(cap_style); |
| buf.Write(&tmp82); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::JoinStyle)) { |
| auto& join_style = *value_list.join_style; |
| |
| // join_style |
| uint32_t tmp83; |
| tmp83 = static_cast<uint32_t>(join_style); |
| buf.Write(&tmp83); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::FillStyle)) { |
| auto& fill_style = *value_list.fill_style; |
| |
| // fill_style |
| uint32_t tmp84; |
| tmp84 = static_cast<uint32_t>(fill_style); |
| buf.Write(&tmp84); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::FillRule)) { |
| auto& fill_rule = *value_list.fill_rule; |
| |
| // fill_rule |
| uint32_t tmp85; |
| tmp85 = static_cast<uint32_t>(fill_rule); |
| buf.Write(&tmp85); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::Tile)) { |
| auto& tile = *value_list.tile; |
| |
| // tile |
| buf.Write(&tile); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::Stipple)) { |
| auto& stipple = *value_list.stipple; |
| |
| // stipple |
| buf.Write(&stipple); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::TileStippleOriginX)) { |
| auto& tile_stipple_x_origin = *value_list.tile_stipple_x_origin; |
| |
| // tile_stipple_x_origin |
| buf.Write(&tile_stipple_x_origin); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::TileStippleOriginY)) { |
| auto& tile_stipple_y_origin = *value_list.tile_stipple_y_origin; |
| |
| // tile_stipple_y_origin |
| buf.Write(&tile_stipple_y_origin); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::Font)) { |
| auto& font = *value_list.font; |
| |
| // font |
| buf.Write(&font); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::SubwindowMode)) { |
| auto& subwindow_mode = *value_list.subwindow_mode; |
| |
| // subwindow_mode |
| uint32_t tmp86; |
| tmp86 = static_cast<uint32_t>(subwindow_mode); |
| buf.Write(&tmp86); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::GraphicsExposures)) { |
| auto& graphics_exposures = *value_list.graphics_exposures; |
| |
| // graphics_exposures |
| buf.Write(&graphics_exposures); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::ClipOriginX)) { |
| auto& clip_x_origin = *value_list.clip_x_origin; |
| |
| // clip_x_origin |
| buf.Write(&clip_x_origin); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::ClipOriginY)) { |
| auto& clip_y_origin = *value_list.clip_y_origin; |
| |
| // clip_y_origin |
| buf.Write(&clip_y_origin); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::ClipMask)) { |
| auto& clip_mask = *value_list.clip_mask; |
| |
| // clip_mask |
| buf.Write(&clip_mask); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::DashOffset)) { |
| auto& dash_offset = *value_list.dash_offset; |
| |
| // dash_offset |
| buf.Write(&dash_offset); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::DashList)) { |
| auto& dashes = *value_list.dashes; |
| |
| // dashes |
| buf.Write(&dashes); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::ArcMode)) { |
| auto& arc_mode = *value_list.arc_mode; |
| |
| // arc_mode |
| uint32_t tmp87; |
| tmp87 = static_cast<uint32_t>(arc_mode); |
| buf.Write(&tmp87); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "CreateGC", false); |
| } |
| |
| Future<void> XProto::CreateGC( |
| const GraphicsContext& cid, |
| const Drawable& drawable, |
| const absl::optional<Gx>& function, |
| const absl::optional<uint32_t>& plane_mask, |
| const absl::optional<uint32_t>& foreground, |
| const absl::optional<uint32_t>& background, |
| const absl::optional<uint32_t>& line_width, |
| const absl::optional<LineStyle>& line_style, |
| const absl::optional<CapStyle>& cap_style, |
| const absl::optional<JoinStyle>& join_style, |
| const absl::optional<FillStyle>& fill_style, |
| const absl::optional<FillRule>& fill_rule, |
| const absl::optional<Pixmap>& tile, |
| const absl::optional<Pixmap>& stipple, |
| const absl::optional<int32_t>& tile_stipple_x_origin, |
| const absl::optional<int32_t>& tile_stipple_y_origin, |
| const absl::optional<Font>& font, |
| const absl::optional<SubwindowMode>& subwindow_mode, |
| const absl::optional<Bool32>& graphics_exposures, |
| const absl::optional<int32_t>& clip_x_origin, |
| const absl::optional<int32_t>& clip_y_origin, |
| const absl::optional<Pixmap>& clip_mask, |
| const absl::optional<uint32_t>& dash_offset, |
| const absl::optional<uint32_t>& dashes, |
| const absl::optional<ArcMode>& arc_mode) { |
| return XProto::CreateGC(CreateGCRequest{cid, |
| drawable, |
| function, |
| plane_mask, |
| foreground, |
| background, |
| line_width, |
| line_style, |
| cap_style, |
| join_style, |
| fill_style, |
| fill_rule, |
| tile, |
| stipple, |
| tile_stipple_x_origin, |
| tile_stipple_y_origin, |
| font, |
| subwindow_mode, |
| graphics_exposures, |
| clip_x_origin, |
| clip_y_origin, |
| clip_mask, |
| dash_offset, |
| dashes, |
| arc_mode}); |
| } |
| |
| Future<void> XProto::ChangeGC(const ChangeGCRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& gc = request.gc; |
| GraphicsContextAttribute value_mask{}; |
| auto& value_list = request; |
| |
| // major_opcode |
| uint8_t major_opcode = 56; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // value_mask |
| SwitchVar(GraphicsContextAttribute::Function, value_list.function.has_value(), |
| true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::PlaneMask, |
| value_list.plane_mask.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::Foreground, |
| value_list.foreground.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::Background, |
| value_list.background.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::LineWidth, |
| value_list.line_width.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::LineStyle, |
| value_list.line_style.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::CapStyle, |
| value_list.cap_style.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::JoinStyle, |
| value_list.join_style.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::FillStyle, |
| value_list.fill_style.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::FillRule, |
| value_list.fill_rule.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::Tile, value_list.tile.has_value(), true, |
| &value_mask); |
| SwitchVar(GraphicsContextAttribute::Stipple, value_list.stipple.has_value(), |
| true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::TileStippleOriginX, |
| value_list.tile_stipple_x_origin.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::TileStippleOriginY, |
| value_list.tile_stipple_y_origin.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::Font, value_list.font.has_value(), true, |
| &value_mask); |
| SwitchVar(GraphicsContextAttribute::SubwindowMode, |
| value_list.subwindow_mode.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::GraphicsExposures, |
| value_list.graphics_exposures.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::ClipOriginX, |
| value_list.clip_x_origin.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::ClipOriginY, |
| value_list.clip_y_origin.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::ClipMask, |
| value_list.clip_mask.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::DashOffset, |
| value_list.dash_offset.has_value(), true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::DashList, value_list.dashes.has_value(), |
| true, &value_mask); |
| SwitchVar(GraphicsContextAttribute::ArcMode, value_list.arc_mode.has_value(), |
| true, &value_mask); |
| uint32_t tmp88; |
| tmp88 = static_cast<uint32_t>(value_mask); |
| buf.Write(&tmp88); |
| |
| // value_list |
| auto value_list_expr = value_mask; |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::Function)) { |
| auto& function = *value_list.function; |
| |
| // function |
| uint32_t tmp89; |
| tmp89 = static_cast<uint32_t>(function); |
| buf.Write(&tmp89); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::PlaneMask)) { |
| auto& plane_mask = *value_list.plane_mask; |
| |
| // plane_mask |
| buf.Write(&plane_mask); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::Foreground)) { |
| auto& foreground = *value_list.foreground; |
| |
| // foreground |
| buf.Write(&foreground); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::Background)) { |
| auto& background = *value_list.background; |
| |
| // background |
| buf.Write(&background); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::LineWidth)) { |
| auto& line_width = *value_list.line_width; |
| |
| // line_width |
| buf.Write(&line_width); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::LineStyle)) { |
| auto& line_style = *value_list.line_style; |
| |
| // line_style |
| uint32_t tmp90; |
| tmp90 = static_cast<uint32_t>(line_style); |
| buf.Write(&tmp90); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::CapStyle)) { |
| auto& cap_style = *value_list.cap_style; |
| |
| // cap_style |
| uint32_t tmp91; |
| tmp91 = static_cast<uint32_t>(cap_style); |
| buf.Write(&tmp91); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::JoinStyle)) { |
| auto& join_style = *value_list.join_style; |
| |
| // join_style |
| uint32_t tmp92; |
| tmp92 = static_cast<uint32_t>(join_style); |
| buf.Write(&tmp92); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::FillStyle)) { |
| auto& fill_style = *value_list.fill_style; |
| |
| // fill_style |
| uint32_t tmp93; |
| tmp93 = static_cast<uint32_t>(fill_style); |
| buf.Write(&tmp93); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::FillRule)) { |
| auto& fill_rule = *value_list.fill_rule; |
| |
| // fill_rule |
| uint32_t tmp94; |
| tmp94 = static_cast<uint32_t>(fill_rule); |
| buf.Write(&tmp94); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::Tile)) { |
| auto& tile = *value_list.tile; |
| |
| // tile |
| buf.Write(&tile); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::Stipple)) { |
| auto& stipple = *value_list.stipple; |
| |
| // stipple |
| buf.Write(&stipple); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::TileStippleOriginX)) { |
| auto& tile_stipple_x_origin = *value_list.tile_stipple_x_origin; |
| |
| // tile_stipple_x_origin |
| buf.Write(&tile_stipple_x_origin); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::TileStippleOriginY)) { |
| auto& tile_stipple_y_origin = *value_list.tile_stipple_y_origin; |
| |
| // tile_stipple_y_origin |
| buf.Write(&tile_stipple_y_origin); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::Font)) { |
| auto& font = *value_list.font; |
| |
| // font |
| buf.Write(&font); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::SubwindowMode)) { |
| auto& subwindow_mode = *value_list.subwindow_mode; |
| |
| // subwindow_mode |
| uint32_t tmp95; |
| tmp95 = static_cast<uint32_t>(subwindow_mode); |
| buf.Write(&tmp95); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::GraphicsExposures)) { |
| auto& graphics_exposures = *value_list.graphics_exposures; |
| |
| // graphics_exposures |
| buf.Write(&graphics_exposures); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::ClipOriginX)) { |
| auto& clip_x_origin = *value_list.clip_x_origin; |
| |
| // clip_x_origin |
| buf.Write(&clip_x_origin); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::ClipOriginY)) { |
| auto& clip_y_origin = *value_list.clip_y_origin; |
| |
| // clip_y_origin |
| buf.Write(&clip_y_origin); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::ClipMask)) { |
| auto& clip_mask = *value_list.clip_mask; |
| |
| // clip_mask |
| buf.Write(&clip_mask); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::DashOffset)) { |
| auto& dash_offset = *value_list.dash_offset; |
| |
| // dash_offset |
| buf.Write(&dash_offset); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::DashList)) { |
| auto& dashes = *value_list.dashes; |
| |
| // dashes |
| buf.Write(&dashes); |
| } |
| if (CaseAnd(value_list_expr, GraphicsContextAttribute::ArcMode)) { |
| auto& arc_mode = *value_list.arc_mode; |
| |
| // arc_mode |
| uint32_t tmp96; |
| tmp96 = static_cast<uint32_t>(arc_mode); |
| buf.Write(&tmp96); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ChangeGC", false); |
| } |
| |
| Future<void> XProto::ChangeGC( |
| const GraphicsContext& gc, |
| const absl::optional<Gx>& function, |
| const absl::optional<uint32_t>& plane_mask, |
| const absl::optional<uint32_t>& foreground, |
| const absl::optional<uint32_t>& background, |
| const absl::optional<uint32_t>& line_width, |
| const absl::optional<LineStyle>& line_style, |
| const absl::optional<CapStyle>& cap_style, |
| const absl::optional<JoinStyle>& join_style, |
| const absl::optional<FillStyle>& fill_style, |
| const absl::optional<FillRule>& fill_rule, |
| const absl::optional<Pixmap>& tile, |
| const absl::optional<Pixmap>& stipple, |
| const absl::optional<int32_t>& tile_stipple_x_origin, |
| const absl::optional<int32_t>& tile_stipple_y_origin, |
| const absl::optional<Font>& font, |
| const absl::optional<SubwindowMode>& subwindow_mode, |
| const absl::optional<Bool32>& graphics_exposures, |
| const absl::optional<int32_t>& clip_x_origin, |
| const absl::optional<int32_t>& clip_y_origin, |
| const absl::optional<Pixmap>& clip_mask, |
| const absl::optional<uint32_t>& dash_offset, |
| const absl::optional<uint32_t>& dashes, |
| const absl::optional<ArcMode>& arc_mode) { |
| return XProto::ChangeGC(ChangeGCRequest{gc, |
| function, |
| plane_mask, |
| foreground, |
| background, |
| line_width, |
| line_style, |
| cap_style, |
| join_style, |
| fill_style, |
| fill_rule, |
| tile, |
| stipple, |
| tile_stipple_x_origin, |
| tile_stipple_y_origin, |
| font, |
| subwindow_mode, |
| graphics_exposures, |
| clip_x_origin, |
| clip_y_origin, |
| clip_mask, |
| dash_offset, |
| dashes, |
| arc_mode}); |
| } |
| |
| Future<void> XProto::CopyGC(const CopyGCRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& src_gc = request.src_gc; |
| auto& dst_gc = request.dst_gc; |
| auto& value_mask = request.value_mask; |
| |
| // major_opcode |
| uint8_t major_opcode = 57; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // src_gc |
| buf.Write(&src_gc); |
| |
| // dst_gc |
| buf.Write(&dst_gc); |
| |
| // value_mask |
| uint32_t tmp97; |
| tmp97 = static_cast<uint32_t>(value_mask); |
| buf.Write(&tmp97); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "CopyGC", false); |
| } |
| |
| Future<void> XProto::CopyGC(const GraphicsContext& src_gc, |
| const GraphicsContext& dst_gc, |
| const GraphicsContextAttribute& value_mask) { |
| return XProto::CopyGC(CopyGCRequest{src_gc, dst_gc, value_mask}); |
| } |
| |
| Future<void> XProto::SetDashes(const SetDashesRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& gc = request.gc; |
| auto& dash_offset = request.dash_offset; |
| uint16_t dashes_len{}; |
| auto& dashes = request.dashes; |
| |
| // major_opcode |
| uint8_t major_opcode = 58; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // dash_offset |
| buf.Write(&dash_offset); |
| |
| // dashes_len |
| dashes_len = dashes.size(); |
| buf.Write(&dashes_len); |
| |
| // dashes |
| DCHECK_EQ(static_cast<size_t>(dashes_len), dashes.size()); |
| for (auto& dashes_elem : dashes) { |
| // dashes_elem |
| buf.Write(&dashes_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "SetDashes", false); |
| } |
| |
| Future<void> XProto::SetDashes(const GraphicsContext& gc, |
| const uint16_t& dash_offset, |
| const std::vector<uint8_t>& dashes) { |
| return XProto::SetDashes(SetDashesRequest{gc, dash_offset, dashes}); |
| } |
| |
| Future<void> XProto::SetClipRectangles( |
| const SetClipRectanglesRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& ordering = request.ordering; |
| auto& gc = request.gc; |
| auto& clip_x_origin = request.clip_x_origin; |
| auto& clip_y_origin = request.clip_y_origin; |
| auto& rectangles = request.rectangles; |
| size_t rectangles_len = rectangles.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 59; |
| buf.Write(&major_opcode); |
| |
| // ordering |
| uint8_t tmp98; |
| tmp98 = static_cast<uint8_t>(ordering); |
| buf.Write(&tmp98); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // clip_x_origin |
| buf.Write(&clip_x_origin); |
| |
| // clip_y_origin |
| buf.Write(&clip_y_origin); |
| |
| // 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, "SetClipRectangles", false); |
| } |
| |
| Future<void> XProto::SetClipRectangles( |
| const ClipOrdering& ordering, |
| const GraphicsContext& gc, |
| const int16_t& clip_x_origin, |
| const int16_t& clip_y_origin, |
| const std::vector<Rectangle>& rectangles) { |
| return XProto::SetClipRectangles(SetClipRectanglesRequest{ |
| ordering, gc, clip_x_origin, clip_y_origin, rectangles}); |
| } |
| |
| Future<void> XProto::FreeGC(const FreeGCRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& gc = request.gc; |
| |
| // major_opcode |
| uint8_t major_opcode = 60; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // gc |
| buf.Write(&gc); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "FreeGC", false); |
| } |
| |
| Future<void> XProto::FreeGC(const GraphicsContext& gc) { |
| return XProto::FreeGC(FreeGCRequest{gc}); |
| } |
| |
| Future<void> XProto::ClearArea(const ClearAreaRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& exposures = request.exposures; |
| auto& window = request.window; |
| auto& x = request.x; |
| auto& y = request.y; |
| auto& width = request.width; |
| auto& height = request.height; |
| |
| // major_opcode |
| uint8_t major_opcode = 61; |
| buf.Write(&major_opcode); |
| |
| // exposures |
| buf.Write(&exposures); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ClearArea", false); |
| } |
| |
| Future<void> XProto::ClearArea(const uint8_t& exposures, |
| const Window& window, |
| const int16_t& x, |
| const int16_t& y, |
| const uint16_t& width, |
| const uint16_t& height) { |
| return XProto::ClearArea( |
| ClearAreaRequest{exposures, window, x, y, width, height}); |
| } |
| |
| Future<void> XProto::CopyArea(const CopyAreaRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& src_drawable = request.src_drawable; |
| auto& dst_drawable = request.dst_drawable; |
| auto& gc = request.gc; |
| auto& src_x = request.src_x; |
| auto& src_y = request.src_y; |
| auto& dst_x = request.dst_x; |
| auto& dst_y = request.dst_y; |
| auto& width = request.width; |
| auto& height = request.height; |
| |
| // major_opcode |
| uint8_t major_opcode = 62; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // src_drawable |
| buf.Write(&src_drawable); |
| |
| // dst_drawable |
| buf.Write(&dst_drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // src_x |
| buf.Write(&src_x); |
| |
| // src_y |
| buf.Write(&src_y); |
| |
| // dst_x |
| buf.Write(&dst_x); |
| |
| // dst_y |
| buf.Write(&dst_y); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "CopyArea", false); |
| } |
| |
| Future<void> XProto::CopyArea(const Drawable& src_drawable, |
| const Drawable& dst_drawable, |
| const GraphicsContext& gc, |
| const int16_t& src_x, |
| const int16_t& src_y, |
| const int16_t& dst_x, |
| const int16_t& dst_y, |
| const uint16_t& width, |
| const uint16_t& height) { |
| return XProto::CopyArea(CopyAreaRequest{src_drawable, dst_drawable, gc, src_x, |
| src_y, dst_x, dst_y, width, height}); |
| } |
| |
| Future<void> XProto::CopyPlane(const CopyPlaneRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& src_drawable = request.src_drawable; |
| auto& dst_drawable = request.dst_drawable; |
| auto& gc = request.gc; |
| auto& src_x = request.src_x; |
| auto& src_y = request.src_y; |
| auto& dst_x = request.dst_x; |
| auto& dst_y = request.dst_y; |
| auto& width = request.width; |
| auto& height = request.height; |
| auto& bit_plane = request.bit_plane; |
| |
| // major_opcode |
| uint8_t major_opcode = 63; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // src_drawable |
| buf.Write(&src_drawable); |
| |
| // dst_drawable |
| buf.Write(&dst_drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // src_x |
| buf.Write(&src_x); |
| |
| // src_y |
| buf.Write(&src_y); |
| |
| // dst_x |
| buf.Write(&dst_x); |
| |
| // dst_y |
| buf.Write(&dst_y); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| |
| // bit_plane |
| buf.Write(&bit_plane); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "CopyPlane", false); |
| } |
| |
| Future<void> XProto::CopyPlane(const Drawable& src_drawable, |
| const Drawable& dst_drawable, |
| const GraphicsContext& gc, |
| const int16_t& src_x, |
| const int16_t& src_y, |
| const int16_t& dst_x, |
| const int16_t& dst_y, |
| const uint16_t& width, |
| const uint16_t& height, |
| const uint32_t& bit_plane) { |
| return XProto::CopyPlane(CopyPlaneRequest{src_drawable, dst_drawable, gc, |
| src_x, src_y, dst_x, dst_y, width, |
| height, bit_plane}); |
| } |
| |
| Future<void> XProto::PolyPoint(const PolyPointRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& coordinate_mode = request.coordinate_mode; |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& points = request.points; |
| size_t points_len = points.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 64; |
| buf.Write(&major_opcode); |
| |
| // coordinate_mode |
| uint8_t tmp99; |
| tmp99 = static_cast<uint8_t>(coordinate_mode); |
| buf.Write(&tmp99); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // points |
| DCHECK_EQ(static_cast<size_t>(points_len), points.size()); |
| for (auto& points_elem : points) { |
| // points_elem |
| { |
| auto& x = points_elem.x; |
| auto& y = points_elem.y; |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "PolyPoint", false); |
| } |
| |
| Future<void> XProto::PolyPoint(const CoordMode& coordinate_mode, |
| const Drawable& drawable, |
| const GraphicsContext& gc, |
| const std::vector<Point>& points) { |
| return XProto::PolyPoint( |
| PolyPointRequest{coordinate_mode, drawable, gc, points}); |
| } |
| |
| Future<void> XProto::PolyLine(const PolyLineRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& coordinate_mode = request.coordinate_mode; |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& points = request.points; |
| size_t points_len = points.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 65; |
| buf.Write(&major_opcode); |
| |
| // coordinate_mode |
| uint8_t tmp100; |
| tmp100 = static_cast<uint8_t>(coordinate_mode); |
| buf.Write(&tmp100); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // points |
| DCHECK_EQ(static_cast<size_t>(points_len), points.size()); |
| for (auto& points_elem : points) { |
| // points_elem |
| { |
| auto& x = points_elem.x; |
| auto& y = points_elem.y; |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "PolyLine", false); |
| } |
| |
| Future<void> XProto::PolyLine(const CoordMode& coordinate_mode, |
| const Drawable& drawable, |
| const GraphicsContext& gc, |
| const std::vector<Point>& points) { |
| return XProto::PolyLine( |
| PolyLineRequest{coordinate_mode, drawable, gc, points}); |
| } |
| |
| Future<void> XProto::PolySegment(const PolySegmentRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& segments = request.segments; |
| size_t segments_len = segments.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 66; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // segments |
| DCHECK_EQ(static_cast<size_t>(segments_len), segments.size()); |
| for (auto& segments_elem : segments) { |
| // segments_elem |
| { |
| auto& x1 = segments_elem.x1; |
| auto& y1 = segments_elem.y1; |
| auto& x2 = segments_elem.x2; |
| auto& y2 = segments_elem.y2; |
| |
| // x1 |
| buf.Write(&x1); |
| |
| // y1 |
| buf.Write(&y1); |
| |
| // x2 |
| buf.Write(&x2); |
| |
| // y2 |
| buf.Write(&y2); |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "PolySegment", false); |
| } |
| |
| Future<void> XProto::PolySegment(const Drawable& drawable, |
| const GraphicsContext& gc, |
| const std::vector<Segment>& segments) { |
| return XProto::PolySegment(PolySegmentRequest{drawable, gc, segments}); |
| } |
| |
| Future<void> XProto::PolyRectangle(const PolyRectangleRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& rectangles = request.rectangles; |
| size_t rectangles_len = rectangles.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 67; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // 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, "PolyRectangle", false); |
| } |
| |
| Future<void> XProto::PolyRectangle(const Drawable& drawable, |
| const GraphicsContext& gc, |
| const std::vector<Rectangle>& rectangles) { |
| return XProto::PolyRectangle(PolyRectangleRequest{drawable, gc, rectangles}); |
| } |
| |
| Future<void> XProto::PolyArc(const PolyArcRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& arcs = request.arcs; |
| size_t arcs_len = arcs.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 68; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // arcs |
| DCHECK_EQ(static_cast<size_t>(arcs_len), arcs.size()); |
| for (auto& arcs_elem : arcs) { |
| // arcs_elem |
| { |
| auto& x = arcs_elem.x; |
| auto& y = arcs_elem.y; |
| auto& width = arcs_elem.width; |
| auto& height = arcs_elem.height; |
| auto& angle1 = arcs_elem.angle1; |
| auto& angle2 = arcs_elem.angle2; |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| |
| // angle1 |
| buf.Write(&angle1); |
| |
| // angle2 |
| buf.Write(&angle2); |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "PolyArc", false); |
| } |
| |
| Future<void> XProto::PolyArc(const Drawable& drawable, |
| const GraphicsContext& gc, |
| const std::vector<Arc>& arcs) { |
| return XProto::PolyArc(PolyArcRequest{drawable, gc, arcs}); |
| } |
| |
| Future<void> XProto::FillPoly(const FillPolyRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& shape = request.shape; |
| auto& coordinate_mode = request.coordinate_mode; |
| auto& points = request.points; |
| size_t points_len = points.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 69; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // shape |
| uint8_t tmp101; |
| tmp101 = static_cast<uint8_t>(shape); |
| buf.Write(&tmp101); |
| |
| // coordinate_mode |
| uint8_t tmp102; |
| tmp102 = static_cast<uint8_t>(coordinate_mode); |
| buf.Write(&tmp102); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| // points |
| DCHECK_EQ(static_cast<size_t>(points_len), points.size()); |
| for (auto& points_elem : points) { |
| // points_elem |
| { |
| auto& x = points_elem.x; |
| auto& y = points_elem.y; |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "FillPoly", false); |
| } |
| |
| Future<void> XProto::FillPoly(const Drawable& drawable, |
| const GraphicsContext& gc, |
| const PolyShape& shape, |
| const CoordMode& coordinate_mode, |
| const std::vector<Point>& points) { |
| return XProto::FillPoly( |
| FillPolyRequest{drawable, gc, shape, coordinate_mode, points}); |
| } |
| |
| Future<void> XProto::PolyFillRectangle( |
| const PolyFillRectangleRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& rectangles = request.rectangles; |
| size_t rectangles_len = rectangles.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 70; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // 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, "PolyFillRectangle", false); |
| } |
| |
| Future<void> XProto::PolyFillRectangle( |
| const Drawable& drawable, |
| const GraphicsContext& gc, |
| const std::vector<Rectangle>& rectangles) { |
| return XProto::PolyFillRectangle( |
| PolyFillRectangleRequest{drawable, gc, rectangles}); |
| } |
| |
| Future<void> XProto::PolyFillArc(const PolyFillArcRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& arcs = request.arcs; |
| size_t arcs_len = arcs.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 71; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // arcs |
| DCHECK_EQ(static_cast<size_t>(arcs_len), arcs.size()); |
| for (auto& arcs_elem : arcs) { |
| // arcs_elem |
| { |
| auto& x = arcs_elem.x; |
| auto& y = arcs_elem.y; |
| auto& width = arcs_elem.width; |
| auto& height = arcs_elem.height; |
| auto& angle1 = arcs_elem.angle1; |
| auto& angle2 = arcs_elem.angle2; |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| |
| // angle1 |
| buf.Write(&angle1); |
| |
| // angle2 |
| buf.Write(&angle2); |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "PolyFillArc", false); |
| } |
| |
| Future<void> XProto::PolyFillArc(const Drawable& drawable, |
| const GraphicsContext& gc, |
| const std::vector<Arc>& arcs) { |
| return XProto::PolyFillArc(PolyFillArcRequest{drawable, gc, arcs}); |
| } |
| |
| Future<void> XProto::PutImage(const PutImageRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& format = request.format; |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& width = request.width; |
| auto& height = request.height; |
| auto& dst_x = request.dst_x; |
| auto& dst_y = request.dst_y; |
| auto& left_pad = request.left_pad; |
| auto& depth = request.depth; |
| auto& data = request.data; |
| size_t data_len = data ? data->size() : 0; |
| |
| // major_opcode |
| uint8_t major_opcode = 72; |
| buf.Write(&major_opcode); |
| |
| // format |
| uint8_t tmp103; |
| tmp103 = static_cast<uint8_t>(format); |
| buf.Write(&tmp103); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| |
| // dst_x |
| buf.Write(&dst_x); |
| |
| // dst_y |
| buf.Write(&dst_y); |
| |
| // left_pad |
| buf.Write(&left_pad); |
| |
| // depth |
| buf.Write(&depth); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| // data |
| buf.AppendBuffer(data, data_len); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "PutImage", false); |
| } |
| |
| Future<void> XProto::PutImage( |
| const ImageFormat& format, |
| const Drawable& drawable, |
| const GraphicsContext& gc, |
| const uint16_t& width, |
| const uint16_t& height, |
| const int16_t& dst_x, |
| const int16_t& dst_y, |
| const uint8_t& left_pad, |
| const uint8_t& depth, |
| const scoped_refptr<base::RefCountedMemory>& data) { |
| return XProto::PutImage(PutImageRequest{format, drawable, gc, width, height, |
| dst_x, dst_y, left_pad, depth, data}); |
| } |
| |
| Future<GetImageReply> XProto::GetImage(const GetImageRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& format = request.format; |
| auto& drawable = request.drawable; |
| auto& x = request.x; |
| auto& y = request.y; |
| auto& width = request.width; |
| auto& height = request.height; |
| auto& plane_mask = request.plane_mask; |
| |
| // major_opcode |
| uint8_t major_opcode = 73; |
| buf.Write(&major_opcode); |
| |
| // format |
| uint8_t tmp104; |
| tmp104 = static_cast<uint8_t>(format); |
| buf.Write(&tmp104); |
| |
| // 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); |
| |
| // plane_mask |
| buf.Write(&plane_mask); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetImageReply>(&buf, "GetImage", false); |
| } |
| |
| Future<GetImageReply> XProto::GetImage(const ImageFormat& format, |
| const Drawable& drawable, |
| const int16_t& x, |
| const int16_t& y, |
| const uint16_t& width, |
| const uint16_t& height, |
| const uint32_t& plane_mask) { |
| return XProto::GetImage( |
| GetImageRequest{format, drawable, x, y, width, height, plane_mask}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetImageReply> detail::ReadReply<GetImageReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetImageReply>(); |
| |
| auto& depth = (*reply).depth; |
| auto& sequence = (*reply).sequence; |
| auto& visual = (*reply).visual; |
| auto& data = (*reply).data; |
| size_t data_len = data ? data->size() : 0; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // depth |
| Read(&depth, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // visual |
| Read(&visual, &buf); |
| |
| // pad0 |
| Pad(&buf, 20); |
| |
| // data |
| data = buffer->ReadAndAdvance((length) * (4)); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::PolyText8(const PolyText8Request& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& x = request.x; |
| auto& y = request.y; |
| auto& items = request.items; |
| size_t items_len = items.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 74; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // items |
| DCHECK_EQ(static_cast<size_t>(items_len), items.size()); |
| for (auto& items_elem : items) { |
| // items_elem |
| buf.Write(&items_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "PolyText8", false); |
| } |
| |
| Future<void> XProto::PolyText8(const Drawable& drawable, |
| const GraphicsContext& gc, |
| const int16_t& x, |
| const int16_t& y, |
| const std::vector<uint8_t>& items) { |
| return XProto::PolyText8(PolyText8Request{drawable, gc, x, y, items}); |
| } |
| |
| Future<void> XProto::PolyText16(const PolyText16Request& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& x = request.x; |
| auto& y = request.y; |
| auto& items = request.items; |
| size_t items_len = items.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 75; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // items |
| DCHECK_EQ(static_cast<size_t>(items_len), items.size()); |
| for (auto& items_elem : items) { |
| // items_elem |
| buf.Write(&items_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "PolyText16", false); |
| } |
| |
| Future<void> XProto::PolyText16(const Drawable& drawable, |
| const GraphicsContext& gc, |
| const int16_t& x, |
| const int16_t& y, |
| const std::vector<uint8_t>& items) { |
| return XProto::PolyText16(PolyText16Request{drawable, gc, x, y, items}); |
| } |
| |
| Future<void> XProto::ImageText8(const ImageText8Request& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| uint8_t string_len{}; |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& x = request.x; |
| auto& y = request.y; |
| auto& string = request.string; |
| |
| // major_opcode |
| uint8_t major_opcode = 76; |
| buf.Write(&major_opcode); |
| |
| // string_len |
| string_len = string.size(); |
| buf.Write(&string_len); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // string |
| DCHECK_EQ(static_cast<size_t>(string_len), string.size()); |
| for (auto& string_elem : string) { |
| // string_elem |
| buf.Write(&string_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ImageText8", false); |
| } |
| |
| Future<void> XProto::ImageText8(const Drawable& drawable, |
| const GraphicsContext& gc, |
| const int16_t& x, |
| const int16_t& y, |
| const std::string& string) { |
| return XProto::ImageText8(ImageText8Request{drawable, gc, x, y, string}); |
| } |
| |
| Future<void> XProto::ImageText16(const ImageText16Request& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| uint8_t string_len{}; |
| auto& drawable = request.drawable; |
| auto& gc = request.gc; |
| auto& x = request.x; |
| auto& y = request.y; |
| auto& string = request.string; |
| |
| // major_opcode |
| uint8_t major_opcode = 77; |
| buf.Write(&major_opcode); |
| |
| // string_len |
| string_len = string.size(); |
| buf.Write(&string_len); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // gc |
| buf.Write(&gc); |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| // string |
| DCHECK_EQ(static_cast<size_t>(string_len), string.size()); |
| for (auto& string_elem : string) { |
| // string_elem |
| { |
| auto& byte1 = string_elem.byte1; |
| auto& byte2 = string_elem.byte2; |
| |
| // byte1 |
| buf.Write(&byte1); |
| |
| // byte2 |
| buf.Write(&byte2); |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ImageText16", false); |
| } |
| |
| Future<void> XProto::ImageText16(const Drawable& drawable, |
| const GraphicsContext& gc, |
| const int16_t& x, |
| const int16_t& y, |
| const std::vector<Char16>& string) { |
| return XProto::ImageText16(ImageText16Request{drawable, gc, x, y, string}); |
| } |
| |
| Future<void> XProto::CreateColormap(const CreateColormapRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& alloc = request.alloc; |
| auto& mid = request.mid; |
| auto& window = request.window; |
| auto& visual = request.visual; |
| |
| // major_opcode |
| uint8_t major_opcode = 78; |
| buf.Write(&major_opcode); |
| |
| // alloc |
| uint8_t tmp105; |
| tmp105 = static_cast<uint8_t>(alloc); |
| buf.Write(&tmp105); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // mid |
| buf.Write(&mid); |
| |
| // window |
| buf.Write(&window); |
| |
| // visual |
| buf.Write(&visual); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "CreateColormap", false); |
| } |
| |
| Future<void> XProto::CreateColormap(const ColormapAlloc& alloc, |
| const ColorMap& mid, |
| const Window& window, |
| const VisualId& visual) { |
| return XProto::CreateColormap( |
| CreateColormapRequest{alloc, mid, window, visual}); |
| } |
| |
| Future<void> XProto::FreeColormap(const FreeColormapRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cmap = request.cmap; |
| |
| // major_opcode |
| uint8_t major_opcode = 79; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cmap |
| buf.Write(&cmap); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "FreeColormap", false); |
| } |
| |
| Future<void> XProto::FreeColormap(const ColorMap& cmap) { |
| return XProto::FreeColormap(FreeColormapRequest{cmap}); |
| } |
| |
| Future<void> XProto::CopyColormapAndFree( |
| const CopyColormapAndFreeRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& mid = request.mid; |
| auto& src_cmap = request.src_cmap; |
| |
| // major_opcode |
| uint8_t major_opcode = 80; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // mid |
| buf.Write(&mid); |
| |
| // src_cmap |
| buf.Write(&src_cmap); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "CopyColormapAndFree", false); |
| } |
| |
| Future<void> XProto::CopyColormapAndFree(const ColorMap& mid, |
| const ColorMap& src_cmap) { |
| return XProto::CopyColormapAndFree(CopyColormapAndFreeRequest{mid, src_cmap}); |
| } |
| |
| Future<void> XProto::InstallColormap(const InstallColormapRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cmap = request.cmap; |
| |
| // major_opcode |
| uint8_t major_opcode = 81; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cmap |
| buf.Write(&cmap); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "InstallColormap", false); |
| } |
| |
| Future<void> XProto::InstallColormap(const ColorMap& cmap) { |
| return XProto::InstallColormap(InstallColormapRequest{cmap}); |
| } |
| |
| Future<void> XProto::UninstallColormap( |
| const UninstallColormapRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cmap = request.cmap; |
| |
| // major_opcode |
| uint8_t major_opcode = 82; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cmap |
| buf.Write(&cmap); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "UninstallColormap", false); |
| } |
| |
| Future<void> XProto::UninstallColormap(const ColorMap& cmap) { |
| return XProto::UninstallColormap(UninstallColormapRequest{cmap}); |
| } |
| |
| Future<ListInstalledColormapsReply> XProto::ListInstalledColormaps( |
| const ListInstalledColormapsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| |
| // major_opcode |
| uint8_t major_opcode = 83; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<ListInstalledColormapsReply>( |
| &buf, "ListInstalledColormaps", false); |
| } |
| |
| Future<ListInstalledColormapsReply> XProto::ListInstalledColormaps( |
| const Window& window) { |
| return XProto::ListInstalledColormaps(ListInstalledColormapsRequest{window}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<ListInstalledColormapsReply> detail::ReadReply< |
| ListInstalledColormapsReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<ListInstalledColormapsReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| uint16_t cmaps_len{}; |
| auto& cmaps = (*reply).cmaps; |
| |
| // 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); |
| |
| // cmaps_len |
| Read(&cmaps_len, &buf); |
| |
| // pad1 |
| Pad(&buf, 22); |
| |
| // cmaps |
| cmaps.resize(cmaps_len); |
| for (auto& cmaps_elem : cmaps) { |
| // cmaps_elem |
| Read(&cmaps_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<AllocColorReply> XProto::AllocColor(const AllocColorRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cmap = request.cmap; |
| auto& red = request.red; |
| auto& green = request.green; |
| auto& blue = request.blue; |
| |
| // major_opcode |
| uint8_t major_opcode = 84; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cmap |
| buf.Write(&cmap); |
| |
| // red |
| buf.Write(&red); |
| |
| // green |
| buf.Write(&green); |
| |
| // blue |
| buf.Write(&blue); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<AllocColorReply>(&buf, "AllocColor", false); |
| } |
| |
| Future<AllocColorReply> XProto::AllocColor(const ColorMap& cmap, |
| const uint16_t& red, |
| const uint16_t& green, |
| const uint16_t& blue) { |
| return XProto::AllocColor(AllocColorRequest{cmap, red, green, blue}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<AllocColorReply> detail::ReadReply<AllocColorReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<AllocColorReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& red = (*reply).red; |
| auto& green = (*reply).green; |
| auto& blue = (*reply).blue; |
| auto& pixel = (*reply).pixel; |
| |
| // 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); |
| |
| // red |
| Read(&red, &buf); |
| |
| // green |
| Read(&green, &buf); |
| |
| // blue |
| Read(&blue, &buf); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| // pixel |
| Read(&pixel, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<AllocNamedColorReply> XProto::AllocNamedColor( |
| const AllocNamedColorRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cmap = request.cmap; |
| uint16_t name_len{}; |
| auto& name = request.name; |
| |
| // major_opcode |
| uint8_t major_opcode = 85; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cmap |
| buf.Write(&cmap); |
| |
| // name_len |
| name_len = name.size(); |
| buf.Write(&name_len); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| // name |
| DCHECK_EQ(static_cast<size_t>(name_len), name.size()); |
| for (auto& name_elem : name) { |
| // name_elem |
| buf.Write(&name_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<AllocNamedColorReply>(&buf, "AllocNamedColor", |
| false); |
| } |
| |
| Future<AllocNamedColorReply> XProto::AllocNamedColor(const ColorMap& cmap, |
| const std::string& name) { |
| return XProto::AllocNamedColor(AllocNamedColorRequest{cmap, name}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<AllocNamedColorReply> detail::ReadReply<AllocNamedColorReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<AllocNamedColorReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& pixel = (*reply).pixel; |
| auto& exact_red = (*reply).exact_red; |
| auto& exact_green = (*reply).exact_green; |
| auto& exact_blue = (*reply).exact_blue; |
| auto& visual_red = (*reply).visual_red; |
| auto& visual_green = (*reply).visual_green; |
| auto& visual_blue = (*reply).visual_blue; |
| |
| // 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); |
| |
| // pixel |
| Read(&pixel, &buf); |
| |
| // exact_red |
| Read(&exact_red, &buf); |
| |
| // exact_green |
| Read(&exact_green, &buf); |
| |
| // exact_blue |
| Read(&exact_blue, &buf); |
| |
| // visual_red |
| Read(&visual_red, &buf); |
| |
| // visual_green |
| Read(&visual_green, &buf); |
| |
| // visual_blue |
| Read(&visual_blue, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<AllocColorCellsReply> XProto::AllocColorCells( |
| const AllocColorCellsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& contiguous = request.contiguous; |
| auto& cmap = request.cmap; |
| auto& colors = request.colors; |
| auto& planes = request.planes; |
| |
| // major_opcode |
| uint8_t major_opcode = 86; |
| buf.Write(&major_opcode); |
| |
| // contiguous |
| buf.Write(&contiguous); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cmap |
| buf.Write(&cmap); |
| |
| // colors |
| buf.Write(&colors); |
| |
| // planes |
| buf.Write(&planes); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<AllocColorCellsReply>(&buf, "AllocColorCells", |
| false); |
| } |
| |
| Future<AllocColorCellsReply> XProto::AllocColorCells(const uint8_t& contiguous, |
| const ColorMap& cmap, |
| const uint16_t& colors, |
| const uint16_t& planes) { |
| return XProto::AllocColorCells( |
| AllocColorCellsRequest{contiguous, cmap, colors, planes}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<AllocColorCellsReply> detail::ReadReply<AllocColorCellsReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<AllocColorCellsReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| uint16_t pixels_len{}; |
| uint16_t masks_len{}; |
| auto& pixels = (*reply).pixels; |
| auto& masks = (*reply).masks; |
| |
| // 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); |
| |
| // pixels_len |
| Read(&pixels_len, &buf); |
| |
| // masks_len |
| Read(&masks_len, &buf); |
| |
| // pad1 |
| Pad(&buf, 20); |
| |
| // pixels |
| pixels.resize(pixels_len); |
| for (auto& pixels_elem : pixels) { |
| // pixels_elem |
| Read(&pixels_elem, &buf); |
| } |
| |
| // masks |
| masks.resize(masks_len); |
| for (auto& masks_elem : masks) { |
| // masks_elem |
| Read(&masks_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<AllocColorPlanesReply> XProto::AllocColorPlanes( |
| const AllocColorPlanesRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& contiguous = request.contiguous; |
| auto& cmap = request.cmap; |
| auto& colors = request.colors; |
| auto& reds = request.reds; |
| auto& greens = request.greens; |
| auto& blues = request.blues; |
| |
| // major_opcode |
| uint8_t major_opcode = 87; |
| buf.Write(&major_opcode); |
| |
| // contiguous |
| buf.Write(&contiguous); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cmap |
| buf.Write(&cmap); |
| |
| // colors |
| buf.Write(&colors); |
| |
| // reds |
| buf.Write(&reds); |
| |
| // greens |
| buf.Write(&greens); |
| |
| // blues |
| buf.Write(&blues); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<AllocColorPlanesReply>( |
| &buf, "AllocColorPlanes", false); |
| } |
| |
| Future<AllocColorPlanesReply> XProto::AllocColorPlanes( |
| const uint8_t& contiguous, |
| const ColorMap& cmap, |
| const uint16_t& colors, |
| const uint16_t& reds, |
| const uint16_t& greens, |
| const uint16_t& blues) { |
| return XProto::AllocColorPlanes( |
| AllocColorPlanesRequest{contiguous, cmap, colors, reds, greens, blues}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<AllocColorPlanesReply> detail::ReadReply<AllocColorPlanesReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<AllocColorPlanesReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| uint16_t pixels_len{}; |
| auto& red_mask = (*reply).red_mask; |
| auto& green_mask = (*reply).green_mask; |
| auto& blue_mask = (*reply).blue_mask; |
| auto& pixels = (*reply).pixels; |
| |
| // 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); |
| |
| // pixels_len |
| Read(&pixels_len, &buf); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| // red_mask |
| Read(&red_mask, &buf); |
| |
| // green_mask |
| Read(&green_mask, &buf); |
| |
| // blue_mask |
| Read(&blue_mask, &buf); |
| |
| // pad2 |
| Pad(&buf, 8); |
| |
| // pixels |
| pixels.resize(pixels_len); |
| for (auto& pixels_elem : pixels) { |
| // pixels_elem |
| Read(&pixels_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::FreeColors(const FreeColorsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cmap = request.cmap; |
| auto& plane_mask = request.plane_mask; |
| auto& pixels = request.pixels; |
| size_t pixels_len = pixels.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 88; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cmap |
| buf.Write(&cmap); |
| |
| // plane_mask |
| buf.Write(&plane_mask); |
| |
| // pixels |
| DCHECK_EQ(static_cast<size_t>(pixels_len), pixels.size()); |
| for (auto& pixels_elem : pixels) { |
| // pixels_elem |
| buf.Write(&pixels_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "FreeColors", false); |
| } |
| |
| Future<void> XProto::FreeColors(const ColorMap& cmap, |
| const uint32_t& plane_mask, |
| const std::vector<uint32_t>& pixels) { |
| return XProto::FreeColors(FreeColorsRequest{cmap, plane_mask, pixels}); |
| } |
| |
| Future<void> XProto::StoreColors(const StoreColorsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cmap = request.cmap; |
| auto& items = request.items; |
| size_t items_len = items.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 89; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cmap |
| buf.Write(&cmap); |
| |
| // items |
| DCHECK_EQ(static_cast<size_t>(items_len), items.size()); |
| for (auto& items_elem : items) { |
| // items_elem |
| { |
| auto& pixel = items_elem.pixel; |
| auto& red = items_elem.red; |
| auto& green = items_elem.green; |
| auto& blue = items_elem.blue; |
| auto& flags = items_elem.flags; |
| |
| // pixel |
| buf.Write(&pixel); |
| |
| // red |
| buf.Write(&red); |
| |
| // green |
| buf.Write(&green); |
| |
| // blue |
| buf.Write(&blue); |
| |
| // flags |
| uint8_t tmp106; |
| tmp106 = static_cast<uint8_t>(flags); |
| buf.Write(&tmp106); |
| |
| // pad0 |
| Pad(&buf, 1); |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "StoreColors", false); |
| } |
| |
| Future<void> XProto::StoreColors(const ColorMap& cmap, |
| const std::vector<ColorItem>& items) { |
| return XProto::StoreColors(StoreColorsRequest{cmap, items}); |
| } |
| |
| Future<void> XProto::StoreNamedColor(const StoreNamedColorRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& flags = request.flags; |
| auto& cmap = request.cmap; |
| auto& pixel = request.pixel; |
| uint16_t name_len{}; |
| auto& name = request.name; |
| |
| // major_opcode |
| uint8_t major_opcode = 90; |
| buf.Write(&major_opcode); |
| |
| // flags |
| uint8_t tmp107; |
| tmp107 = static_cast<uint8_t>(flags); |
| buf.Write(&tmp107); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cmap |
| buf.Write(&cmap); |
| |
| // pixel |
| buf.Write(&pixel); |
| |
| // name_len |
| name_len = name.size(); |
| buf.Write(&name_len); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| // name |
| DCHECK_EQ(static_cast<size_t>(name_len), name.size()); |
| for (auto& name_elem : name) { |
| // name_elem |
| buf.Write(&name_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "StoreNamedColor", false); |
| } |
| |
| Future<void> XProto::StoreNamedColor(const ColorFlag& flags, |
| const ColorMap& cmap, |
| const uint32_t& pixel, |
| const std::string& name) { |
| return XProto::StoreNamedColor( |
| StoreNamedColorRequest{flags, cmap, pixel, name}); |
| } |
| |
| Future<QueryColorsReply> XProto::QueryColors( |
| const QueryColorsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cmap = request.cmap; |
| auto& pixels = request.pixels; |
| size_t pixels_len = pixels.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 91; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cmap |
| buf.Write(&cmap); |
| |
| // pixels |
| DCHECK_EQ(static_cast<size_t>(pixels_len), pixels.size()); |
| for (auto& pixels_elem : pixels) { |
| // pixels_elem |
| buf.Write(&pixels_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<QueryColorsReply>(&buf, "QueryColors", false); |
| } |
| |
| Future<QueryColorsReply> XProto::QueryColors( |
| const ColorMap& cmap, |
| const std::vector<uint32_t>& pixels) { |
| return XProto::QueryColors(QueryColorsRequest{cmap, pixels}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<QueryColorsReply> detail::ReadReply<QueryColorsReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<QueryColorsReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| uint16_t colors_len{}; |
| auto& colors = (*reply).colors; |
| |
| // 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); |
| |
| // colors_len |
| Read(&colors_len, &buf); |
| |
| // pad1 |
| Pad(&buf, 22); |
| |
| // colors |
| colors.resize(colors_len); |
| for (auto& colors_elem : colors) { |
| // colors_elem |
| { |
| auto& red = colors_elem.red; |
| auto& green = colors_elem.green; |
| auto& blue = colors_elem.blue; |
| |
| // red |
| Read(&red, &buf); |
| |
| // green |
| Read(&green, &buf); |
| |
| // blue |
| Read(&blue, &buf); |
| |
| // pad0 |
| Pad(&buf, 2); |
| } |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<LookupColorReply> XProto::LookupColor( |
| const LookupColorRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cmap = request.cmap; |
| uint16_t name_len{}; |
| auto& name = request.name; |
| |
| // major_opcode |
| uint8_t major_opcode = 92; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cmap |
| buf.Write(&cmap); |
| |
| // name_len |
| name_len = name.size(); |
| buf.Write(&name_len); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| // name |
| DCHECK_EQ(static_cast<size_t>(name_len), name.size()); |
| for (auto& name_elem : name) { |
| // name_elem |
| buf.Write(&name_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<LookupColorReply>(&buf, "LookupColor", false); |
| } |
| |
| Future<LookupColorReply> XProto::LookupColor(const ColorMap& cmap, |
| const std::string& name) { |
| return XProto::LookupColor(LookupColorRequest{cmap, name}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<LookupColorReply> detail::ReadReply<LookupColorReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<LookupColorReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& exact_red = (*reply).exact_red; |
| auto& exact_green = (*reply).exact_green; |
| auto& exact_blue = (*reply).exact_blue; |
| auto& visual_red = (*reply).visual_red; |
| auto& visual_green = (*reply).visual_green; |
| auto& visual_blue = (*reply).visual_blue; |
| |
| // 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); |
| |
| // exact_red |
| Read(&exact_red, &buf); |
| |
| // exact_green |
| Read(&exact_green, &buf); |
| |
| // exact_blue |
| Read(&exact_blue, &buf); |
| |
| // visual_red |
| Read(&visual_red, &buf); |
| |
| // visual_green |
| Read(&visual_green, &buf); |
| |
| // visual_blue |
| Read(&visual_blue, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::CreateCursor(const CreateCursorRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cid = request.cid; |
| auto& source = request.source; |
| auto& mask = request.mask; |
| auto& fore_red = request.fore_red; |
| auto& fore_green = request.fore_green; |
| auto& fore_blue = request.fore_blue; |
| auto& back_red = request.back_red; |
| auto& back_green = request.back_green; |
| auto& back_blue = request.back_blue; |
| auto& x = request.x; |
| auto& y = request.y; |
| |
| // major_opcode |
| uint8_t major_opcode = 93; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cid |
| buf.Write(&cid); |
| |
| // source |
| buf.Write(&source); |
| |
| // mask |
| buf.Write(&mask); |
| |
| // fore_red |
| buf.Write(&fore_red); |
| |
| // fore_green |
| buf.Write(&fore_green); |
| |
| // fore_blue |
| buf.Write(&fore_blue); |
| |
| // back_red |
| buf.Write(&back_red); |
| |
| // back_green |
| buf.Write(&back_green); |
| |
| // back_blue |
| buf.Write(&back_blue); |
| |
| // x |
| buf.Write(&x); |
| |
| // y |
| buf.Write(&y); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "CreateCursor", false); |
| } |
| |
| Future<void> XProto::CreateCursor(const Cursor& cid, |
| const Pixmap& source, |
| const Pixmap& mask, |
| const uint16_t& fore_red, |
| const uint16_t& fore_green, |
| const uint16_t& fore_blue, |
| const uint16_t& back_red, |
| const uint16_t& back_green, |
| const uint16_t& back_blue, |
| const uint16_t& x, |
| const uint16_t& y) { |
| return XProto::CreateCursor( |
| CreateCursorRequest{cid, source, mask, fore_red, fore_green, fore_blue, |
| back_red, back_green, back_blue, x, y}); |
| } |
| |
| Future<void> XProto::CreateGlyphCursor( |
| const CreateGlyphCursorRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cid = request.cid; |
| auto& source_font = request.source_font; |
| auto& mask_font = request.mask_font; |
| auto& source_char = request.source_char; |
| auto& mask_char = request.mask_char; |
| auto& fore_red = request.fore_red; |
| auto& fore_green = request.fore_green; |
| auto& fore_blue = request.fore_blue; |
| auto& back_red = request.back_red; |
| auto& back_green = request.back_green; |
| auto& back_blue = request.back_blue; |
| |
| // major_opcode |
| uint8_t major_opcode = 94; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cid |
| buf.Write(&cid); |
| |
| // source_font |
| buf.Write(&source_font); |
| |
| // mask_font |
| buf.Write(&mask_font); |
| |
| // source_char |
| buf.Write(&source_char); |
| |
| // mask_char |
| buf.Write(&mask_char); |
| |
| // fore_red |
| buf.Write(&fore_red); |
| |
| // fore_green |
| buf.Write(&fore_green); |
| |
| // fore_blue |
| buf.Write(&fore_blue); |
| |
| // back_red |
| buf.Write(&back_red); |
| |
| // back_green |
| buf.Write(&back_green); |
| |
| // back_blue |
| buf.Write(&back_blue); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "CreateGlyphCursor", false); |
| } |
| |
| Future<void> XProto::CreateGlyphCursor(const Cursor& cid, |
| const Font& source_font, |
| const Font& mask_font, |
| const uint16_t& source_char, |
| const uint16_t& mask_char, |
| const uint16_t& fore_red, |
| const uint16_t& fore_green, |
| const uint16_t& fore_blue, |
| const uint16_t& back_red, |
| const uint16_t& back_green, |
| const uint16_t& back_blue) { |
| return XProto::CreateGlyphCursor(CreateGlyphCursorRequest{ |
| cid, source_font, mask_font, source_char, mask_char, fore_red, fore_green, |
| fore_blue, back_red, back_green, back_blue}); |
| } |
| |
| Future<void> XProto::FreeCursor(const FreeCursorRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cursor = request.cursor; |
| |
| // major_opcode |
| uint8_t major_opcode = 95; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cursor |
| buf.Write(&cursor); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "FreeCursor", false); |
| } |
| |
| Future<void> XProto::FreeCursor(const Cursor& cursor) { |
| return XProto::FreeCursor(FreeCursorRequest{cursor}); |
| } |
| |
| Future<void> XProto::RecolorCursor(const RecolorCursorRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& cursor = request.cursor; |
| auto& fore_red = request.fore_red; |
| auto& fore_green = request.fore_green; |
| auto& fore_blue = request.fore_blue; |
| auto& back_red = request.back_red; |
| auto& back_green = request.back_green; |
| auto& back_blue = request.back_blue; |
| |
| // major_opcode |
| uint8_t major_opcode = 96; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // cursor |
| buf.Write(&cursor); |
| |
| // fore_red |
| buf.Write(&fore_red); |
| |
| // fore_green |
| buf.Write(&fore_green); |
| |
| // fore_blue |
| buf.Write(&fore_blue); |
| |
| // back_red |
| buf.Write(&back_red); |
| |
| // back_green |
| buf.Write(&back_green); |
| |
| // back_blue |
| buf.Write(&back_blue); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "RecolorCursor", false); |
| } |
| |
| Future<void> XProto::RecolorCursor(const Cursor& cursor, |
| const uint16_t& fore_red, |
| const uint16_t& fore_green, |
| const uint16_t& fore_blue, |
| const uint16_t& back_red, |
| const uint16_t& back_green, |
| const uint16_t& back_blue) { |
| return XProto::RecolorCursor( |
| RecolorCursorRequest{cursor, fore_red, fore_green, fore_blue, back_red, |
| back_green, back_blue}); |
| } |
| |
| Future<QueryBestSizeReply> XProto::QueryBestSize( |
| const QueryBestSizeRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& c_class = request.c_class; |
| auto& drawable = request.drawable; |
| auto& width = request.width; |
| auto& height = request.height; |
| |
| // major_opcode |
| uint8_t major_opcode = 97; |
| buf.Write(&major_opcode); |
| |
| // c_class |
| uint8_t tmp108; |
| tmp108 = static_cast<uint8_t>(c_class); |
| buf.Write(&tmp108); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // width |
| buf.Write(&width); |
| |
| // height |
| buf.Write(&height); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<QueryBestSizeReply>(&buf, "QueryBestSize", |
| false); |
| } |
| |
| Future<QueryBestSizeReply> XProto::QueryBestSize(const QueryShapeOf& c_class, |
| const Drawable& drawable, |
| const uint16_t& width, |
| const uint16_t& height) { |
| return XProto::QueryBestSize( |
| QueryBestSizeRequest{c_class, drawable, width, height}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<QueryBestSizeReply> detail::ReadReply<QueryBestSizeReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<QueryBestSizeReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& width = (*reply).width; |
| auto& height = (*reply).height; |
| |
| // 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); |
| |
| // 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<QueryExtensionReply> XProto::QueryExtension( |
| const QueryExtensionRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| uint16_t name_len{}; |
| auto& name = request.name; |
| |
| // major_opcode |
| uint8_t major_opcode = 98; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // name_len |
| name_len = name.size(); |
| buf.Write(&name_len); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| // name |
| DCHECK_EQ(static_cast<size_t>(name_len), name.size()); |
| for (auto& name_elem : name) { |
| // name_elem |
| buf.Write(&name_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<QueryExtensionReply>(&buf, "QueryExtension", |
| false); |
| } |
| |
| Future<QueryExtensionReply> XProto::QueryExtension(const std::string& name) { |
| return XProto::QueryExtension(QueryExtensionRequest{name}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<QueryExtensionReply> detail::ReadReply<QueryExtensionReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<QueryExtensionReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& present = (*reply).present; |
| auto& major_opcode = (*reply).major_opcode; |
| auto& first_event = (*reply).first_event; |
| auto& first_error = (*reply).first_error; |
| |
| // 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); |
| |
| // present |
| Read(&present, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| // first_event |
| Read(&first_event, &buf); |
| |
| // first_error |
| Read(&first_error, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<ListExtensionsReply> XProto::ListExtensions( |
| const ListExtensionsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 99; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<ListExtensionsReply>(&buf, "ListExtensions", |
| false); |
| } |
| |
| Future<ListExtensionsReply> XProto::ListExtensions() { |
| return XProto::ListExtensions(ListExtensionsRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<ListExtensionsReply> detail::ReadReply<ListExtensionsReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<ListExtensionsReply>(); |
| |
| uint8_t names_len{}; |
| auto& sequence = (*reply).sequence; |
| auto& names = (*reply).names; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // names_len |
| Read(&names_len, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // pad0 |
| Pad(&buf, 24); |
| |
| // names |
| names.resize(names_len); |
| for (auto& names_elem : names) { |
| // names_elem |
| { |
| uint8_t name_len{}; |
| auto& name = names_elem.name; |
| |
| // name_len |
| Read(&name_len, &buf); |
| |
| // name |
| name.resize(name_len); |
| 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> XProto::ChangeKeyboardMapping( |
| const ChangeKeyboardMappingRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& keycode_count = request.keycode_count; |
| auto& first_keycode = request.first_keycode; |
| auto& keysyms_per_keycode = request.keysyms_per_keycode; |
| auto& keysyms = request.keysyms; |
| size_t keysyms_len = keysyms.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 100; |
| buf.Write(&major_opcode); |
| |
| // keycode_count |
| buf.Write(&keycode_count); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // first_keycode |
| buf.Write(&first_keycode); |
| |
| // keysyms_per_keycode |
| buf.Write(&keysyms_per_keycode); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| // keysyms |
| DCHECK_EQ(static_cast<size_t>((keycode_count) * (keysyms_per_keycode)), |
| keysyms.size()); |
| for (auto& keysyms_elem : keysyms) { |
| // keysyms_elem |
| buf.Write(&keysyms_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ChangeKeyboardMapping", false); |
| } |
| |
| Future<void> XProto::ChangeKeyboardMapping(const uint8_t& keycode_count, |
| const KeyCode& first_keycode, |
| const uint8_t& keysyms_per_keycode, |
| const std::vector<KeySym>& keysyms) { |
| return XProto::ChangeKeyboardMapping(ChangeKeyboardMappingRequest{ |
| keycode_count, first_keycode, keysyms_per_keycode, keysyms}); |
| } |
| |
| Future<GetKeyboardMappingReply> XProto::GetKeyboardMapping( |
| const GetKeyboardMappingRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& first_keycode = request.first_keycode; |
| auto& count = request.count; |
| |
| // major_opcode |
| uint8_t major_opcode = 101; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // first_keycode |
| buf.Write(&first_keycode); |
| |
| // count |
| buf.Write(&count); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetKeyboardMappingReply>( |
| &buf, "GetKeyboardMapping", false); |
| } |
| |
| Future<GetKeyboardMappingReply> XProto::GetKeyboardMapping( |
| const KeyCode& first_keycode, |
| const uint8_t& count) { |
| return XProto::GetKeyboardMapping( |
| GetKeyboardMappingRequest{first_keycode, count}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetKeyboardMappingReply> detail::ReadReply< |
| GetKeyboardMappingReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetKeyboardMappingReply>(); |
| |
| auto& keysyms_per_keycode = (*reply).keysyms_per_keycode; |
| auto& sequence = (*reply).sequence; |
| auto& keysyms = (*reply).keysyms; |
| size_t keysyms_len = keysyms.size(); |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // keysyms_per_keycode |
| Read(&keysyms_per_keycode, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // pad0 |
| Pad(&buf, 24); |
| |
| // keysyms |
| keysyms.resize(length); |
| for (auto& keysyms_elem : keysyms) { |
| // keysyms_elem |
| Read(&keysyms_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::ChangeKeyboardControl( |
| const ChangeKeyboardControlRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| Keyboard value_mask{}; |
| auto& value_list = request; |
| |
| // major_opcode |
| uint8_t major_opcode = 102; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // value_mask |
| SwitchVar(Keyboard::KeyClickPercent, value_list.key_click_percent.has_value(), |
| true, &value_mask); |
| SwitchVar(Keyboard::BellPercent, value_list.bell_percent.has_value(), true, |
| &value_mask); |
| SwitchVar(Keyboard::BellPitch, value_list.bell_pitch.has_value(), true, |
| &value_mask); |
| SwitchVar(Keyboard::BellDuration, value_list.bell_duration.has_value(), true, |
| &value_mask); |
| SwitchVar(Keyboard::Led, value_list.led.has_value(), true, &value_mask); |
| SwitchVar(Keyboard::LedMode, value_list.led_mode.has_value(), true, |
| &value_mask); |
| SwitchVar(Keyboard::Key, value_list.key.has_value(), true, &value_mask); |
| SwitchVar(Keyboard::AutoRepeatMode, value_list.auto_repeat_mode.has_value(), |
| true, &value_mask); |
| uint32_t tmp109; |
| tmp109 = static_cast<uint32_t>(value_mask); |
| buf.Write(&tmp109); |
| |
| // value_list |
| auto value_list_expr = value_mask; |
| if (CaseAnd(value_list_expr, Keyboard::KeyClickPercent)) { |
| auto& key_click_percent = *value_list.key_click_percent; |
| |
| // key_click_percent |
| buf.Write(&key_click_percent); |
| } |
| if (CaseAnd(value_list_expr, Keyboard::BellPercent)) { |
| auto& bell_percent = *value_list.bell_percent; |
| |
| // bell_percent |
| buf.Write(&bell_percent); |
| } |
| if (CaseAnd(value_list_expr, Keyboard::BellPitch)) { |
| auto& bell_pitch = *value_list.bell_pitch; |
| |
| // bell_pitch |
| buf.Write(&bell_pitch); |
| } |
| if (CaseAnd(value_list_expr, Keyboard::BellDuration)) { |
| auto& bell_duration = *value_list.bell_duration; |
| |
| // bell_duration |
| buf.Write(&bell_duration); |
| } |
| if (CaseAnd(value_list_expr, Keyboard::Led)) { |
| auto& led = *value_list.led; |
| |
| // led |
| buf.Write(&led); |
| } |
| if (CaseAnd(value_list_expr, Keyboard::LedMode)) { |
| auto& led_mode = *value_list.led_mode; |
| |
| // led_mode |
| uint32_t tmp110; |
| tmp110 = static_cast<uint32_t>(led_mode); |
| buf.Write(&tmp110); |
| } |
| if (CaseAnd(value_list_expr, Keyboard::Key)) { |
| auto& key = *value_list.key; |
| |
| // key |
| buf.Write(&key); |
| } |
| if (CaseAnd(value_list_expr, Keyboard::AutoRepeatMode)) { |
| auto& auto_repeat_mode = *value_list.auto_repeat_mode; |
| |
| // auto_repeat_mode |
| uint32_t tmp111; |
| tmp111 = static_cast<uint32_t>(auto_repeat_mode); |
| buf.Write(&tmp111); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ChangeKeyboardControl", false); |
| } |
| |
| Future<void> XProto::ChangeKeyboardControl( |
| const absl::optional<int32_t>& key_click_percent, |
| const absl::optional<int32_t>& bell_percent, |
| const absl::optional<int32_t>& bell_pitch, |
| const absl::optional<int32_t>& bell_duration, |
| const absl::optional<uint32_t>& led, |
| const absl::optional<LedMode>& led_mode, |
| const absl::optional<KeyCode32>& key, |
| const absl::optional<AutoRepeatMode>& auto_repeat_mode) { |
| return XProto::ChangeKeyboardControl(ChangeKeyboardControlRequest{ |
| key_click_percent, bell_percent, bell_pitch, bell_duration, led, led_mode, |
| key, auto_repeat_mode}); |
| } |
| |
| Future<GetKeyboardControlReply> XProto::GetKeyboardControl( |
| const GetKeyboardControlRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 103; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetKeyboardControlReply>( |
| &buf, "GetKeyboardControl", false); |
| } |
| |
| Future<GetKeyboardControlReply> XProto::GetKeyboardControl() { |
| return XProto::GetKeyboardControl(GetKeyboardControlRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetKeyboardControlReply> detail::ReadReply< |
| GetKeyboardControlReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetKeyboardControlReply>(); |
| |
| auto& global_auto_repeat = (*reply).global_auto_repeat; |
| auto& sequence = (*reply).sequence; |
| auto& led_mask = (*reply).led_mask; |
| auto& key_click_percent = (*reply).key_click_percent; |
| auto& bell_percent = (*reply).bell_percent; |
| auto& bell_pitch = (*reply).bell_pitch; |
| auto& bell_duration = (*reply).bell_duration; |
| auto& auto_repeats = (*reply).auto_repeats; |
| size_t auto_repeats_len = auto_repeats.size(); |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // global_auto_repeat |
| uint8_t tmp112; |
| Read(&tmp112, &buf); |
| global_auto_repeat = static_cast<AutoRepeatMode>(tmp112); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // led_mask |
| Read(&led_mask, &buf); |
| |
| // key_click_percent |
| Read(&key_click_percent, &buf); |
| |
| // bell_percent |
| Read(&bell_percent, &buf); |
| |
| // bell_pitch |
| Read(&bell_pitch, &buf); |
| |
| // bell_duration |
| Read(&bell_duration, &buf); |
| |
| // pad0 |
| Pad(&buf, 2); |
| |
| // auto_repeats |
| for (auto& auto_repeats_elem : auto_repeats) { |
| // auto_repeats_elem |
| Read(&auto_repeats_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::Bell(const BellRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& percent = request.percent; |
| |
| // major_opcode |
| uint8_t major_opcode = 104; |
| buf.Write(&major_opcode); |
| |
| // percent |
| buf.Write(&percent); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Bell", false); |
| } |
| |
| Future<void> XProto::Bell(const int8_t& percent) { |
| return XProto::Bell(BellRequest{percent}); |
| } |
| |
| Future<void> XProto::ChangePointerControl( |
| const ChangePointerControlRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& acceleration_numerator = request.acceleration_numerator; |
| auto& acceleration_denominator = request.acceleration_denominator; |
| auto& threshold = request.threshold; |
| auto& do_acceleration = request.do_acceleration; |
| auto& do_threshold = request.do_threshold; |
| |
| // major_opcode |
| uint8_t major_opcode = 105; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // acceleration_numerator |
| buf.Write(&acceleration_numerator); |
| |
| // acceleration_denominator |
| buf.Write(&acceleration_denominator); |
| |
| // threshold |
| buf.Write(&threshold); |
| |
| // do_acceleration |
| buf.Write(&do_acceleration); |
| |
| // do_threshold |
| buf.Write(&do_threshold); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ChangePointerControl", false); |
| } |
| |
| Future<void> XProto::ChangePointerControl( |
| const int16_t& acceleration_numerator, |
| const int16_t& acceleration_denominator, |
| const int16_t& threshold, |
| const uint8_t& do_acceleration, |
| const uint8_t& do_threshold) { |
| return XProto::ChangePointerControl(ChangePointerControlRequest{ |
| acceleration_numerator, acceleration_denominator, threshold, |
| do_acceleration, do_threshold}); |
| } |
| |
| Future<GetPointerControlReply> XProto::GetPointerControl( |
| const GetPointerControlRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 106; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetPointerControlReply>( |
| &buf, "GetPointerControl", false); |
| } |
| |
| Future<GetPointerControlReply> XProto::GetPointerControl() { |
| return XProto::GetPointerControl(GetPointerControlRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetPointerControlReply> detail::ReadReply< |
| GetPointerControlReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetPointerControlReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& acceleration_numerator = (*reply).acceleration_numerator; |
| auto& acceleration_denominator = (*reply).acceleration_denominator; |
| auto& threshold = (*reply).threshold; |
| |
| // 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); |
| |
| // acceleration_numerator |
| Read(&acceleration_numerator, &buf); |
| |
| // acceleration_denominator |
| Read(&acceleration_denominator, &buf); |
| |
| // threshold |
| Read(&threshold, &buf); |
| |
| // pad1 |
| Pad(&buf, 18); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::SetScreenSaver(const SetScreenSaverRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& timeout = request.timeout; |
| auto& interval = request.interval; |
| auto& prefer_blanking = request.prefer_blanking; |
| auto& allow_exposures = request.allow_exposures; |
| |
| // major_opcode |
| uint8_t major_opcode = 107; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // timeout |
| buf.Write(&timeout); |
| |
| // interval |
| buf.Write(&interval); |
| |
| // prefer_blanking |
| uint8_t tmp113; |
| tmp113 = static_cast<uint8_t>(prefer_blanking); |
| buf.Write(&tmp113); |
| |
| // allow_exposures |
| uint8_t tmp114; |
| tmp114 = static_cast<uint8_t>(allow_exposures); |
| buf.Write(&tmp114); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "SetScreenSaver", false); |
| } |
| |
| Future<void> XProto::SetScreenSaver(const int16_t& timeout, |
| const int16_t& interval, |
| const Blanking& prefer_blanking, |
| const Exposures& allow_exposures) { |
| return XProto::SetScreenSaver(SetScreenSaverRequest{ |
| timeout, interval, prefer_blanking, allow_exposures}); |
| } |
| |
| Future<GetScreenSaverReply> XProto::GetScreenSaver( |
| const GetScreenSaverRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 108; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetScreenSaverReply>(&buf, "GetScreenSaver", |
| false); |
| } |
| |
| Future<GetScreenSaverReply> XProto::GetScreenSaver() { |
| return XProto::GetScreenSaver(GetScreenSaverRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetScreenSaverReply> detail::ReadReply<GetScreenSaverReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetScreenSaverReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& timeout = (*reply).timeout; |
| auto& interval = (*reply).interval; |
| auto& prefer_blanking = (*reply).prefer_blanking; |
| auto& allow_exposures = (*reply).allow_exposures; |
| |
| // 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); |
| |
| // timeout |
| Read(&timeout, &buf); |
| |
| // interval |
| Read(&interval, &buf); |
| |
| // prefer_blanking |
| uint8_t tmp115; |
| Read(&tmp115, &buf); |
| prefer_blanking = static_cast<Blanking>(tmp115); |
| |
| // allow_exposures |
| uint8_t tmp116; |
| Read(&tmp116, &buf); |
| allow_exposures = static_cast<Exposures>(tmp116); |
| |
| // pad1 |
| Pad(&buf, 18); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::ChangeHosts(const ChangeHostsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& mode = request.mode; |
| auto& family = request.family; |
| uint16_t address_len{}; |
| auto& address = request.address; |
| |
| // major_opcode |
| uint8_t major_opcode = 109; |
| buf.Write(&major_opcode); |
| |
| // mode |
| uint8_t tmp117; |
| tmp117 = static_cast<uint8_t>(mode); |
| buf.Write(&tmp117); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // family |
| uint8_t tmp118; |
| tmp118 = static_cast<uint8_t>(family); |
| buf.Write(&tmp118); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // address_len |
| address_len = address.size(); |
| buf.Write(&address_len); |
| |
| // address |
| DCHECK_EQ(static_cast<size_t>(address_len), address.size()); |
| for (auto& address_elem : address) { |
| // address_elem |
| buf.Write(&address_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ChangeHosts", false); |
| } |
| |
| Future<void> XProto::ChangeHosts(const HostMode& mode, |
| const Family& family, |
| const std::vector<uint8_t>& address) { |
| return XProto::ChangeHosts(ChangeHostsRequest{mode, family, address}); |
| } |
| |
| Future<ListHostsReply> XProto::ListHosts(const ListHostsRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 110; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<ListHostsReply>(&buf, "ListHosts", false); |
| } |
| |
| Future<ListHostsReply> XProto::ListHosts() { |
| return XProto::ListHosts(ListHostsRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<ListHostsReply> detail::ReadReply<ListHostsReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<ListHostsReply>(); |
| |
| auto& mode = (*reply).mode; |
| auto& sequence = (*reply).sequence; |
| uint16_t hosts_len{}; |
| auto& hosts = (*reply).hosts; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // mode |
| uint8_t tmp119; |
| Read(&tmp119, &buf); |
| mode = static_cast<AccessControl>(tmp119); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // hosts_len |
| Read(&hosts_len, &buf); |
| |
| // pad0 |
| Pad(&buf, 22); |
| |
| // hosts |
| hosts.resize(hosts_len); |
| for (auto& hosts_elem : hosts) { |
| // hosts_elem |
| { |
| auto& family = hosts_elem.family; |
| uint16_t address_len{}; |
| auto& address = hosts_elem.address; |
| |
| // family |
| uint8_t tmp120; |
| Read(&tmp120, &buf); |
| family = static_cast<Family>(tmp120); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // address_len |
| Read(&address_len, &buf); |
| |
| // address |
| address.resize(address_len); |
| for (auto& address_elem : address) { |
| // address_elem |
| Read(&address_elem, &buf); |
| } |
| |
| // pad1 |
| Align(&buf, 4); |
| } |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::SetAccessControl(const SetAccessControlRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& mode = request.mode; |
| |
| // major_opcode |
| uint8_t major_opcode = 111; |
| buf.Write(&major_opcode); |
| |
| // mode |
| uint8_t tmp121; |
| tmp121 = static_cast<uint8_t>(mode); |
| buf.Write(&tmp121); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "SetAccessControl", false); |
| } |
| |
| Future<void> XProto::SetAccessControl(const AccessControl& mode) { |
| return XProto::SetAccessControl(SetAccessControlRequest{mode}); |
| } |
| |
| Future<void> XProto::SetCloseDownMode(const SetCloseDownModeRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& mode = request.mode; |
| |
| // major_opcode |
| uint8_t major_opcode = 112; |
| buf.Write(&major_opcode); |
| |
| // mode |
| uint8_t tmp122; |
| tmp122 = static_cast<uint8_t>(mode); |
| buf.Write(&tmp122); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "SetCloseDownMode", false); |
| } |
| |
| Future<void> XProto::SetCloseDownMode(const CloseDown& mode) { |
| return XProto::SetCloseDownMode(SetCloseDownModeRequest{mode}); |
| } |
| |
| Future<void> XProto::KillClient(const KillClientRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& resource = request.resource; |
| |
| // major_opcode |
| uint8_t major_opcode = 113; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // resource |
| buf.Write(&resource); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "KillClient", false); |
| } |
| |
| Future<void> XProto::KillClient(const uint32_t& resource) { |
| return XProto::KillClient(KillClientRequest{resource}); |
| } |
| |
| Future<void> XProto::RotateProperties(const RotatePropertiesRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& window = request.window; |
| uint16_t atoms_len{}; |
| auto& delta = request.delta; |
| auto& atoms = request.atoms; |
| |
| // major_opcode |
| uint8_t major_opcode = 114; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // window |
| buf.Write(&window); |
| |
| // atoms_len |
| atoms_len = atoms.size(); |
| buf.Write(&atoms_len); |
| |
| // delta |
| buf.Write(&delta); |
| |
| // atoms |
| DCHECK_EQ(static_cast<size_t>(atoms_len), atoms.size()); |
| for (auto& atoms_elem : atoms) { |
| // atoms_elem |
| buf.Write(&atoms_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "RotateProperties", false); |
| } |
| |
| Future<void> XProto::RotateProperties(const Window& window, |
| const int16_t& delta, |
| const std::vector<Atom>& atoms) { |
| return XProto::RotateProperties( |
| RotatePropertiesRequest{window, delta, atoms}); |
| } |
| |
| Future<void> XProto::ForceScreenSaver(const ForceScreenSaverRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& mode = request.mode; |
| |
| // major_opcode |
| uint8_t major_opcode = 115; |
| buf.Write(&major_opcode); |
| |
| // mode |
| uint8_t tmp123; |
| tmp123 = static_cast<uint8_t>(mode); |
| buf.Write(&tmp123); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "ForceScreenSaver", false); |
| } |
| |
| Future<void> XProto::ForceScreenSaver(const ScreenSaverMode& mode) { |
| return XProto::ForceScreenSaver(ForceScreenSaverRequest{mode}); |
| } |
| |
| Future<SetPointerMappingReply> XProto::SetPointerMapping( |
| const SetPointerMappingRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| uint8_t map_len{}; |
| auto& map = request.map; |
| |
| // major_opcode |
| uint8_t major_opcode = 116; |
| buf.Write(&major_opcode); |
| |
| // map_len |
| map_len = map.size(); |
| buf.Write(&map_len); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // map |
| DCHECK_EQ(static_cast<size_t>(map_len), map.size()); |
| for (auto& map_elem : map) { |
| // map_elem |
| buf.Write(&map_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<SetPointerMappingReply>( |
| &buf, "SetPointerMapping", false); |
| } |
| |
| Future<SetPointerMappingReply> XProto::SetPointerMapping( |
| const std::vector<uint8_t>& map) { |
| return XProto::SetPointerMapping(SetPointerMappingRequest{map}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<SetPointerMappingReply> detail::ReadReply< |
| SetPointerMappingReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<SetPointerMappingReply>(); |
| |
| auto& status = (*reply).status; |
| auto& sequence = (*reply).sequence; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // status |
| uint8_t tmp124; |
| Read(&tmp124, &buf); |
| status = static_cast<MappingStatus>(tmp124); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<GetPointerMappingReply> XProto::GetPointerMapping( |
| const GetPointerMappingRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 117; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetPointerMappingReply>( |
| &buf, "GetPointerMapping", false); |
| } |
| |
| Future<GetPointerMappingReply> XProto::GetPointerMapping() { |
| return XProto::GetPointerMapping(GetPointerMappingRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetPointerMappingReply> detail::ReadReply< |
| GetPointerMappingReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetPointerMappingReply>(); |
| |
| uint8_t map_len{}; |
| auto& sequence = (*reply).sequence; |
| auto& map = (*reply).map; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // map_len |
| Read(&map_len, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // pad0 |
| Pad(&buf, 24); |
| |
| // map |
| map.resize(map_len); |
| for (auto& map_elem : map) { |
| // map_elem |
| Read(&map_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<SetModifierMappingReply> XProto::SetModifierMapping( |
| const SetModifierMappingRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& keycodes_per_modifier = request.keycodes_per_modifier; |
| auto& keycodes = request.keycodes; |
| size_t keycodes_len = keycodes.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = 118; |
| buf.Write(&major_opcode); |
| |
| // keycodes_per_modifier |
| buf.Write(&keycodes_per_modifier); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // keycodes |
| DCHECK_EQ(static_cast<size_t>((keycodes_per_modifier) * (8)), |
| keycodes.size()); |
| for (auto& keycodes_elem : keycodes) { |
| // keycodes_elem |
| buf.Write(&keycodes_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<SetModifierMappingReply>( |
| &buf, "SetModifierMapping", false); |
| } |
| |
| Future<SetModifierMappingReply> XProto::SetModifierMapping( |
| const uint8_t& keycodes_per_modifier, |
| const std::vector<KeyCode>& keycodes) { |
| return XProto::SetModifierMapping( |
| SetModifierMappingRequest{keycodes_per_modifier, keycodes}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<SetModifierMappingReply> detail::ReadReply< |
| SetModifierMappingReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<SetModifierMappingReply>(); |
| |
| auto& status = (*reply).status; |
| auto& sequence = (*reply).sequence; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // status |
| uint8_t tmp125; |
| Read(&tmp125, &buf); |
| status = static_cast<MappingStatus>(tmp125); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<GetModifierMappingReply> XProto::GetModifierMapping( |
| const GetModifierMappingRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 119; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<GetModifierMappingReply>( |
| &buf, "GetModifierMapping", false); |
| } |
| |
| Future<GetModifierMappingReply> XProto::GetModifierMapping() { |
| return XProto::GetModifierMapping(GetModifierMappingRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<GetModifierMappingReply> detail::ReadReply< |
| GetModifierMappingReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<GetModifierMappingReply>(); |
| |
| auto& keycodes_per_modifier = (*reply).keycodes_per_modifier; |
| auto& sequence = (*reply).sequence; |
| auto& keycodes = (*reply).keycodes; |
| size_t keycodes_len = keycodes.size(); |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // keycodes_per_modifier |
| Read(&keycodes_per_modifier, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // pad0 |
| Pad(&buf, 24); |
| |
| // keycodes |
| keycodes.resize((keycodes_per_modifier) * (8)); |
| for (auto& keycodes_elem : keycodes) { |
| // keycodes_elem |
| Read(&keycodes_elem, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> XProto::NoOperation(const NoOperationRequest& request) { |
| if (!connection_->Ready()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = 127; |
| buf.Write(&major_opcode); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "NoOperation", false); |
| } |
| |
| Future<void> XProto::NoOperation() { |
| return XProto::NoOperation(NoOperationRequest{}); |
| } |
| |
| } // namespace x11 |
