diff --git a/packages/xcb/sample/root.zig b/packages/xcb/sample/root.zig index 2bbd720..e745dd7 100644 --- a/packages/xcb/sample/root.zig +++ b/packages/xcb/sample/root.zig @@ -1,83 +1,75 @@ const std = @import("std"); const xcb = @import("xcb"); -const WM_PROTOCOLS = "WM_PROTOCOLS"; -const WM_DELETE_WINDOW = "WM_DELETE_WINDOW"; - pub fn main(init: std.process.Init) !void { _ = init; - const connection = xcb.import.xcb_connect(null, null); - defer xcb.import.xcb_disconnect(connection); + const connection = xcb.Connection.connect(null, null); + defer connection.disconnect(); { - const res = xcb.import.xcb_connection_has_error(connection); - if (res != 0) { - std.debug.print("Error: xcb_connection_has_error returned {}", .{res}); + const error_code = connection.hasError(); + if (error_code != 0) { + std.debug.print("Error: xcb_connection_has_error returned {}", .{error_code}); return error.XcbConnection; } } - const screen = xcb.import.xcb_setup_roots_iterator(xcb.import.xcb_get_setup(connection)).data.?; + const setup = connection.getSetup(); + const screen = setup.rootsIterator().data; - const mask: xcb.Cw = .{ - .BACK_PIXEL = true, - .EVENT_MASK = true, - }; - - const values = [_]u32{ - screen.white_pixel, - @bitCast(xcb.EventMask{ - .KEY_PRESS = true, - }), - }; - - const window: xcb.Window = @enumFromInt(xcb.import.xcb_generate_id(connection)); - _ = xcb.import.xcb_create_window( - connection, + const window = @as(xcb.Window, @enumFromInt(connection.generateId())); + _ = connection.createWindow( xcb.COPY_FROM_PARENT, window, screen.root, - 10, - 10, + 0, + 0, 640, - 480, + 360, 1, - @intFromEnum(xcb.WindowClass.INPUT_OUTPUT), + .INPUT_OUTPUT, screen.root_visual, - @bitCast(mask), - &values, + .{ + .BACK_PIXEL = true, + }, + &[_]u32{ + screen.black_pixel, + }, ); - const wm_protocols_atom_cookie = xcb.import.xcb_intern_atom(connection, 1, WM_PROTOCOLS.len, WM_PROTOCOLS); - const wm_delete_window_atom_cookie = xcb.import.xcb_intern_atom(connection, 0, WM_DELETE_WINDOW.len, WM_DELETE_WINDOW); + const wm_protocols_atom_cookie = connection.internAtom(true, "WM_PROTOCOLS"); + const wm_delete_window_atom_cookie = connection.internAtom(false, "WM_DELETE_WINDOW"); - const wm_protocols_atom_reply: *xcb.InternAtomReply = xcb.import.xcb_intern_atom_reply(connection, wm_protocols_atom_cookie, null) orelse return error.XcbInternAtom; - const wm_delete_window_atom_reply: *xcb.InternAtomReply = xcb.import.xcb_intern_atom_reply(connection, wm_delete_window_atom_cookie, null) orelse return error.XcbInternAtom; + const wm_protocols_atom_reply = connection.internAtomReply(wm_protocols_atom_cookie, null) orelse return error.XcbInternAtom; + defer std.c.free(wm_protocols_atom_reply); + const wm_protocols_atom = wm_protocols_atom_reply.atom; - _ = xcb.import.xcb_change_property( - connection, - @intFromEnum(xcb.PropMode.REPLACE), + const wm_delete_window_atom_reply = connection.internAtomReply(wm_delete_window_atom_cookie, null) orelse return error.XcbInternAtom; + defer std.c.free(wm_delete_window_atom_reply); + const wm_delete_window_atom = wm_delete_window_atom_reply.atom; + + _ = connection.changeProperty( + .REPLACE, window, - wm_protocols_atom_reply.atom, + wm_protocols_atom, .ATOM, 32, 1, - &wm_delete_window_atom_reply.atom, + &wm_delete_window_atom, ); - _ = xcb.import.xcb_map_window(connection, window); - _ = xcb.import.xcb_flush(connection); + _ = connection.mapWindow(window); + _ = connection.flush(); var running = true; while (running) { - const maybe_event: ?*xcb.GenericEvent = xcb.import.xcb_wait_for_event(connection); - if (maybe_event) |event| { + if (connection.waitForEvent()) |event| { defer std.c.free(event); switch (event.response_type & ~@as(u8, 0x80)) { xcb.CLIENT_MESSAGE => { - const client_message_event: *xcb.ClientMessageEvent = @ptrCast(event); + const client_message_event = @as(*xcb.ClientMessageEvent, @ptrCast(event)); if (client_message_event.data.data32[0] == @intFromEnum(wm_delete_window_atom_reply.atom)) { running = false; } diff --git a/packages/xcb/src/root.zig b/packages/xcb/src/root.zig index c9f0e6f..ccaceaa 100644 --- a/packages/xcb/src/root.zig +++ b/packages/xcb/src/root.zig @@ -1,324 +1,1282 @@ const std = @import("std"); pub const Connection = opaque { - pub const createWindowChecked = import.xcb_create_window_checked; - pub const createWindow = import.xcb_create_window; - pub const createWindowAuxChecked = import.xcb_create_window_aux_checked; - pub const createWindowAux = import.xcb_create_window_aux; - pub const changeWindowAttributesChecked = import.xcb_change_window_attributes_checked; - pub const changeWindowAttributes = import.xcb_change_window_attributes; - pub const changeWindowAttributesAuxChecked = import.xcb_change_window_attributes_aux_checked; - pub const changeWindowAttributesAux = import.xcb_change_window_attributes_aux; - pub const getWindowAttributes = import.xcb_get_window_attributes; - pub const getWindowAttributesUnchecked = import.xcb_get_window_attributes_unchecked; - pub const getWindowAttributesReply = import.xcb_get_window_attributes_reply; - pub const destroyWindowChecked = import.xcb_destroy_window_checked; - pub const destroyWindow = import.xcb_destroy_window; - pub const destroySubwindowsChecked = import.xcb_destroy_subwindows_checked; - pub const destroySubwindows = import.xcb_destroy_subwindows; - pub const changeSaveSetChecked = import.xcb_change_save_set_checked; - pub const changeSaveSet = import.xcb_change_save_set; - pub const reparentWindowChecked = import.xcb_reparent_window_checked; - pub const reparentWindow = import.xcb_reparent_window; - pub const mapWindowChecked = import.xcb_map_window_checked; - pub const mapWindow = import.xcb_map_window; - pub const mapSubwindowsChecked = import.xcb_map_subwindows_checked; - pub const mapSubwindows = import.xcb_map_subwindows; - pub const unmapWindowChecked = import.xcb_unmap_window_checked; - pub const unmapWindow = import.xcb_unmap_window; - pub const unmapSubwindowsChecked = import.xcb_unmap_subwindows_checked; - pub const unmapSubwindows = import.xcb_unmap_subwindows; - pub const configureWindowChecked = import.xcb_configure_window_checked; - pub const configureWindow = import.xcb_configure_window; - pub const configureWindowAuxChecked = import.xcb_configure_window_aux_checked; - pub const configureWindowAux = import.xcb_configure_window_aux; - pub const circulateWindowChecked = import.xcb_circulate_window_checked; - pub const circulateWindow = import.xcb_circulate_window; - pub const getGeometry = import.xcb_get_geometry; - pub const getGeometryUnchecked = import.xcb_get_geometry_unchecked; - pub const getGeometryReply = import.xcb_get_geometry_reply; - pub const queryTree = import.xcb_query_tree; - pub const queryTreeUnchecked = import.xcb_query_tree_unchecked; - pub const queryTreeReply = import.xcb_query_tree_reply; - pub const internAtom = import.xcb_intern_atom; - pub const internAtomUnchecked = import.xcb_intern_atom_unchecked; - pub const internAtomReply = import.xcb_intern_atom_reply; - pub const getAtomName = import.xcb_get_atom_name; - pub const getAtomNameUnchecked = import.xcb_get_atom_name_unchecked; - pub const getAtomNameReply = import.xcb_get_atom_name_reply; - pub const changePropertyChecked = import.xcb_change_property_checked; - pub const changeProperty = import.xcb_change_property; - pub const deletePropertyChecked = import.xcb_delete_property_checked; - pub const deleteProperty = import.xcb_delete_property; - pub const getProperty = import.xcb_get_property; - pub const getPropertyUnchecked = import.xcb_get_property_unchecked; - pub const getPropertyReply = import.xcb_get_property_reply; - pub const listProperties = import.xcb_list_properties; - pub const listPropertiesUnchecked = import.xcb_list_properties_unchecked; - pub const listPropertiesReply = import.xcb_list_properties_reply; - pub const setSelectionOwnerChecked = import.xcb_set_selection_owner_checked; - pub const setSelectionOwner = import.xcb_set_selection_owner; - pub const getSelectionOwner = import.xcb_get_selection_owner; - pub const getSelectionOwnerUnchecked = import.xcb_get_selection_owner_unchecked; - pub const getSelectionOwnerReply = import.xcb_get_selection_owner_reply; - pub const convertSelectionChecked = import.xcb_convert_selection_checked; - pub const convertSelection = import.xcb_convert_selection; - pub const sendEventChecked = import.xcb_send_event_checked; - pub const sendEvent = import.xcb_send_event; - pub const grabPointer = import.xcb_grab_pointer; - pub const grabPointerUnchecked = import.xcb_grab_pointer_unchecked; - pub const grabPointerReply = import.xcb_grab_pointer_reply; - pub const ungrabPointerChecked = import.xcb_ungrab_pointer_checked; - pub const ungrabPointer = import.xcb_ungrab_pointer; - pub const grabButtonChecked = import.xcb_grab_button_checked; - pub const grabButton = import.xcb_grab_button; - pub const ungrabButtonChecked = import.xcb_ungrab_button_checked; - pub const ungrabButton = import.xcb_ungrab_button; - pub const changeActivePointerGrabChecked = import.xcb_change_active_pointer_grab_checked; - pub const changeActivePointerGrab = import.xcb_change_active_pointer_grab; - pub const grabKeyboard = import.xcb_grab_keyboard; - pub const grabKeyboardUnchecked = import.xcb_grab_keyboard_unchecked; - pub const grabKeyboardReply = import.xcb_grab_keyboard_reply; - pub const ungrabKeyboardChecked = import.xcb_ungrab_keyboard_checked; - pub const ungrabKeyboard = import.xcb_ungrab_keyboard; - pub const grabKeyChecked = import.xcb_grab_key_checked; - pub const grabKey = import.xcb_grab_key; - pub const ungrabKeyChecked = import.xcb_ungrab_key_checked; - pub const ungrabKey = import.xcb_ungrab_key; - pub const allowEventsChecked = import.xcb_allow_events_checked; - pub const allowEvents = import.xcb_allow_events; - pub const grabServerChecked = import.xcb_grab_server_checked; - pub const grabServer = import.xcb_grab_server; - pub const ungrabServerChecked = import.xcb_ungrab_server_checked; - pub const ungrabServer = import.xcb_ungrab_server; - pub const queryPointer = import.xcb_query_pointer; - pub const queryPointerUnchecked = import.xcb_query_pointer_unchecked; - pub const queryPointerReply = import.xcb_query_pointer_reply; - pub const getMotionEvents = import.xcb_get_motion_events; - pub const getMotionEventsUnchecked = import.xcb_get_motion_events_unchecked; - pub const getMotionEventsReply = import.xcb_get_motion_events_reply; - pub const translateCoordinates = import.xcb_translate_coordinates; - pub const translateCoordinatesUnchecked = import.xcb_translate_coordinates_unchecked; - pub const translateCoordinatesReply = import.xcb_translate_coordinates_reply; - pub const warpPointerChecked = import.xcb_warp_pointer_checked; - pub const warpPointer = import.xcb_warp_pointer; - pub const setInputFocusChecked = import.xcb_set_input_focus_checked; - pub const setInputFocus = import.xcb_set_input_focus; - pub const getInputFocus = import.xcb_get_input_focus; - pub const getInputFocusUnchecked = import.xcb_get_input_focus_unchecked; - pub const getInputFocusReply = import.xcb_get_input_focus_reply; - pub const queryKeymap = import.xcb_query_keymap; - pub const queryKeymapUnchecked = import.xcb_query_keymap_unchecked; - pub const queryKeymapReply = import.xcb_query_keymap_reply; - pub const openFontChecked = import.xcb_open_font_checked; - pub const openFont = import.xcb_open_font; - pub const closeFontChecked = import.xcb_close_font_checked; - pub const closeFont = import.xcb_close_font; - pub const queryFont = import.xcb_query_font; - pub const queryFontUnchecked = import.xcb_query_font_unchecked; - pub const queryFontReply = import.xcb_query_font_reply; - pub const queryTextExtents = import.xcb_query_text_extents; - pub const queryTextExtentsUnchecked = import.xcb_query_text_extents_unchecked; - pub const queryTextExtentsReply = import.xcb_query_text_extents_reply; - pub const listFonts = import.xcb_list_fonts; - pub const listFontsUnchecked = import.xcb_list_fonts_unchecked; - pub const listFontsReply = import.xcb_list_fonts_reply; - pub const listFontsWithInfo = import.xcb_list_fonts_with_info; - pub const listFontsWithInfoUnchecked = import.xcb_list_fonts_with_info_unchecked; - pub const listFontsWithInfoReply = import.xcb_list_fonts_with_info_reply; - pub const setFontPathChecked = import.xcb_set_font_path_checked; - pub const setFontPath = import.xcb_set_font_path; - pub const getFontPath = import.xcb_get_font_path; - pub const getFontPathUnchecked = import.xcb_get_font_path_unchecked; - pub const getFontPathReply = import.xcb_get_font_path_reply; - pub const createPixmapChecked = import.xcb_create_pixmap_checked; - pub const createPixmap = import.xcb_create_pixmap; - pub const freePixmapChecked = import.xcb_free_pixmap_checked; - pub const freePixmap = import.xcb_free_pixmap; - pub const createGcChecked = import.xcb_create_gc_checked; - pub const createGc = import.xcb_create_gc; - pub const createGcAuxChecked = import.xcb_create_gc_aux_checked; - pub const createGcAux = import.xcb_create_gc_aux; - pub const changeGcChecked = import.xcb_change_gc_checked; - pub const changeGc = import.xcb_change_gc; - pub const changeGcAuxChecked = import.xcb_change_gc_aux_checked; - pub const changeGcAux = import.xcb_change_gc_aux; - pub const copyGcChecked = import.xcb_copy_gc_checked; - pub const copyGc = import.xcb_copy_gc; - pub const setDashesChecked = import.xcb_set_dashes_checked; - pub const setDashes = import.xcb_set_dashes; - pub const setClipRectanglesChecked = import.xcb_set_clip_rectangles_checked; - pub const setClipRectangles = import.xcb_set_clip_rectangles; - pub const freeGcChecked = import.xcb_free_gc_checked; - pub const freeGc = import.xcb_free_gc; - pub const clearAreaChecked = import.xcb_clear_area_checked; - pub const clearArea = import.xcb_clear_area; - pub const copyAreaChecked = import.xcb_copy_area_checked; - pub const copyArea = import.xcb_copy_area; - pub const copyPlaneChecked = import.xcb_copy_plane_checked; - pub const copyPlane = import.xcb_copy_plane; - pub const polyPointChecked = import.xcb_poly_point_checked; - pub const polyPoint = import.xcb_poly_point; - pub const polyLineChecked = import.xcb_poly_line_checked; - pub const polyLine = import.xcb_poly_line; - pub const polySegmentChecked = import.xcb_poly_segment_checked; - pub const polySegment = import.xcb_poly_segment; - pub const polyRectangleChecked = import.xcb_poly_rectangle_checked; - pub const polyRectangle = import.xcb_poly_rectangle; - pub const polyArcChecked = import.xcb_poly_arc_checked; - pub const polyArc = import.xcb_poly_arc; - pub const fillPolyChecked = import.xcb_fill_poly_checked; - pub const fillPoly = import.xcb_fill_poly; - pub const polyFillRectangleChecked = import.xcb_poly_fill_rectangle_checked; - pub const polyFillRectangle = import.xcb_poly_fill_rectangle; - pub const polyFillArcChecked = import.xcb_poly_fill_arc_checked; - pub const polyFillArc = import.xcb_poly_fill_arc; - pub const putImageChecked = import.xcb_put_image_checked; - pub const putImage = import.xcb_put_image; - pub const getImage = import.xcb_get_image; - pub const getImageUnchecked = import.xcb_get_image_unchecked; - pub const getImageReply = import.xcb_get_image_reply; - pub const polyText8Checked = import.xcb_poly_text_8_checked; - pub const polyText8 = import.xcb_poly_text_8; - pub const polyText16Checked = import.xcb_poly_text_16_checked; - pub const polyText16 = import.xcb_poly_text_16; - pub const imageText8Checked = import.xcb_image_text_8_checked; - pub const imageText8 = import.xcb_image_text_8; - pub const imageText16Checked = import.xcb_image_text_16_checked; - pub const imageText16 = import.xcb_image_text_16; - pub const createColormapChecked = import.xcb_create_colormap_checked; - pub const createColormap = import.xcb_create_colormap; - pub const freeColormapChecked = import.xcb_free_colormap_checked; - pub const freeColormap = import.xcb_free_colormap; - pub const copyColormapAndFreeChecked = import.xcb_copy_colormap_and_free_checked; - pub const copyColormapAndFree = import.xcb_copy_colormap_and_free; - pub const installColormapChecked = import.xcb_install_colormap_checked; - pub const installColormap = import.xcb_install_colormap; - pub const uninstallColormapChecked = import.xcb_uninstall_colormap_checked; - pub const uninstallColormap = import.xcb_uninstall_colormap; - pub const listInstalledColormaps = import.xcb_list_installed_colormaps; - pub const listInstalledColormapsUnchecked = import.xcb_list_installed_colormaps_unchecked; - pub const listInstalledColormapsReply = import.xcb_list_installed_colormaps_reply; - pub const allocColor = import.xcb_alloc_color; - pub const allocColorUnchecked = import.xcb_alloc_color_unchecked; - pub const allocColorReply = import.xcb_alloc_color_reply; - pub const allocNamedColor = import.xcb_alloc_named_color; - pub const allocNamedColorUnchecked = import.xcb_alloc_named_color_unchecked; - pub const allocNamedColorReply = import.xcb_alloc_named_color_reply; - pub const allocColorCells = import.xcb_alloc_color_cells; - pub const allocColorCellsUnchecked = import.xcb_alloc_color_cells_unchecked; - pub const allocColorCellsReply = import.xcb_alloc_color_cells_reply; - pub const allocColorPlanes = import.xcb_alloc_color_planes; - pub const allocColorPlanesUnchecked = import.xcb_alloc_color_planes_unchecked; - pub const allocColorPlanesReply = import.xcb_alloc_color_planes_reply; - pub const freeColorsChecked = import.xcb_free_colors_checked; - pub const freeColors = import.xcb_free_colors; - pub const storeColorsChecked = import.xcb_store_colors_checked; - pub const storeColors = import.xcb_store_colors; - pub const storeNamedColorChecked = import.xcb_store_named_color_checked; - pub const storeNamedColor = import.xcb_store_named_color; - pub const queryColors = import.xcb_query_colors; - pub const queryColorsUnchecked = import.xcb_query_colors_unchecked; - pub const queryColorsReply = import.xcb_query_colors_reply; - pub const lookupColor = import.xcb_lookup_color; - pub const lookupColorUnchecked = import.xcb_lookup_color_unchecked; - pub const lookupColorReply = import.xcb_lookup_color_reply; - pub const createCursorChecked = import.xcb_create_cursor_checked; - pub const createCursor = import.xcb_create_cursor; - pub const createGlyphCursorChecked = import.xcb_create_glyph_cursor_checked; - pub const createGlyphCursor = import.xcb_create_glyph_cursor; - pub const freeCursorChecked = import.xcb_free_cursor_checked; - pub const freeCursor = import.xcb_free_cursor; - pub const recolorCursorChecked = import.xcb_recolor_cursor_checked; - pub const recolorCursor = import.xcb_recolor_cursor; - pub const queryBestSize = import.xcb_query_best_size; - pub const queryBestSizeUnchecked = import.xcb_query_best_size_unchecked; - pub const queryBestSizeReply = import.xcb_query_best_size_reply; - pub const queryExtension = import.xcb_query_extension; - pub const queryExtensionUnchecked = import.xcb_query_extension_unchecked; - pub const queryExtensionReply = import.xcb_query_extension_reply; - pub const listExtensions = import.xcb_list_extensions; - pub const listExtensionsUnchecked = import.xcb_list_extensions_unchecked; - pub const listExtensionsReply = import.xcb_list_extensions_reply; - pub const changeKeyboardMappingChecked = import.xcb_change_keyboard_mapping_checked; - pub const changeKeyboardMapping = import.xcb_change_keyboard_mapping; - pub const getKeyboardMapping = import.xcb_get_keyboard_mapping; - pub const getKeyboardMappingUnchecked = import.xcb_get_keyboard_mapping_unchecked; - pub const getKeyboardMappingReply = import.xcb_get_keyboard_mapping_reply; - pub const changeKeyboardControlChecked = import.xcb_change_keyboard_control_checked; - pub const changeKeyboardControl = import.xcb_change_keyboard_control; - pub const changeKeyboardControlAuxChecked = import.xcb_change_keyboard_control_aux_checked; - pub const changeKeyboardControlAux = import.xcb_change_keyboard_control_aux; - pub const getKeyboardControl = import.xcb_get_keyboard_control; - pub const getKeyboardControlUnchecked = import.xcb_get_keyboard_control_unchecked; - pub const getKeyboardControlReply = import.xcb_get_keyboard_control_reply; - pub const bellChecked = import.xcb_bell_checked; - pub const bell = import.xcb_bell; - pub const changePointerControlChecked = import.xcb_change_pointer_control_checked; - pub const changePointerControl = import.xcb_change_pointer_control; - pub const getPointerControl = import.xcb_get_pointer_control; - pub const getPointerControlUnchecked = import.xcb_get_pointer_control_unchecked; - pub const getPointerControlReply = import.xcb_get_pointer_control_reply; - pub const setScreenSaverChecked = import.xcb_set_screen_saver_checked; - pub const setScreenSaver = import.xcb_set_screen_saver; - pub const getScreenSaver = import.xcb_get_screen_saver; - pub const getScreenSaverUnchecked = import.xcb_get_screen_saver_unchecked; - pub const getScreenSaverReply = import.xcb_get_screen_saver_reply; - pub const changeHostsChecked = import.xcb_change_hosts_checked; - pub const changeHosts = import.xcb_change_hosts; - pub const listHosts = import.xcb_list_hosts; - pub const listHostsUnchecked = import.xcb_list_hosts_unchecked; - pub const listHostsReply = import.xcb_list_hosts_reply; - pub const setAccessControlChecked = import.xcb_set_access_control_checked; - pub const setAccessControl = import.xcb_set_access_control; - pub const setCloseDownModeChecked = import.xcb_set_close_down_mode_checked; - pub const setCloseDownMode = import.xcb_set_close_down_mode; - pub const killClientChecked = import.xcb_kill_client_checked; - pub const killClient = import.xcb_kill_client; - pub const rotatePropertiesChecked = import.xcb_rotate_properties_checked; - pub const rotateProperties = import.xcb_rotate_properties; - pub const forceScreenSaverChecked = import.xcb_force_screen_saver_checked; - pub const forceScreenSaver = import.xcb_force_screen_saver; - pub const setPointerMapping = import.xcb_set_pointer_mapping; - pub const setPointerMappingUnchecked = import.xcb_set_pointer_mapping_unchecked; - pub const setPointerMappingReply = import.xcb_set_pointer_mapping_reply; - pub const getPointerMapping = import.xcb_get_pointer_mapping; - pub const getPointerMappingUnchecked = import.xcb_get_pointer_mapping_unchecked; - pub const getPointerMappingReply = import.xcb_get_pointer_mapping_reply; - pub const setModifierMapping = import.xcb_set_modifier_mapping; - pub const setModifierMappingUnchecked = import.xcb_set_modifier_mapping_unchecked; - pub const setModifierMappingReply = import.xcb_set_modifier_mapping_reply; - pub const getModifierMapping = import.xcb_get_modifier_mapping; - pub const getModifierMappingUnchecked = import.xcb_get_modifier_mapping_unchecked; - pub const getModifierMappingReply = import.xcb_get_modifier_mapping_reply; - pub const noOperationChecked = import.xcb_no_operation_checked; - pub const noOperation = import.xcb_no_operation; - pub const flush = import.xcb_flush; - pub const getMaximumRequestLength = import.xcb_get_maximum_request_length; - pub const prefetchMaximumRequestLength = import.xcb_prefetch_maximum_request_length; - pub const waitForEvent = import.xcb_wait_for_event; - pub const pollForEvent = import.xcb_poll_for_event; - pub const pollForQueuedEvent = import.xcb_poll_for_queued_event; - pub const pollForSpecialEvent = import.xcb_poll_for_special_event; - pub const waitForSpecialEvent = import.xcb_wait_for_special_event; - pub const registerForSpecialXge = import.xcb_register_for_special_xge; - pub const unregisterForSpecialEvent = import.xcb_unregister_for_special_event; - pub const requestCheck = import.xcb_request_check; - pub const discardReply = import.xcb_discard_reply; - pub const discardReply64 = import.xcb_discard_reply64; - pub const getExtensionData = import.xcb_get_extension_data; - pub const prefetchExtensionData = import.xcb_prefetch_extension_data; - pub const getSetup = import.xcb_get_setup; - pub const getFileDescriptor = import.xcb_get_file_descriptor; - pub const connectionHasError = import.xcb_connection_has_error; - pub const disconnect = import.xcb_disconnect; - pub const generateId = import.xcb_generate_id; - pub const totalRead = import.xcb_total_read; - pub const totalWritten = import.xcb_total_written; + + // --- CONSTRUCTORS -------------------------------------------------------- + + pub inline fn connectToFd(fd: c_int, auth_info: ?*AuthInfo) *Connection { + return import.xcb_connect_to_fd(fd, auth_info); + } + + pub inline fn connect(displayname: ?[*:0]const u8, screenp: ?*c_int) *Connection { + return import.xcb_connect(displayname, screenp); + } + + pub inline fn connectToDisplayWithAuthInfo(display: ?[*:0]const u8, auth: ?*AuthInfo, screen: ?*c_int) *Connection { + return import.xcb_connect_to_display_with_auth_info(display, auth, screen); + } + + // --- METHODS ------------------------------------------------------------- + + pub inline fn createWindowChecked(c: *Connection, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, _class: WindowClass, visual: Visualid, value_mask: Cw, value_list: ?*const anyopaque) VoidCookie { + return import.xcb_create_window_checked(c, depth, wid, parent, x, y, width, height, border_width, _class, visual, value_mask, value_list); + } + + pub inline fn createWindow(c: *Connection, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, _class: WindowClass, visual: Visualid, value_mask: Cw, value_list: ?*const anyopaque) VoidCookie { + return import.xcb_create_window(c, depth, wid, parent, x, y, width, height, border_width, _class, visual, value_mask, value_list); + } + + pub inline fn createWindowAuxChecked(c: *Connection, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, _class: WindowClass, visual: Visualid, value_mask: Cw, value_list: [*c]const CreateWindowValueList) VoidCookie { + return import.xcb_create_window_aux_checked(c, depth, wid, parent, x, y, width, height, border_width, _class, visual, value_mask, value_list); + } + + pub inline fn createWindowAux(c: *Connection, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, _class: WindowClass, visual: Visualid, value_mask: Cw, value_list: [*c]const CreateWindowValueList) VoidCookie { + return import.xcb_create_window_aux(c, depth, wid, parent, x, y, width, height, border_width, _class, visual, value_mask, value_list); + } + + pub inline fn changeWindowAttributesChecked(c: *Connection, window: Window, value_mask: u32, value_list: ?*const anyopaque) VoidCookie { + return import.xcb_change_window_attributes_checked(c, window, value_mask, value_list); + } + + pub inline fn changeWindowAttributes(c: *Connection, window: Window, value_mask: u32, value_list: ?*const anyopaque) VoidCookie { + return import.xcb_change_window_attributes(c, window, value_mask, value_list); + } + + pub inline fn changeWindowAttributesAuxChecked(c: *Connection, window: Window, value_mask: u32, value_list: [*c]const ChangeWindowAttributesValueList) VoidCookie { + return import.xcb_change_window_attributes_aux_checked(c, window, value_mask, value_list); + } + + pub inline fn changeWindowAttributesAux(c: *Connection, window: Window, value_mask: u32, value_list: [*c]const ChangeWindowAttributesValueList) VoidCookie { + return import.xcb_change_window_attributes_aux(c, window, value_mask, value_list); + } + + pub inline fn getWindowAttributes(c: *Connection, window: Window) GetWindowAttributesCookie { + return import.xcb_get_window_attributes(c, window); + } + + pub inline fn getWindowAttributesUnchecked(c: *Connection, window: Window) GetWindowAttributesCookie { + return import.xcb_get_window_attributes_unchecked(c, window); + } + + pub inline fn getWindowAttributesReply(c: *Connection, cookie: GetWindowAttributesCookie, e: ?*?*GenericError) ?*GetWindowAttributesReply { + return import.xcb_get_window_attributes_reply(c, cookie, e); + } + + pub inline fn destroyWindowChecked(c: *Connection, window: Window) VoidCookie { + return import.xcb_destroy_window_checked(c, window); + } + + pub inline fn destroyWindow(c: *Connection, window: Window) VoidCookie { + return import.xcb_destroy_window(c, window); + } + + pub inline fn destroySubwindowsChecked(c: *Connection, window: Window) VoidCookie { + return import.xcb_destroy_subwindows_checked(c, window); + } + + pub inline fn destroySubwindows(c: *Connection, window: Window) VoidCookie { + return import.xcb_destroy_subwindows(c, window); + } + + pub inline fn changeSaveSetChecked(c: *Connection, mode: u8, window: Window) VoidCookie { + return import.xcb_change_save_set_checked(c, mode, window); + } + + pub inline fn changeSaveSet(c: *Connection, mode: u8, window: Window) VoidCookie { + return import.xcb_change_save_set(c, mode, window); + } + + pub inline fn reparentWindowChecked(c: *Connection, window: Window, parent: Window, x: i16, y: i16) VoidCookie { + return import.xcb_reparent_window_checked(c, window, parent, x, y); + } + + pub inline fn reparentWindow(c: *Connection, window: Window, parent: Window, x: i16, y: i16) VoidCookie { + return import.xcb_reparent_window(c, window, parent, x, y); + } + + pub inline fn mapWindowChecked(c: *Connection, window: Window) VoidCookie { + return import.xcb_map_window_checked(c, window); + } + + pub inline fn mapWindow(c: *Connection, window: Window) VoidCookie { + return import.xcb_map_window(c, window); + } + + pub inline fn mapSubwindowsChecked(c: *Connection, window: Window) VoidCookie { + return import.xcb_map_subwindows_checked(c, window); + } + + pub inline fn mapSubwindows(c: *Connection, window: Window) VoidCookie { + return import.xcb_map_subwindows(c, window); + } + + pub inline fn unmapWindowChecked(c: *Connection, window: Window) VoidCookie { + return import.xcb_unmap_window_checked(c, window); + } + + pub inline fn unmapWindow(c: *Connection, window: Window) VoidCookie { + return import.xcb_unmap_window(c, window); + } + + pub inline fn unmapSubwindowsChecked(c: *Connection, window: Window) VoidCookie { + return import.xcb_unmap_subwindows_checked(c, window); + } + + pub inline fn unmapSubwindows(c: *Connection, window: Window) VoidCookie { + return import.xcb_unmap_subwindows(c, window); + } + + pub inline fn configureWindowChecked(c: *Connection, window: Window, value_mask: u16, value_list: ?*const anyopaque) VoidCookie { + return import.xcb_configure_window_checked(c, window, value_mask, value_list); + } + + pub inline fn configureWindow(c: *Connection, window: Window, value_mask: u16, value_list: ?*const anyopaque) VoidCookie { + return import.xcb_configure_window(c, window, value_mask, value_list); + } + + pub inline fn configureWindowAuxChecked(c: *Connection, window: Window, value_mask: u16, value_list: [*c]const ConfigureWindowValueList) VoidCookie { + return import.xcb_configure_window_aux_checked(c, window, value_mask, value_list); + } + + pub inline fn configureWindowAux(c: *Connection, window: Window, value_mask: u16, value_list: [*c]const ConfigureWindowValueList) VoidCookie { + return import.xcb_configure_window_aux(c, window, value_mask, value_list); + } + + pub inline fn circulateWindowChecked(c: *Connection, direction: u8, window: Window) VoidCookie { + return import.xcb_circulate_window_checked(c, direction, window); + } + + pub inline fn circulateWindow(c: *Connection, direction: u8, window: Window) VoidCookie { + return import.xcb_circulate_window(c, direction, window); + } + + pub inline fn getGeometry(c: *Connection, drawable: Drawable) GetGeometryCookie { + return import.xcb_get_geometry(c, drawable); + } + + pub inline fn getGeometryUnchecked(c: *Connection, drawable: Drawable) GetGeometryCookie { + return import.xcb_get_geometry_unchecked(c, drawable); + } + + pub inline fn getGeometryReply(c: *Connection, cookie: GetGeometryCookie, e: ?*?*GenericError) ?*GetGeometryReply { + return import.xcb_get_geometry_reply(c, cookie, e); + } + + pub inline fn queryTree(c: *Connection, window: Window) QueryTreeCookie { + return import.xcb_query_tree(c, window); + } + + pub inline fn queryTreeUnchecked(c: *Connection, window: Window) QueryTreeCookie { + return import.xcb_query_tree_unchecked(c, window); + } + + pub inline fn queryTreeReply(c: *Connection, cookie: QueryTreeCookie, e: ?*?*GenericError) ?*QueryTreeReply { + return import.xcb_query_tree_reply(c, cookie, e); + } + + pub inline fn internAtom(c: *Connection, only_if_exists: bool, name: []const u8) InternAtomCookie { + return import.xcb_intern_atom(c, if (only_if_exists) 1 else 0, @intCast(name.len), name.ptr); + } + + pub inline fn internAtomUnchecked(c: *Connection, only_if_exists: u8, name_len: u16, name: [*c]const u8) InternAtomCookie { + return import.xcb_intern_atom_unchecked(c, only_if_exists, name_len, name); + } + + pub inline fn internAtomReply(c: *Connection, cookie: InternAtomCookie, e: ?*?*GenericError) ?*InternAtomReply { + return import.xcb_intern_atom_reply(c, cookie, e); + } + + pub inline fn getAtomName(c: *Connection, atom: Atom) GetAtomNameCookie { + return import.xcb_get_atom_name(c, atom); + } + + pub inline fn getAtomNameUnchecked(c: *Connection, atom: Atom) GetAtomNameCookie { + return import.xcb_get_atom_name_unchecked(c, atom); + } + + pub inline fn getAtomNameReply(c: *Connection, cookie: GetAtomNameCookie, e: ?*?*GenericError) ?*GetAtomNameReply { + return import.xcb_get_atom_name_reply(c, cookie, e); + } + + pub inline fn changePropertyChecked(c: *Connection, mode: PropMode, window: Window, property: Atom, @"type": Atom, format: u8, data_len: u32, data: ?*const anyopaque) VoidCookie { + return import.xcb_change_property_checked(c, mode, window, property, @"type", format, data_len, data); + } + + pub inline fn changeProperty(c: *Connection, mode: PropMode, window: Window, property: Atom, @"type": Atom, format: u8, data_len: u32, data: ?*const anyopaque) VoidCookie { + return import.xcb_change_property(c, mode, window, property, @"type", format, data_len, data); + } + + pub inline fn deletePropertyChecked(c: *Connection, window: Window, property: Atom) VoidCookie { + return import.xcb_delete_property_checked(c, window, property); + } + + pub inline fn deleteProperty(c: *Connection, window: Window, property: Atom) VoidCookie { + return import.xcb_delete_property(c, window, property); + } + + pub inline fn getProperty(c: *Connection, _delete: u8, window: Window, property: Atom, @"type": Atom, long_offset: u32, long_length: u32) GetPropertyCookie { + return import.xcb_get_property(c, _delete, window, property, @"type", long_offset, long_length); + } + + pub inline fn getPropertyUnchecked(c: *Connection, _delete: u8, window: Window, property: Atom, @"type": Atom, long_offset: u32, long_length: u32) GetPropertyCookie { + return import.xcb_get_property_unchecked(c, _delete, window, property, @"type", long_offset, long_length); + } + + pub inline fn getPropertyReply(c: *Connection, cookie: GetPropertyCookie, e: ?*?*GenericError) ?*GetPropertyReply { + return import.xcb_get_property_reply(c, cookie, e); + } + + pub inline fn listProperties(c: *Connection, window: Window) ListPropertiesCookie { + return import.xcb_list_properties(c, window); + } + + pub inline fn listPropertiesUnchecked(c: *Connection, window: Window) ListPropertiesCookie { + return import.xcb_list_properties_unchecked(c, window); + } + + pub inline fn listPropertiesReply(c: *Connection, cookie: ListPropertiesCookie, e: ?*?*GenericError) ?*ListPropertiesReply { + return import.xcb_list_properties_reply(c, cookie, e); + } + + pub inline fn setSelectionOwnerChecked(c: *Connection, owner: Window, selection: Atom, time: Timestamp) VoidCookie { + return import.xcb_set_selection_owner_checked(c, owner, selection, time); + } + + pub inline fn setSelectionOwner(c: *Connection, owner: Window, selection: Atom, time: Timestamp) VoidCookie { + return import.xcb_set_selection_owner(c, owner, selection, time); + } + + pub inline fn getSelectionOwner(c: *Connection, selection: Atom) GetSelectionOwnerCookie { + return import.xcb_get_selection_owner(c, selection); + } + + pub inline fn getSelectionOwnerUnchecked(c: *Connection, selection: Atom) GetSelectionOwnerCookie { + return import.xcb_get_selection_owner_unchecked(c, selection); + } + + pub inline fn getSelectionOwnerReply(c: *Connection, cookie: GetSelectionOwnerCookie, e: ?*?*GenericError) ?*GetSelectionOwnerReply { + return import.xcb_get_selection_owner_reply(c, cookie, e); + } + + pub inline fn convertSelectionChecked(c: *Connection, requestor: Window, selection: Atom, target: Atom, property: Atom, time: Timestamp) VoidCookie { + return import.xcb_convert_selection_checked(c, requestor, selection, target, property, time); + } + + pub inline fn convertSelection(c: *Connection, requestor: Window, selection: Atom, target: Atom, property: Atom, time: Timestamp) VoidCookie { + return import.xcb_convert_selection(c, requestor, selection, target, property, time); + } + + pub inline fn sendEventChecked(c: *Connection, propagate: u8, destination: Window, event_mask: u32, event: [*c]const u8) VoidCookie { + return import.xcb_send_event_checked(c, propagate, destination, event_mask, event); + } + + pub inline fn sendEvent(c: *Connection, propagate: u8, destination: Window, event_mask: u32, event: [*c]const u8) VoidCookie { + return import.xcb_send_event(c, propagate, destination, event_mask, event); + } + + pub inline fn grabPointer(c: *Connection, owner_events: u8, grab_window: Window, event_mask: u16, pointer_mode: u8, keyboard_mode: u8, confine_to: Window, cursor: Cursor, time: Timestamp) GrabPointerCookie { + return import.xcb_grab_pointer(c, owner_events, grab_window, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, time); + } + + pub inline fn grabPointerUnchecked(c: *Connection, owner_events: u8, grab_window: Window, event_mask: u16, pointer_mode: u8, keyboard_mode: u8, confine_to: Window, cursor: Cursor, time: Timestamp) GrabPointerCookie { + return import.xcb_grab_pointer_unchecked(c, owner_events, grab_window, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, time); + } + + pub inline fn grabPointerReply(c: *Connection, cookie: GrabPointerCookie, e: ?*?*GenericError) ?*GrabPointerReply { + return import.xcb_grab_pointer_reply(c, cookie, e); + } + + pub inline fn ungrabPointerChecked(c: *Connection, time: Timestamp) VoidCookie { + return import.xcb_ungrab_pointer_checked(c, time); + } + + pub inline fn ungrabPointer(c: *Connection, time: Timestamp) VoidCookie { + return import.xcb_ungrab_pointer(c, time); + } + + pub inline fn grabButtonChecked(c: *Connection, owner_events: u8, grab_window: Window, event_mask: u16, pointer_mode: u8, keyboard_mode: u8, confine_to: Window, cursor: Cursor, button: u8, modifiers: u16) VoidCookie { + return import.xcb_grab_button_checked(c, owner_events, grab_window, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, button, modifiers); + } + + pub inline fn grabButton(c: *Connection, owner_events: u8, grab_window: Window, event_mask: u16, pointer_mode: u8, keyboard_mode: u8, confine_to: Window, cursor: Cursor, button: u8, modifiers: u16) VoidCookie { + return import.xcb_grab_button(c, owner_events, grab_window, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, button, modifiers); + } + + pub inline fn ungrabButtonChecked(c: *Connection, button: u8, grab_window: Window, modifiers: u16) VoidCookie { + return import.xcb_ungrab_button_checked(c, button, grab_window, modifiers); + } + + pub inline fn ungrabButton(c: *Connection, button: u8, grab_window: Window, modifiers: u16) VoidCookie { + return import.xcb_ungrab_button(c, button, grab_window, modifiers); + } + + pub inline fn changeActivePointerGrabChecked(c: *Connection, cursor: Cursor, time: Timestamp, event_mask: u16) VoidCookie { + return import.xcb_change_active_pointer_grab_checked(c, cursor, time, event_mask); + } + + pub inline fn changeActivePointerGrab(c: *Connection, cursor: Cursor, time: Timestamp, event_mask: u16) VoidCookie { + return import.xcb_change_active_pointer_grab(c, cursor, time, event_mask); + } + + pub inline fn grabKeyboard(c: *Connection, owner_events: u8, grab_window: Window, time: Timestamp, pointer_mode: u8, keyboard_mode: u8) GrabKeyboardCookie { + return import.xcb_grab_keyboard(c, owner_events, grab_window, time, pointer_mode, keyboard_mode); + } + + pub inline fn grabKeyboardUnchecked(c: *Connection, owner_events: u8, grab_window: Window, time: Timestamp, pointer_mode: u8, keyboard_mode: u8) GrabKeyboardCookie { + return import.xcb_grab_keyboard_unchecked(c, owner_events, grab_window, time, pointer_mode, keyboard_mode); + } + + pub inline fn grabKeyboardReply(c: *Connection, cookie: GrabKeyboardCookie, e: ?*?*GenericError) ?*GrabKeyboardReply { + return import.xcb_grab_keyboard_reply(c, cookie, e); + } + + pub inline fn ungrabKeyboardChecked(c: *Connection, time: Timestamp) VoidCookie { + return import.xcb_ungrab_keyboard_checked(c, time); + } + + pub inline fn ungrabKeyboard(c: *Connection, time: Timestamp) VoidCookie { + return import.xcb_ungrab_keyboard(c, time); + } + + pub inline fn grabKeyChecked(c: *Connection, owner_events: u8, grab_window: Window, modifiers: u16, key: Keycode, pointer_mode: u8, keyboard_mode: u8) VoidCookie { + return import.xcb_grab_key_checked(c, owner_events, grab_window, modifiers, key, pointer_mode, keyboard_mode); + } + + pub inline fn grabKey(c: *Connection, owner_events: u8, grab_window: Window, modifiers: u16, key: Keycode, pointer_mode: u8, keyboard_mode: u8) VoidCookie { + return import.xcb_grab_key(c, owner_events, grab_window, modifiers, key, pointer_mode, keyboard_mode); + } + + pub inline fn ungrabKeyChecked(c: *Connection, key: Keycode, grab_window: Window, modifiers: u16) VoidCookie { + return import.xcb_ungrab_key_checked(c, key, grab_window, modifiers); + } + + pub inline fn ungrabKey(c: *Connection, key: Keycode, grab_window: Window, modifiers: u16) VoidCookie { + return import.xcb_ungrab_key(c, key, grab_window, modifiers); + } + + pub inline fn allowEventsChecked(c: *Connection, mode: u8, time: Timestamp) VoidCookie { + return import.xcb_allow_events_checked(c, mode, time); + } + + pub inline fn allowEvents(c: *Connection, mode: u8, time: Timestamp) VoidCookie { + return import.xcb_allow_events(c, mode, time); + } + + pub inline fn grabServerChecked(c: *Connection) VoidCookie { + return import.xcb_grab_server_checked(c); + } + + pub inline fn grabServer(c: *Connection) VoidCookie { + return import.xcb_grab_server(c); + } + + pub inline fn ungrabServerChecked(c: *Connection) VoidCookie { + return import.xcb_ungrab_server_checked(c); + } + + pub inline fn ungrabServer(c: *Connection) VoidCookie { + return import.xcb_ungrab_server(c); + } + + pub inline fn queryPointer(c: *Connection, window: Window) QueryPointerCookie { + return import.xcb_query_pointer(c, window); + } + + pub inline fn queryPointerUnchecked(c: *Connection, window: Window) QueryPointerCookie { + return import.xcb_query_pointer_unchecked(c, window); + } + + pub inline fn queryPointerReply(c: *Connection, cookie: QueryPointerCookie, e: ?*?*GenericError) ?*QueryPointerReply { + return import.xcb_query_pointer_reply(c, cookie, e); + } + + pub inline fn getMotionEvents(c: *Connection, window: Window, start: Timestamp, stop: Timestamp) GetMotionEventsCookie { + return import.xcb_get_motion_events(c, window, start, stop); + } + + pub inline fn getMotionEventsUnchecked(c: *Connection, window: Window, start: Timestamp, stop: Timestamp) GetMotionEventsCookie { + return import.xcb_get_motion_events_unchecked(c, window, start, stop); + } + + pub inline fn getMotionEventsReply(c: *Connection, cookie: GetMotionEventsCookie, e: ?*?*GenericError) ?*GetMotionEventsReply { + return import.xcb_get_motion_events_reply(c, cookie, e); + } + + pub inline fn translateCoordinates(c: *Connection, src_window: Window, dst_window: Window, src_x: i16, src_y: i16) TranslateCoordinatesCookie { + return import.xcb_translate_coordinates(c, src_window, dst_window, src_x, src_y); + } + + pub inline fn translateCoordinatesUnchecked(c: *Connection, src_window: Window, dst_window: Window, src_x: i16, src_y: i16) TranslateCoordinatesCookie { + return import.xcb_translate_coordinates_unchecked(c, src_window, dst_window, src_x, src_y); + } + + pub inline fn translateCoordinatesReply(c: *Connection, cookie: TranslateCoordinatesCookie, e: ?*?*GenericError) ?*TranslateCoordinatesReply { + return import.xcb_translate_coordinates_reply(c, cookie, e); + } + + pub inline fn warpPointerChecked(c: *Connection, src_window: Window, dst_window: Window, src_x: i16, src_y: i16, src_width: u16, src_height: u16, dst_x: i16, dst_y: i16) VoidCookie { + return import.xcb_warp_pointer_checked(c, src_window, dst_window, src_x, src_y, src_width, src_height, dst_x, dst_y); + } + + pub inline fn warpPointer(c: *Connection, src_window: Window, dst_window: Window, src_x: i16, src_y: i16, src_width: u16, src_height: u16, dst_x: i16, dst_y: i16) VoidCookie { + return import.xcb_warp_pointer(c, src_window, dst_window, src_x, src_y, src_width, src_height, dst_x, dst_y); + } + + pub inline fn setInputFocusChecked(c: *Connection, revert_to: u8, focus: Window, time: Timestamp) VoidCookie { + return import.xcb_set_input_focus_checked(c, revert_to, focus, time); + } + + pub inline fn setInputFocus(c: *Connection, revert_to: u8, focus: Window, time: Timestamp) VoidCookie { + return import.xcb_set_input_focus(c, revert_to, focus, time); + } + + pub inline fn getInputFocus(c: *Connection) GetInputFocusCookie { + return import.xcb_get_input_focus(c); + } + + pub inline fn getInputFocusUnchecked(c: *Connection) GetInputFocusCookie { + return import.xcb_get_input_focus_unchecked(c); + } + + pub inline fn getInputFocusReply(c: *Connection, cookie: GetInputFocusCookie, e: ?*?*GenericError) ?*GetInputFocusReply { + return import.xcb_get_input_focus_reply(c, cookie, e); + } + + pub inline fn queryKeymap(c: *Connection) QueryKeymapCookie { + return import.xcb_query_keymap(c); + } + + pub inline fn queryKeymapUnchecked(c: *Connection) QueryKeymapCookie { + return import.xcb_query_keymap_unchecked(c); + } + + pub inline fn queryKeymapReply(c: *Connection, cookie: QueryKeymapCookie, e: ?*?*GenericError) ?*QueryKeymapReply { + return import.xcb_query_keymap_reply(c, cookie, e); + } + + pub inline fn openFontChecked(c: *Connection, fid: Font, name_len: u16, name: [*c]const u8) VoidCookie { + return import.xcb_open_font_checked(c, fid, name_len, name); + } + + pub inline fn openFont(c: *Connection, fid: Font, name_len: u16, name: [*c]const u8) VoidCookie { + return import.xcb_open_font(c, fid, name_len, name); + } + + pub inline fn closeFontChecked(c: *Connection, font: Font) VoidCookie { + return import.xcb_close_font_checked(c, font); + } + + pub inline fn closeFont(c: *Connection, font: Font) VoidCookie { + return import.xcb_close_font(c, font); + } + + pub inline fn queryFont(c: *Connection, font: Fontable) QueryFontCookie { + return import.xcb_query_font(c, font); + } + + pub inline fn queryFontUnchecked(c: *Connection, font: Fontable) QueryFontCookie { + return import.xcb_query_font_unchecked(c, font); + } + + pub inline fn queryFontReply(c: *Connection, cookie: QueryFontCookie, e: ?*?*GenericError) ?*QueryFontReply { + return import.xcb_query_font_reply(c, cookie, e); + } + + pub inline fn queryTextExtents(c: *Connection, font: Fontable, string_len: u32, string: [*c]const Char2B) QueryTextExtentsCookie { + return import.xcb_query_text_extents(c, font, string_len, string); + } + + pub inline fn queryTextExtentsUnchecked(c: *Connection, font: Fontable, string_len: u32, string: [*c]const Char2B) QueryTextExtentsCookie { + return import.xcb_query_text_extents_unchecked(c, font, string_len, string); + } + + pub inline fn queryTextExtentsReply(c: *Connection, cookie: QueryTextExtentsCookie, e: ?*?*GenericError) ?*QueryTextExtentsReply { + return import.xcb_query_text_extents_reply(c, cookie, e); + } + + pub inline fn listFonts(c: *Connection, max_names: u16, pattern_len: u16, pattern: [*c]const u8) ListFontsCookie { + return import.xcb_list_fonts(c, max_names, pattern_len, pattern); + } + + pub inline fn listFontsUnchecked(c: *Connection, max_names: u16, pattern_len: u16, pattern: [*c]const u8) ListFontsCookie { + return import.xcb_list_fonts_unchecked(c, max_names, pattern_len, pattern); + } + + pub inline fn listFontsReply(c: *Connection, cookie: ListFontsCookie, e: ?*?*GenericError) ?*ListFontsReply { + return import.xcb_list_fonts_reply(c, cookie, e); + } + + pub inline fn listFontsWithInfo(c: *Connection, max_names: u16, pattern_len: u16, pattern: [*c]const u8) ListFontsWithInfoCookie { + return import.xcb_list_fonts_with_info(c, max_names, pattern_len, pattern); + } + + pub inline fn listFontsWithInfoUnchecked(c: *Connection, max_names: u16, pattern_len: u16, pattern: [*c]const u8) ListFontsWithInfoCookie { + return import.xcb_list_fonts_with_info_unchecked(c, max_names, pattern_len, pattern); + } + + pub inline fn listFontsWithInfoReply(c: *Connection, cookie: ListFontsWithInfoCookie, e: ?*?*GenericError) ?*ListFontsWithInfoReply { + return import.xcb_list_fonts_with_info_reply(c, cookie, e); + } + + pub inline fn setFontPathChecked(c: *Connection, font_qty: u16, font: [*c]const Str) VoidCookie { + return import.xcb_set_font_path_checked(c, font_qty, font); + } + + pub inline fn setFontPath(c: *Connection, font_qty: u16, font: [*c]const Str) VoidCookie { + return import.xcb_set_font_path(c, font_qty, font); + } + + pub inline fn getFontPath(c: *Connection) GetFontPathCookie { + return import.xcb_get_font_path(c); + } + + pub inline fn getFontPathUnchecked(c: *Connection) GetFontPathCookie { + return import.xcb_get_font_path_unchecked(c); + } + + pub inline fn getFontPathReply(c: *Connection, cookie: GetFontPathCookie, e: ?*?*GenericError) ?*GetFontPathReply { + return import.xcb_get_font_path_reply(c, cookie, e); + } + + pub inline fn createPixmapChecked(c: *Connection, depth: u8, pid: Pixmap, drawable: Drawable, width: u16, height: u16) VoidCookie { + return import.xcb_create_pixmap_checked(c, depth, pid, drawable, width, height); + } + + pub inline fn createPixmap(c: *Connection, depth: u8, pid: Pixmap, drawable: Drawable, width: u16, height: u16) VoidCookie { + return import.xcb_create_pixmap(c, depth, pid, drawable, width, height); + } + + pub inline fn freePixmapChecked(c: *Connection, pixmap: Pixmap) VoidCookie { + return import.xcb_free_pixmap_checked(c, pixmap); + } + + pub inline fn freePixmap(c: *Connection, pixmap: Pixmap) VoidCookie { + return import.xcb_free_pixmap(c, pixmap); + } + + pub inline fn createGcChecked(c: *Connection, cid: Gcontext, drawable: Drawable, value_mask: u32, value_list: ?*const anyopaque) VoidCookie { + return import.xcb_create_gc_checked(c, cid, drawable, value_mask, value_list); + } + + pub inline fn createGc(c: *Connection, cid: Gcontext, drawable: Drawable, value_mask: u32, value_list: ?*const anyopaque) VoidCookie { + return import.xcb_create_gc(c, cid, drawable, value_mask, value_list); + } + + pub inline fn createGcAuxChecked(c: *Connection, cid: Gcontext, drawable: Drawable, value_mask: u32, value_list: [*c]const CreateGcValueList) VoidCookie { + return import.xcb_create_gc_aux_checked(c, cid, drawable, value_mask, value_list); + } + + pub inline fn createGcAux(c: *Connection, cid: Gcontext, drawable: Drawable, value_mask: u32, value_list: [*c]const CreateGcValueList) VoidCookie { + return import.xcb_create_gc_aux(c, cid, drawable, value_mask, value_list); + } + + pub inline fn changeGcChecked(c: *Connection, gc: Gcontext, value_mask: u32, value_list: ?*const anyopaque) VoidCookie { + return import.xcb_change_gc_checked(c, gc, value_mask, value_list); + } + + pub inline fn changeGc(c: *Connection, gc: Gcontext, value_mask: u32, value_list: ?*const anyopaque) VoidCookie { + return import.xcb_change_gc(c, gc, value_mask, value_list); + } + + pub inline fn changeGcAuxChecked(c: *Connection, gc: Gcontext, value_mask: u32, value_list: [*c]const ChangeGcValueList) VoidCookie { + return import.xcb_change_gc_aux_checked(c, gc, value_mask, value_list); + } + + pub inline fn changeGcAux(c: *Connection, gc: Gcontext, value_mask: u32, value_list: [*c]const ChangeGcValueList) VoidCookie { + return import.xcb_change_gc_aux(c, gc, value_mask, value_list); + } + + pub inline fn copyGcChecked(c: *Connection, src_gc: Gcontext, dst_gc: Gcontext, value_mask: u32) VoidCookie { + return import.xcb_copy_gc_checked(c, src_gc, dst_gc, value_mask); + } + + pub inline fn copyGc(c: *Connection, src_gc: Gcontext, dst_gc: Gcontext, value_mask: u32) VoidCookie { + return import.xcb_copy_gc(c, src_gc, dst_gc, value_mask); + } + + pub inline fn setDashesChecked(c: *Connection, gc: Gcontext, dash_offset: u16, dashes_len: u16, dashes: [*c]const u8) VoidCookie { + return import.xcb_set_dashes_checked(c, gc, dash_offset, dashes_len, dashes); + } + + pub inline fn setDashes(c: *Connection, gc: Gcontext, dash_offset: u16, dashes_len: u16, dashes: [*c]const u8) VoidCookie { + return import.xcb_set_dashes(c, gc, dash_offset, dashes_len, dashes); + } + + pub inline fn setClipRectanglesChecked(c: *Connection, ordering: u8, gc: Gcontext, clip_x_origin: i16, clip_y_origin: i16, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie { + return import.xcb_set_clip_rectangles_checked(c, ordering, gc, clip_x_origin, clip_y_origin, rectangles_len, rectangles); + } + + pub inline fn setClipRectangles(c: *Connection, ordering: u8, gc: Gcontext, clip_x_origin: i16, clip_y_origin: i16, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie { + return import.xcb_set_clip_rectangles(c, ordering, gc, clip_x_origin, clip_y_origin, rectangles_len, rectangles); + } + + pub inline fn freeGcChecked(c: *Connection, gc: Gcontext) VoidCookie { + return import.xcb_free_gc_checked(c, gc); + } + + pub inline fn freeGc(c: *Connection, gc: Gcontext) VoidCookie { + return import.xcb_free_gc(c, gc); + } + + pub inline fn clearAreaChecked(c: *Connection, exposures: u8, window: Window, x: i16, y: i16, width: u16, height: u16) VoidCookie { + return import.xcb_clear_area_checked(c, exposures, window, x, y, width, height); + } + + pub inline fn clearArea(c: *Connection, exposures: u8, window: Window, x: i16, y: i16, width: u16, height: u16) VoidCookie { + return import.xcb_clear_area(c, exposures, window, x, y, width, height); + } + + pub inline fn copyAreaChecked(c: *Connection, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16) VoidCookie { + return import.xcb_copy_area_checked(c, src_drawable, dst_drawable, gc, src_x, src_y, dst_x, dst_y, width, height); + } + + pub inline fn copyArea(c: *Connection, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16) VoidCookie { + return import.xcb_copy_area(c, src_drawable, dst_drawable, gc, src_x, src_y, dst_x, dst_y, width, height); + } + + pub inline fn copyPlaneChecked(c: *Connection, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16, bit_plane: u32) VoidCookie { + return import.xcb_copy_plane_checked(c, src_drawable, dst_drawable, gc, src_x, src_y, dst_x, dst_y, width, height, bit_plane); + } + + pub inline fn copyPlane(c: *Connection, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16, bit_plane: u32) VoidCookie { + return import.xcb_copy_plane(c, src_drawable, dst_drawable, gc, src_x, src_y, dst_x, dst_y, width, height, bit_plane); + } + + pub inline fn polyPointChecked(c: *Connection, coordinate_mode: u8, drawable: Drawable, gc: Gcontext, points_len: u32, points: [*c]const Point) VoidCookie { + return import.xcb_poly_point_checked(c, coordinate_mode, drawable, gc, points_len, points); + } + + pub inline fn polyPoint(c: *Connection, coordinate_mode: u8, drawable: Drawable, gc: Gcontext, points_len: u32, points: [*c]const Point) VoidCookie { + return import.xcb_poly_point(c, coordinate_mode, drawable, gc, points_len, points); + } + + pub inline fn polyLineChecked(c: *Connection, coordinate_mode: u8, drawable: Drawable, gc: Gcontext, points_len: u32, points: [*c]const Point) VoidCookie { + return import.xcb_poly_line_checked(c, coordinate_mode, drawable, gc, points_len, points); + } + + pub inline fn polyLine(c: *Connection, coordinate_mode: u8, drawable: Drawable, gc: Gcontext, points_len: u32, points: [*c]const Point) VoidCookie { + return import.xcb_poly_line(c, coordinate_mode, drawable, gc, points_len, points); + } + + pub inline fn polySegmentChecked(c: *Connection, drawable: Drawable, gc: Gcontext, segments_len: u32, segments: [*c]const Segment) VoidCookie { + return import.xcb_poly_segment_checked(c, drawable, gc, segments_len, segments); + } + + pub inline fn polySegment(c: *Connection, drawable: Drawable, gc: Gcontext, segments_len: u32, segments: [*c]const Segment) VoidCookie { + return import.xcb_poly_segment(c, drawable, gc, segments_len, segments); + } + + pub inline fn polyRectangleChecked(c: *Connection, drawable: Drawable, gc: Gcontext, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie { + return import.xcb_poly_rectangle_checked(c, drawable, gc, rectangles_len, rectangles); + } + + pub inline fn polyRectangle(c: *Connection, drawable: Drawable, gc: Gcontext, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie { + return import.xcb_poly_rectangle(c, drawable, gc, rectangles_len, rectangles); + } + + pub inline fn polyArcChecked(c: *Connection, drawable: Drawable, gc: Gcontext, arcs_len: u32, arcs: [*c]const Arc) VoidCookie { + return import.xcb_poly_arc_checked(c, drawable, gc, arcs_len, arcs); + } + + pub inline fn polyArc(c: *Connection, drawable: Drawable, gc: Gcontext, arcs_len: u32, arcs: [*c]const Arc) VoidCookie { + return import.xcb_poly_arc(c, drawable, gc, arcs_len, arcs); + } + + pub inline fn fillPolyChecked(c: *Connection, drawable: Drawable, gc: Gcontext, shape: u8, coordinate_mode: u8, points_len: u32, points: [*c]const Point) VoidCookie { + return import.xcb_fill_poly_checked(c, drawable, gc, shape, coordinate_mode, points_len, points); + } + + pub inline fn fillPoly(c: *Connection, drawable: Drawable, gc: Gcontext, shape: u8, coordinate_mode: u8, points_len: u32, points: [*c]const Point) VoidCookie { + return import.xcb_fill_poly(c, drawable, gc, shape, coordinate_mode, points_len, points); + } + + pub inline fn polyFillRectangleChecked(c: *Connection, drawable: Drawable, gc: Gcontext, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie { + return import.xcb_poly_fill_rectangle_checked(c, drawable, gc, rectangles_len, rectangles); + } + + pub inline fn polyFillRectangle(c: *Connection, drawable: Drawable, gc: Gcontext, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie { + return import.xcb_poly_fill_rectangle(c, drawable, gc, rectangles_len, rectangles); + } + + pub inline fn polyFillArcChecked(c: *Connection, drawable: Drawable, gc: Gcontext, arcs_len: u32, arcs: [*c]const Arc) VoidCookie { + return import.xcb_poly_fill_arc_checked(c, drawable, gc, arcs_len, arcs); + } + + pub inline fn polyFillArc(c: *Connection, drawable: Drawable, gc: Gcontext, arcs_len: u32, arcs: [*c]const Arc) VoidCookie { + return import.xcb_poly_fill_arc(c, drawable, gc, arcs_len, arcs); + } + + pub inline fn putImageChecked(c: *Connection, format: u8, drawable: Drawable, gc: Gcontext, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data_len: u32, data: [*c]const u8) VoidCookie { + return import.xcb_put_image_checked(c, format, drawable, gc, width, height, dst_x, dst_y, left_pad, depth, data_len, data); + } + + pub inline fn putImage(c: *Connection, format: u8, drawable: Drawable, gc: Gcontext, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data_len: u32, data: [*c]const u8) VoidCookie { + return import.xcb_put_image(c, format, drawable, gc, width, height, dst_x, dst_y, left_pad, depth, data_len, data); + } + + pub inline fn getImage(c: *Connection, format: u8, drawable: Drawable, x: i16, y: i16, width: u16, height: u16, plane_mask: u32) GetImageCookie { + return import.xcb_get_image(c, format, drawable, x, y, width, height, plane_mask); + } + + pub inline fn getImageUnchecked(c: *Connection, format: u8, drawable: Drawable, x: i16, y: i16, width: u16, height: u16, plane_mask: u32) GetImageCookie { + return import.xcb_get_image_unchecked(c, format, drawable, x, y, width, height, plane_mask); + } + + pub inline fn getImageReply(c: *Connection, cookie: GetImageCookie, e: ?*?*GenericError) ?*GetImageReply { + return import.xcb_get_image_reply(c, cookie, e); + } + + pub inline fn polyText8Checked(c: *Connection, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items_len: u32, items: [*c]const u8) VoidCookie { + return import.xcb_poly_text_8_checked(c, drawable, gc, x, y, items_len, items); + } + + pub inline fn polyText8(c: *Connection, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items_len: u32, items: [*c]const u8) VoidCookie { + return import.xcb_poly_text_8(c, drawable, gc, x, y, items_len, items); + } + + pub inline fn polyText16Checked(c: *Connection, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items_len: u32, items: [*c]const u8) VoidCookie { + return import.xcb_poly_text_16_checked(c, drawable, gc, x, y, items_len, items); + } + + pub inline fn polyText16(c: *Connection, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items_len: u32, items: [*c]const u8) VoidCookie { + return import.xcb_poly_text_16(c, drawable, gc, x, y, items_len, items); + } + + pub inline fn imageText8Checked(c: *Connection, string_len: u8, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: [*c]const u8) VoidCookie { + return import.xcb_image_text_8_checked(c, string_len, drawable, gc, x, y, string); + } + + pub inline fn imageText8(c: *Connection, string_len: u8, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: [*c]const u8) VoidCookie { + return import.xcb_image_text_8(c, string_len, drawable, gc, x, y, string); + } + + pub inline fn imageText16Checked(c: *Connection, string_len: u8, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: [*c]const Char2B) VoidCookie { + return import.xcb_image_text_16_checked(c, string_len, drawable, gc, x, y, string); + } + + pub inline fn imageText16(c: *Connection, string_len: u8, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: [*c]const Char2B) VoidCookie { + return import.xcb_image_text_16(c, string_len, drawable, gc, x, y, string); + } + + pub inline fn createColormapChecked(c: *Connection, alloc: u8, mid: Colormap, window: Window, visual: Visualid) VoidCookie { + return import.xcb_create_colormap_checked(c, alloc, mid, window, visual); + } + + pub inline fn createColormap(c: *Connection, alloc: u8, mid: Colormap, window: Window, visual: Visualid) VoidCookie { + return import.xcb_create_colormap(c, alloc, mid, window, visual); + } + + pub inline fn freeColormapChecked(c: *Connection, cmap: Colormap) VoidCookie { + return import.xcb_free_colormap_checked(c, cmap); + } + + pub inline fn freeColormap(c: *Connection, cmap: Colormap) VoidCookie { + return import.xcb_free_colormap(c, cmap); + } + + pub inline fn copyColormapAndFreeChecked(c: *Connection, mid: Colormap, src_cmap: Colormap) VoidCookie { + return import.xcb_copy_colormap_and_free_checked(c, mid, src_cmap); + } + + pub inline fn copyColormapAndFree(c: *Connection, mid: Colormap, src_cmap: Colormap) VoidCookie { + return import.xcb_copy_colormap_and_free(c, mid, src_cmap); + } + + pub inline fn installColormapChecked(c: *Connection, cmap: Colormap) VoidCookie { + return import.xcb_install_colormap_checked(c, cmap); + } + + pub inline fn installColormap(c: *Connection, cmap: Colormap) VoidCookie { + return import.xcb_install_colormap(c, cmap); + } + + pub inline fn uninstallColormapChecked(c: *Connection, cmap: Colormap) VoidCookie { + return import.xcb_uninstall_colormap_checked(c, cmap); + } + + pub inline fn uninstallColormap(c: *Connection, cmap: Colormap) VoidCookie { + return import.xcb_uninstall_colormap(c, cmap); + } + + pub inline fn listInstalledColormaps(c: *Connection, window: Window) ListInstalledColormapsCookie { + return import.xcb_list_installed_colormaps(c, window); + } + + pub inline fn listInstalledColormapsUnchecked(c: *Connection, window: Window) ListInstalledColormapsCookie { + return import.xcb_list_installed_colormaps_unchecked(c, window); + } + + pub inline fn listInstalledColormapsReply(c: *Connection, cookie: ListInstalledColormapsCookie, e: ?*?*GenericError) ?*ListInstalledColormapsReply { + return import.xcb_list_installed_colormaps_reply(c, cookie, e); + } + + pub inline fn allocColor(c: *Connection, cmap: Colormap, red: u16, green: u16, blue: u16) AllocColorCookie { + return import.xcb_alloc_color(c, cmap, red, green, blue); + } + + pub inline fn allocColorUnchecked(c: *Connection, cmap: Colormap, red: u16, green: u16, blue: u16) AllocColorCookie { + return import.xcb_alloc_color_unchecked(c, cmap, red, green, blue); + } + + pub inline fn allocColorReply(c: *Connection, cookie: AllocColorCookie, e: ?*?*GenericError) ?*AllocColorReply { + return import.xcb_alloc_color_reply(c, cookie, e); + } + + pub inline fn allocNamedColor(c: *Connection, cmap: Colormap, name_len: u16, name: [*c]const u8) AllocNamedColorCookie { + return import.xcb_alloc_named_color(c, cmap, name_len, name); + } + + pub inline fn allocNamedColorUnchecked(c: *Connection, cmap: Colormap, name_len: u16, name: [*c]const u8) AllocNamedColorCookie { + return import.xcb_alloc_named_color_unchecked(c, cmap, name_len, name); + } + + pub inline fn allocNamedColorReply(c: *Connection, cookie: AllocNamedColorCookie, e: ?*?*GenericError) ?*AllocNamedColorReply { + return import.xcb_alloc_named_color_reply(c, cookie, e); + } + + pub inline fn allocColorCells(c: *Connection, contiguous: u8, cmap: Colormap, colors: u16, planes: u16) AllocColorCellsCookie { + return import.xcb_alloc_color_cells(c, contiguous, cmap, colors, planes); + } + + pub inline fn allocColorCellsUnchecked(c: *Connection, contiguous: u8, cmap: Colormap, colors: u16, planes: u16) AllocColorCellsCookie { + return import.xcb_alloc_color_cells_unchecked(c, contiguous, cmap, colors, planes); + } + + pub inline fn allocColorCellsReply(c: *Connection, cookie: AllocColorCellsCookie, e: ?*?*GenericError) ?*AllocColorCellsReply { + return import.xcb_alloc_color_cells_reply(c, cookie, e); + } + + pub inline fn allocColorPlanes(c: *Connection, contiguous: u8, cmap: Colormap, colors: u16, reds: u16, greens: u16, blues: u16) AllocColorPlanesCookie { + return import.xcb_alloc_color_planes(c, contiguous, cmap, colors, reds, greens, blues); + } + + pub inline fn allocColorPlanesUnchecked(c: *Connection, contiguous: u8, cmap: Colormap, colors: u16, reds: u16, greens: u16, blues: u16) AllocColorPlanesCookie { + return import.xcb_alloc_color_planes_unchecked(c, contiguous, cmap, colors, reds, greens, blues); + } + + pub inline fn allocColorPlanesReply(c: *Connection, cookie: AllocColorPlanesCookie, e: ?*?*GenericError) ?*AllocColorPlanesReply { + return import.xcb_alloc_color_planes_reply(c, cookie, e); + } + + pub inline fn freeColorsChecked(c: *Connection, cmap: Colormap, plane_mask: u32, pixels_len: u32, pixels: [*c]const u32) VoidCookie { + return import.xcb_free_colors_checked(c, cmap, plane_mask, pixels_len, pixels); + } + + pub inline fn freeColors(c: *Connection, cmap: Colormap, plane_mask: u32, pixels_len: u32, pixels: [*c]const u32) VoidCookie { + return import.xcb_free_colors(c, cmap, plane_mask, pixels_len, pixels); + } + + pub inline fn storeColorsChecked(c: *Connection, cmap: Colormap, items_len: u32, items: [*c]const Coloritem) VoidCookie { + return import.xcb_store_colors_checked(c, cmap, items_len, items); + } + + pub inline fn storeColors(c: *Connection, cmap: Colormap, items_len: u32, items: [*c]const Coloritem) VoidCookie { + return import.xcb_store_colors(c, cmap, items_len, items); + } + + pub inline fn storeNamedColorChecked(c: *Connection, flags: u8, cmap: Colormap, pixel: u32, name_len: u16, name: [*c]const u8) VoidCookie { + return import.xcb_store_named_color_checked(c, flags, cmap, pixel, name_len, name); + } + + pub inline fn storeNamedColor(c: *Connection, flags: u8, cmap: Colormap, pixel: u32, name_len: u16, name: [*c]const u8) VoidCookie { + return import.xcb_store_named_color(c, flags, cmap, pixel, name_len, name); + } + + pub inline fn queryColors(c: *Connection, cmap: Colormap, pixels_len: u32, pixels: [*c]const u32) QueryColorsCookie { + return import.xcb_query_colors(c, cmap, pixels_len, pixels); + } + + pub inline fn queryColorsUnchecked(c: *Connection, cmap: Colormap, pixels_len: u32, pixels: [*c]const u32) QueryColorsCookie { + return import.xcb_query_colors_unchecked(c, cmap, pixels_len, pixels); + } + + pub inline fn queryColorsReply(c: *Connection, cookie: QueryColorsCookie, e: ?*?*GenericError) ?*QueryColorsReply { + return import.xcb_query_colors_reply(c, cookie, e); + } + + pub inline fn lookupColor(c: *Connection, cmap: Colormap, name_len: u16, name: [*c]const u8) LookupColorCookie { + return import.xcb_lookup_color(c, cmap, name_len, name); + } + + pub inline fn lookupColorUnchecked(c: *Connection, cmap: Colormap, name_len: u16, name: [*c]const u8) LookupColorCookie { + return import.xcb_lookup_color_unchecked(c, cmap, name_len, name); + } + + pub inline fn lookupColorReply(c: *Connection, cookie: LookupColorCookie, e: ?*?*GenericError) ?*LookupColorReply { + return import.xcb_lookup_color_reply(c, cookie, e); + } + + pub inline fn createCursorChecked(c: *Connection, cid: Cursor, source: Pixmap, mask: Pixmap, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, x: u16, y: u16) VoidCookie { + return import.xcb_create_cursor_checked(c, cid, source, mask, fore_red, fore_green, fore_blue, back_red, back_green, back_blue, x, y); + } + + pub inline fn createCursor(c: *Connection, cid: Cursor, source: Pixmap, mask: Pixmap, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, x: u16, y: u16) VoidCookie { + return import.xcb_create_cursor(c, cid, source, mask, fore_red, fore_green, fore_blue, back_red, back_green, back_blue, x, y); + } + + pub inline fn createGlyphCursorChecked(c: *Connection, cid: Cursor, source_font: Font, mask_font: Font, source_char: u16, mask_char: u16, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) VoidCookie { + return import.xcb_create_glyph_cursor_checked(c, cid, source_font, mask_font, source_char, mask_char, fore_red, fore_green, fore_blue, back_red, back_green, back_blue); + } + + pub inline fn createGlyphCursor(c: *Connection, cid: Cursor, source_font: Font, mask_font: Font, source_char: u16, mask_char: u16, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) VoidCookie { + return import.xcb_create_glyph_cursor(c, cid, source_font, mask_font, source_char, mask_char, fore_red, fore_green, fore_blue, back_red, back_green, back_blue); + } + + pub inline fn freeCursorChecked(c: *Connection, cursor: Cursor) VoidCookie { + return import.xcb_free_cursor_checked(c, cursor); + } + + pub inline fn freeCursor(c: *Connection, cursor: Cursor) VoidCookie { + return import.xcb_free_cursor(c, cursor); + } + + pub inline fn recolorCursorChecked(c: *Connection, cursor: Cursor, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) VoidCookie { + return import.xcb_recolor_cursor_checked(c, cursor, fore_red, fore_green, fore_blue, back_red, back_green, back_blue); + } + + pub inline fn recolorCursor(c: *Connection, cursor: Cursor, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) VoidCookie { + return import.xcb_recolor_cursor(c, cursor, fore_red, fore_green, fore_blue, back_red, back_green, back_blue); + } + + pub inline fn queryBestSize(c: *Connection, _class: u8, drawable: Drawable, width: u16, height: u16) QueryBestSizeCookie { + return import.xcb_query_best_size(c, _class, drawable, width, height); + } + + pub inline fn queryBestSizeUnchecked(c: *Connection, _class: u8, drawable: Drawable, width: u16, height: u16) QueryBestSizeCookie { + return import.xcb_query_best_size_unchecked(c, _class, drawable, width, height); + } + + pub inline fn queryBestSizeReply(c: *Connection, cookie: QueryBestSizeCookie, e: ?*?*GenericError) ?*QueryBestSizeReply { + return import.xcb_query_best_size_reply(c, cookie, e); + } + + pub inline fn queryExtension(c: *Connection, name_len: u16, name: [*c]const u8) QueryExtensionCookie { + return import.xcb_query_extension(c, name_len, name); + } + + pub inline fn queryExtensionUnchecked(c: *Connection, name_len: u16, name: [*c]const u8) QueryExtensionCookie { + return import.xcb_query_extension_unchecked(c, name_len, name); + } + + pub inline fn queryExtensionReply(c: *Connection, cookie: QueryExtensionCookie, e: ?*?*GenericError) ?*QueryExtensionReply { + return import.xcb_query_extension_reply(c, cookie, e); + } + + pub inline fn listExtensions(c: *Connection) ListExtensionsCookie { + return import.xcb_list_extensions(c); + } + + pub inline fn listExtensionsUnchecked(c: *Connection) ListExtensionsCookie { + return import.xcb_list_extensions_unchecked(c); + } + + pub inline fn listExtensionsReply(c: *Connection, cookie: ListExtensionsCookie, e: ?*?*GenericError) ?*ListExtensionsReply { + return import.xcb_list_extensions_reply(c, cookie, e); + } + + pub inline fn changeKeyboardMappingChecked(c: *Connection, keycode_count: u8, first_keycode: Keycode, keysyms_per_keycode: u8, keysyms: [*c]const Keysym) VoidCookie { + return import.xcb_change_keyboard_mapping_checked(c, keycode_count, first_keycode, keysyms_per_keycode, keysyms); + } + + pub inline fn changeKeyboardMapping(c: *Connection, keycode_count: u8, first_keycode: Keycode, keysyms_per_keycode: u8, keysyms: [*c]const Keysym) VoidCookie { + return import.xcb_change_keyboard_mapping(c, keycode_count, first_keycode, keysyms_per_keycode, keysyms); + } + + pub inline fn getKeyboardMapping(c: *Connection, first_keycode: Keycode, count: u8) GetKeyboardMappingCookie { + return import.xcb_get_keyboard_mapping(c, first_keycode, count); + } + + pub inline fn getKeyboardMappingUnchecked(c: *Connection, first_keycode: Keycode, count: u8) GetKeyboardMappingCookie { + return import.xcb_get_keyboard_mapping_unchecked(c, first_keycode, count); + } + + pub inline fn getKeyboardMappingReply(c: *Connection, cookie: GetKeyboardMappingCookie, e: ?*?*GenericError) ?*GetKeyboardMappingReply { + return import.xcb_get_keyboard_mapping_reply(c, cookie, e); + } + + pub inline fn changeKeyboardControlChecked(c: *Connection, value_mask: u32, value_list: ?*const anyopaque) VoidCookie { + return import.xcb_change_keyboard_control_checked(c, value_mask, value_list); + } + + pub inline fn changeKeyboardControl(c: *Connection, value_mask: u32, value_list: ?*const anyopaque) VoidCookie { + return import.xcb_change_keyboard_control(c, value_mask, value_list); + } + + pub inline fn changeKeyboardControlAuxChecked(c: *Connection, value_mask: u32, value_list: [*c]const ChangeKeyboardControlValueList) VoidCookie { + return import.xcb_change_keyboard_control_aux_checked(c, value_mask, value_list); + } + + pub inline fn changeKeyboardControlAux(c: *Connection, value_mask: u32, value_list: [*c]const ChangeKeyboardControlValueList) VoidCookie { + return import.xcb_change_keyboard_control_aux(c, value_mask, value_list); + } + + pub inline fn getKeyboardControl(c: *Connection) GetKeyboardControlCookie { + return import.xcb_get_keyboard_control(c); + } + + pub inline fn getKeyboardControlUnchecked(c: *Connection) GetKeyboardControlCookie { + return import.xcb_get_keyboard_control_unchecked(c); + } + + pub inline fn getKeyboardControlReply(c: *Connection, cookie: GetKeyboardControlCookie, e: ?*?*GenericError) ?*GetKeyboardControlReply { + return import.xcb_get_keyboard_control_reply(c, cookie, e); + } + + pub inline fn bellChecked(c: *Connection, percent: i8) VoidCookie { + return import.xcb_bell_checked(c, percent); + } + + pub inline fn bell(c: *Connection, percent: i8) VoidCookie { + return import.xcb_bell(c, percent); + } + + pub inline fn changePointerControlChecked(c: *Connection, acceleration_numerator: i16, acceleration_denominator: i16, threshold: i16, do_acceleration: u8, do_threshold: u8) VoidCookie { + return import.xcb_change_pointer_control_checked(c, acceleration_numerator, acceleration_denominator, threshold, do_acceleration, do_threshold); + } + + pub inline fn changePointerControl(c: *Connection, acceleration_numerator: i16, acceleration_denominator: i16, threshold: i16, do_acceleration: u8, do_threshold: u8) VoidCookie { + return import.xcb_change_pointer_control(c, acceleration_numerator, acceleration_denominator, threshold, do_acceleration, do_threshold); + } + + pub inline fn getPointerControl(c: *Connection) GetPointerControlCookie { + return import.xcb_get_pointer_control(c); + } + + pub inline fn getPointerControlUnchecked(c: *Connection) GetPointerControlCookie { + return import.xcb_get_pointer_control_unchecked(c); + } + + pub inline fn getPointerControlReply(c: *Connection, cookie: GetPointerControlCookie, e: ?*?*GenericError) ?*GetPointerControlReply { + return import.xcb_get_pointer_control_reply(c, cookie, e); + } + + pub inline fn setScreenSaverChecked(c: *Connection, timeout: i16, interval: i16, prefer_blanking: u8, allow_exposures: u8) VoidCookie { + return import.xcb_set_screen_saver_checked(c, timeout, interval, prefer_blanking, allow_exposures); + } + + pub inline fn setScreenSaver(c: *Connection, timeout: i16, interval: i16, prefer_blanking: u8, allow_exposures: u8) VoidCookie { + return import.xcb_set_screen_saver(c, timeout, interval, prefer_blanking, allow_exposures); + } + + pub inline fn getScreenSaver(c: *Connection) GetScreenSaverCookie { + return import.xcb_get_screen_saver(c); + } + + pub inline fn getScreenSaverUnchecked(c: *Connection) GetScreenSaverCookie { + return import.xcb_get_screen_saver_unchecked(c); + } + + pub inline fn getScreenSaverReply(c: *Connection, cookie: GetScreenSaverCookie, e: ?*?*GenericError) ?*GetScreenSaverReply { + return import.xcb_get_screen_saver_reply(c, cookie, e); + } + + pub inline fn changeHostsChecked(c: *Connection, mode: u8, family: u8, address_len: u16, address: [*c]const u8) VoidCookie { + return import.xcb_change_hosts_checked(c, mode, family, address_len, address); + } + + pub inline fn changeHosts(c: *Connection, mode: u8, family: u8, address_len: u16, address: [*c]const u8) VoidCookie { + return import.xcb_change_hosts(c, mode, family, address_len, address); + } + + pub inline fn listHosts(c: *Connection) ListHostsCookie { + return import.xcb_list_hosts(c); + } + + pub inline fn listHostsUnchecked(c: *Connection) ListHostsCookie { + return import.xcb_list_hosts_unchecked(c); + } + + pub inline fn listHostsReply(c: *Connection, cookie: ListHostsCookie, e: ?*?*GenericError) ?*ListHostsReply { + return import.xcb_list_hosts_reply(c, cookie, e); + } + + pub inline fn setAccessControlChecked(c: *Connection, mode: u8) VoidCookie { + return import.xcb_set_access_control_checked(c, mode); + } + + pub inline fn setAccessControl(c: *Connection, mode: u8) VoidCookie { + return import.xcb_set_access_control(c, mode); + } + + pub inline fn setCloseDownModeChecked(c: *Connection, mode: u8) VoidCookie { + return import.xcb_set_close_down_mode_checked(c, mode); + } + + pub inline fn setCloseDownMode(c: *Connection, mode: u8) VoidCookie { + return import.xcb_set_close_down_mode(c, mode); + } + + pub inline fn killClientChecked(c: *Connection, resource: u32) VoidCookie { + return import.xcb_kill_client_checked(c, resource); + } + + pub inline fn killClient(c: *Connection, resource: u32) VoidCookie { + return import.xcb_kill_client(c, resource); + } + + pub inline fn rotatePropertiesChecked(c: *Connection, window: Window, atoms_len: u16, delta: i16, atoms: [*c]const Atom) VoidCookie { + return import.xcb_rotate_properties_checked(c, window, atoms_len, delta, atoms); + } + + pub inline fn rotateProperties(c: *Connection, window: Window, atoms_len: u16, delta: i16, atoms: [*c]const Atom) VoidCookie { + return import.xcb_rotate_properties(c, window, atoms_len, delta, atoms); + } + + pub inline fn forceScreenSaverChecked(c: *Connection, mode: u8) VoidCookie { + return import.xcb_force_screen_saver_checked(c, mode); + } + + pub inline fn forceScreenSaver(c: *Connection, mode: u8) VoidCookie { + return import.xcb_force_screen_saver(c, mode); + } + + pub inline fn setPointerMapping(c: *Connection, map_len: u8, map: [*c]const u8) SetPointerMappingCookie { + return import.xcb_set_pointer_mapping(c, map_len, map); + } + + pub inline fn setPointerMappingUnchecked(c: *Connection, map_len: u8, map: [*c]const u8) SetPointerMappingCookie { + return import.xcb_set_pointer_mapping_unchecked(c, map_len, map); + } + + pub inline fn setPointerMappingReply(c: *Connection, cookie: SetPointerMappingCookie, e: ?*?*GenericError) ?*SetPointerMappingReply { + return import.xcb_set_pointer_mapping_reply(c, cookie, e); + } + + pub inline fn getPointerMapping(c: *Connection) GetPointerMappingCookie { + return import.xcb_get_pointer_mapping(c); + } + + pub inline fn getPointerMappingUnchecked(c: *Connection) GetPointerMappingCookie { + return import.xcb_get_pointer_mapping_unchecked(c); + } + + pub inline fn getPointerMappingReply(c: *Connection, cookie: GetPointerMappingCookie, e: ?*?*GenericError) ?*GetPointerMappingReply { + return import.xcb_get_pointer_mapping_reply(c, cookie, e); + } + + pub inline fn setModifierMapping(c: *Connection, keycodes_per_modifier: u8, keycodes: [*c]const Keycode) SetModifierMappingCookie { + return import.xcb_set_modifier_mapping(c, keycodes_per_modifier, keycodes); + } + + pub inline fn setModifierMappingUnchecked(c: *Connection, keycodes_per_modifier: u8, keycodes: [*c]const Keycode) SetModifierMappingCookie { + return import.xcb_set_modifier_mapping_unchecked(c, keycodes_per_modifier, keycodes); + } + + pub inline fn setModifierMappingReply(c: *Connection, cookie: SetModifierMappingCookie, e: ?*?*GenericError) ?*SetModifierMappingReply { + return import.xcb_set_modifier_mapping_reply(c, cookie, e); + } + + pub inline fn getModifierMapping(c: *Connection) GetModifierMappingCookie { + return import.xcb_get_modifier_mapping(c); + } + + pub inline fn getModifierMappingUnchecked(c: *Connection) GetModifierMappingCookie { + return import.xcb_get_modifier_mapping_unchecked(c); + } + + pub inline fn getModifierMappingReply(c: *Connection, cookie: GetModifierMappingCookie, e: ?*?*GenericError) ?*GetModifierMappingReply { + return import.xcb_get_modifier_mapping_reply(c, cookie, e); + } + + pub inline fn noOperationChecked(c: *Connection) VoidCookie { + return import.xcb_no_operation_checked(c); + } + + pub inline fn noOperation(c: *Connection) VoidCookie { + return import.xcb_no_operation(c); + } + + pub inline fn flush(c: *Connection) c_int { + return import.xcb_flush(c); + } + + pub inline fn getMaximumRequestLength(c: *Connection) u32 { + return import.xcb_get_maximum_request_length(c); + } + + pub inline fn prefetchMaximumRequestLength(c: *Connection) void { + import.xcb_prefetch_maximum_request_length(c); + } + + pub inline fn waitForEvent(c: *Connection) ?*GenericEvent { + return import.xcb_wait_for_event(c); + } + + pub inline fn pollForEvent(c: *Connection) ?*GenericEvent { + return import.xcb_poll_for_event(c); + } + + pub inline fn pollForQueuedEvent(c: *Connection) ?*GenericEvent { + return import.xcb_poll_for_queued_event(c); + } + + pub inline fn pollForSpecialEvent(c: *Connection, se: ?*SpecialEvent) ?*GenericEvent { + return import.xcb_poll_for_special_event(c, se); + } + + pub inline fn waitForSpecialEvent(c: *Connection, se: ?*SpecialEvent) ?*GenericEvent { + return import.xcb_wait_for_special_event(c, se); + } + + pub inline fn registerForSpecialXge(c: *Connection, ext: ?*Extension, eid: u32, stamp: [*c]u32) ?*SpecialEvent { + return import.xcb_register_for_special_xge(c, ext, eid, stamp); + } + + pub inline fn unregisterForSpecialEvent(c: *Connection, se: ?*SpecialEvent) void { + import.xcb_unregister_for_special_event(c, se); + } + + pub inline fn requestCheck(c: *Connection, cookie: VoidCookie) [*c]GenericError { + return import.xcb_request_check(c, cookie); + } + + pub inline fn discardReply(c: *Connection, sequence: c_uint) void { + import.xcb_discard_reply(c, sequence); + } + + pub inline fn discardReply64(c: *Connection, sequence: u64) void { + import.xcb_discard_reply64(c, sequence); + } + + pub inline fn getExtensionData(c: *Connection, ext: ?*Extension) [*c]const QueryExtensionReply { + return import.xcb_get_extension_data(c, ext); + } + + pub inline fn prefetchExtensionData(c: *Connection, ext: ?*Extension) void { + import.xcb_prefetch_extension_data(c, ext); + } + + pub inline fn getSetup(c: *Connection) *const Setup { + return import.xcb_get_setup(c); + } + + pub inline fn getFileDescriptor(c: *Connection) c_int { + return import.xcb_get_file_descriptor(c); + } + + pub inline fn hasError(c: *Connection) c_int { + return import.xcb_connection_has_error(c); + } + + pub inline fn disconnect(c: *Connection) void { + import.xcb_disconnect(c); + } + + pub inline fn generateId(c: *Connection) u32 { + return import.xcb_generate_id(c); + } + + pub inline fn totalRead(c: *Connection) u64 { + return import.xcb_total_read(c); + } + + pub inline fn totalWritten(c: *Connection) u64 { + return import.xcb_total_written(c); + } }; pub const GenericIterator = extern struct { - data: ?*anyopaque = null, + data: *anyopaque = undefined, rem: c_int = 0, index: c_int = 0, }; @@ -378,7 +1336,7 @@ pub const Char2B = extern struct { }; pub const Char2BIterator = extern struct { - data: ?*Char2B = null, + data: *Char2B = undefined, rem: c_int = 0, index: c_int = 0, @@ -389,7 +1347,7 @@ pub const Char2BIterator = extern struct { pub const Window = enum(u32) { NONE = 0, _ }; pub const WindowIterator = extern struct { - data: ?*Window = null, + data: *Window = undefined, rem: c_int = 0, index: c_int = 0, @@ -400,7 +1358,7 @@ pub const WindowIterator = extern struct { pub const Pixmap = enum(u32) { NONE = 0, _ }; pub const PixmapIterator = extern struct { - data: ?*Pixmap = null, + data: *Pixmap = undefined, rem: c_int = 0, index: c_int = 0, @@ -411,7 +1369,7 @@ pub const PixmapIterator = extern struct { pub const Cursor = enum(u32) { NONE = 0, _ }; pub const CursorIterator = extern struct { - data: ?*Cursor = null, + data: *Cursor = undefined, rem: c_int = 0, index: c_int = 0, @@ -422,7 +1380,7 @@ pub const CursorIterator = extern struct { pub const Font = enum(u32) { NONE = 0, _ }; pub const FontIterator = extern struct { - data: ?*Font = null, + data: *Font = undefined, rem: c_int = 0, index: c_int = 0, @@ -433,7 +1391,7 @@ pub const FontIterator = extern struct { pub const Gcontext = enum(u32) { _ }; pub const GcontextIterator = extern struct { - data: ?*Gcontext = null, + data: *Gcontext = undefined, rem: c_int = 0, index: c_int = 0, @@ -444,7 +1402,7 @@ pub const GcontextIterator = extern struct { pub const Colormap = enum(u32) { NONE = 0, _ }; pub const ColormapIterator = extern struct { - data: ?*Colormap = null, + data: *Colormap = undefined, rem: c_int = 0, index: c_int = 0, @@ -528,7 +1486,7 @@ pub const Atom = enum(u32) { }; pub const AtomIterator = extern struct { - data: ?*Atom = null, + data: *Atom = undefined, rem: c_int = 0, index: c_int = 0, @@ -539,7 +1497,7 @@ pub const AtomIterator = extern struct { pub const Drawable = enum(u32) { _ }; pub const DrawableIterator = extern struct { - data: ?*Drawable = null, + data: *Drawable = undefined, rem: c_int = 0, index: c_int = 0, @@ -550,7 +1508,7 @@ pub const DrawableIterator = extern struct { pub const Fontable = enum(u32) { _ }; pub const FontableIterator = extern struct { - data: ?*Fontable = null, + data: *Fontable = undefined, rem: c_int = 0, index: c_int = 0, @@ -573,7 +1531,7 @@ pub const Bool32 = enum(u32) { }; pub const Bool32Iterator = extern struct { - data: ?*Bool32 = null, + data: *Bool32 = undefined, rem: c_int = 0, index: c_int = 0, @@ -584,7 +1542,7 @@ pub const Bool32Iterator = extern struct { pub const Visualid = enum(u32) { _ }; pub const VisualidIterator = extern struct { - data: ?*Visualid = null, + data: *Visualid = undefined, rem: c_int = 0, index: c_int = 0, @@ -595,7 +1553,7 @@ pub const VisualidIterator = extern struct { pub const Timestamp = enum(u32) { CURRENT_TIME = 0, _ }; pub const TimestampIterator = extern struct { - data: ?*Timestamp = null, + data: *Timestamp = undefined, rem: c_int = 0, index: c_int = 0, @@ -606,7 +1564,7 @@ pub const TimestampIterator = extern struct { pub const Keysym = enum(u32) { _ }; pub const KeysymIterator = extern struct { - data: ?*Keysym = null, + data: *Keysym = undefined, rem: c_int = 0, index: c_int = 0, @@ -617,7 +1575,7 @@ pub const KeysymIterator = extern struct { pub const Keycode = enum(u8) { ANY = 0, _ }; pub const KeycodeIterator = extern struct { - data: ?*Keycode = null, + data: *Keycode = undefined, rem: c_int = 0, index: c_int = 0, @@ -628,7 +1586,7 @@ pub const KeycodeIterator = extern struct { pub const Keycode32 = enum(u32) { _ }; pub const Keycode32Iterator = extern struct { - data: ?*Keycode32 = null, + data: *Keycode32 = undefined, rem: c_int = 0, index: c_int = 0, @@ -639,7 +1597,7 @@ pub const Keycode32Iterator = extern struct { pub const Button = enum(u8) { _ }; pub const ButtonIterator = extern struct { - data: ?*Button = null, + data: *Button = undefined, rem: c_int = 0, index: c_int = 0, @@ -653,7 +1611,7 @@ pub const Point = extern struct { }; pub const PointIterator = extern struct { - data: ?*Point = null, + data: *Point = undefined, rem: c_int = 0, index: c_int = 0, @@ -669,7 +1627,7 @@ pub const Rectangle = extern struct { }; pub const RectangleIterator = extern struct { - data: ?*Rectangle = null, + data: *Rectangle = undefined, rem: c_int = 0, index: c_int = 0, @@ -687,7 +1645,7 @@ pub const Arc = extern struct { }; pub const ArcIterator = extern struct { - data: ?*Arc = null, + data: *Arc = undefined, rem: c_int = 0, index: c_int = 0, @@ -703,7 +1661,7 @@ pub const Format = extern struct { }; pub const FormatIterator = extern struct { - data: ?*Format = null, + data: *Format = undefined, rem: c_int = 0, index: c_int = 0, @@ -733,7 +1691,7 @@ pub const Visualtype = extern struct { }; pub const VisualtypeIterator = extern struct { - data: ?*Visualtype = null, + data: *Visualtype = undefined, rem: c_int = 0, index: c_int = 0, @@ -753,7 +1711,7 @@ pub const Depth = extern struct { }; pub const DepthIterator = extern struct { - data: ?*Depth = null, + data: *Depth = undefined, rem: c_int = 0, index: c_int = 0, @@ -820,7 +1778,7 @@ pub const Screen = extern struct { }; pub const ScreenIterator = extern struct { - data: ?*Screen = null, + data: *Screen = undefined, rem: c_int = 0, index: c_int = 0, @@ -846,7 +1804,7 @@ pub const SetupRequest = extern struct { }; pub const SetupRequestIterator = extern struct { - data: ?*SetupRequest = null, + data: *SetupRequest = undefined, rem: c_int = 0, index: c_int = 0, @@ -867,7 +1825,7 @@ pub const SetupFailed = extern struct { }; pub const SetupFailedIterator = extern struct { - data: ?*SetupFailed = null, + data: *SetupFailed = undefined, rem: c_int = 0, index: c_int = 0, @@ -886,7 +1844,7 @@ pub const SetupAuthenticate = extern struct { }; pub const SetupAuthenticateIterator = extern struct { - data: ?*SetupAuthenticate = null, + data: *SetupAuthenticate = undefined, rem: c_int = 0, index: c_int = 0, @@ -933,7 +1891,7 @@ pub const Setup = extern struct { }; pub const SetupIterator = extern struct { - data: ?*Setup = null, + data: *Setup = undefined, rem: c_int = 0, index: c_int = 0, @@ -1360,7 +2318,7 @@ pub const ClientMessageData = extern union { }; pub const ClientMessageDataIterator = extern struct { - data: ?*ClientMessageData = null, + data: *ClientMessageData = undefined, rem: c_int = 0, index: c_int = 0, @@ -1440,14 +2398,14 @@ pub const NameError = RequestError; pub const LengthError = RequestError; pub const ImplementationError = RequestError; -pub const WindowClass = enum(c_uint) { +pub const WindowClass = enum(u16) { COPY_FROM_PARENT = 0, INPUT_OUTPUT = 1, INPUT_ONLY = 2, _, }; -pub const Cw = packed struct(c_uint) { +pub const Cw = packed struct(u32) { BACK_PIXMAP: bool = false, BACK_PIXEL: bool = false, BORDER_PIXMAP: bool = false, @@ -1518,9 +2476,9 @@ pub const CreateWindowRequest = extern struct { width: u16 = 0, height: u16 = 0, border_width: u16 = 0, - _class: u16 = 0, + _class: WindowClass = 0, visual: Visualid = @enumFromInt(0), - value_mask: u32 = 0, + value_mask: Cw = .{}, pub const valueList = import.xcb_create_window_value_list; }; @@ -1577,7 +2535,7 @@ pub const GetWindowAttributesReply = extern struct { sequence: u16 = 0, length: u32 = 0, visual: Visualid = @enumFromInt(0), - _class: u16 = 0, + _class: WindowClass = 0, bit_gravity: u8 = 0, win_gravity: u8 = 0, backing_planes: u32 = 0, @@ -1807,7 +2765,7 @@ pub const GetAtomNameReply = extern struct { pub const nameEnd = import.xcb_get_atom_name_name_end; }; -pub const PropMode = enum(c_uint) { +pub const PropMode = enum(u8) { REPLACE = 0, PREPEND = 1, APPEND = 2, @@ -1816,7 +2774,7 @@ pub const PropMode = enum(c_uint) { pub const ChangePropertyRequest = extern struct { major_opcode: u8 = 0, - mode: u8 = 0, + mode: PropMode = .REPLACE, length: u16 = 0, window: Window = .NONE, property: Atom = .NONE, @@ -2150,7 +3108,7 @@ pub const Timecoord = extern struct { }; pub const TimecoordIterator = extern struct { - data: ?*Timecoord = null, + data: *Timecoord = undefined, rem: c_int = 0, index: c_int = 0, @@ -2306,7 +3264,7 @@ pub const Fontprop = extern struct { }; pub const FontpropIterator = extern struct { - data: ?*Fontprop = null, + data: *Fontprop = undefined, rem: c_int = 0, index: c_int = 0, @@ -2324,7 +3282,7 @@ pub const Charinfo = extern struct { }; pub const CharinfoIterator = extern struct { - data: ?*Charinfo = null, + data: *Charinfo = undefined, rem: c_int = 0, index: c_int = 0, @@ -2406,7 +3364,7 @@ pub const Str = extern struct { }; pub const StrIterator = extern struct { - data: ?*Str = null, + data: *Str = undefined, rem: c_int = 0, index: c_int = 0, @@ -2827,7 +3785,7 @@ pub const Segment = extern struct { }; pub const SegmentIterator = extern struct { - data: ?*Segment = null, + data: *Segment = undefined, rem: c_int = 0, index: c_int = 0, @@ -3241,7 +4199,7 @@ pub const Coloritem = extern struct { }; pub const ColoritemIterator = extern struct { - data: ?*Coloritem = null, + data: *Coloritem = undefined, rem: c_int = 0, index: c_int = 0, @@ -3282,7 +4240,7 @@ pub const Rgb = extern struct { }; pub const RgbIterator = extern struct { - data: ?*Rgb = null, + data: *Rgb = undefined, rem: c_int = 0, index: c_int = 0, @@ -3696,7 +4654,7 @@ pub const Host = extern struct { }; pub const HostIterator = extern struct { - data: ?*Host = null, + data: *Host = undefined, rem: c_int = 0, index: c_int = 0, @@ -4183,179 +5141,179 @@ pub const import = struct { pub extern fn xcb_create_window_value_list_unpack(_buffer: ?*const anyopaque, value_mask: u32, _aux: [*c]CreateWindowValueList) c_int; pub extern fn xcb_create_window_value_list_sizeof(_buffer: ?*const anyopaque, value_mask: u32) c_int; pub extern fn xcb_create_window_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_create_window_checked(c: ?*Connection, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, _class: u16, visual: Visualid, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; - pub extern fn xcb_create_window(c: ?*Connection, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, _class: u16, visual: Visualid, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; - pub extern fn xcb_create_window_aux_checked(c: ?*Connection, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, _class: u16, visual: Visualid, value_mask: u32, value_list: [*c]const CreateWindowValueList) VoidCookie; - pub extern fn xcb_create_window_aux(c: ?*Connection, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, _class: u16, visual: Visualid, value_mask: u32, value_list: [*c]const CreateWindowValueList) VoidCookie; + pub extern fn xcb_create_window_checked(c: *Connection, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, _class: WindowClass, visual: Visualid, value_mask: Cw, value_list: ?*const anyopaque) VoidCookie; + pub extern fn xcb_create_window(c: *Connection, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, _class: WindowClass, visual: Visualid, value_mask: Cw, value_list: ?*const anyopaque) VoidCookie; + pub extern fn xcb_create_window_aux_checked(c: *Connection, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, _class: WindowClass, visual: Visualid, value_mask: Cw, value_list: *const CreateWindowValueList) VoidCookie; + pub extern fn xcb_create_window_aux(c: *Connection, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, _class: WindowClass, visual: Visualid, value_mask: Cw, value_list: *const CreateWindowValueList) VoidCookie; pub extern fn xcb_create_window_value_list(R: *const CreateWindowRequest) ?*anyopaque; pub extern fn xcb_change_window_attributes_value_list_serialize(_buffer: [*c]?*anyopaque, value_mask: u32, _aux: [*c]const ChangeWindowAttributesValueList) c_int; pub extern fn xcb_change_window_attributes_value_list_unpack(_buffer: ?*const anyopaque, value_mask: u32, _aux: [*c]ChangeWindowAttributesValueList) c_int; pub extern fn xcb_change_window_attributes_value_list_sizeof(_buffer: ?*const anyopaque, value_mask: u32) c_int; pub extern fn xcb_change_window_attributes_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_change_window_attributes_checked(c: ?*Connection, window: Window, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; - pub extern fn xcb_change_window_attributes(c: ?*Connection, window: Window, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; - pub extern fn xcb_change_window_attributes_aux_checked(c: ?*Connection, window: Window, value_mask: u32, value_list: [*c]const ChangeWindowAttributesValueList) VoidCookie; - pub extern fn xcb_change_window_attributes_aux(c: ?*Connection, window: Window, value_mask: u32, value_list: [*c]const ChangeWindowAttributesValueList) VoidCookie; + pub extern fn xcb_change_window_attributes_checked(c: *Connection, window: Window, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; + pub extern fn xcb_change_window_attributes(c: *Connection, window: Window, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; + pub extern fn xcb_change_window_attributes_aux_checked(c: *Connection, window: Window, value_mask: u32, value_list: [*c]const ChangeWindowAttributesValueList) VoidCookie; + pub extern fn xcb_change_window_attributes_aux(c: *Connection, window: Window, value_mask: u32, value_list: [*c]const ChangeWindowAttributesValueList) VoidCookie; pub extern fn xcb_change_window_attributes_value_list(R: *const ChangeWindowAttributesRequest) ?*anyopaque; - pub extern fn xcb_get_window_attributes(c: ?*Connection, window: Window) GetWindowAttributesCookie; - pub extern fn xcb_get_window_attributes_unchecked(c: ?*Connection, window: Window) GetWindowAttributesCookie; - pub extern fn xcb_get_window_attributes_reply(c: ?*Connection, cookie: GetWindowAttributesCookie, e: [*c][*c]GenericError) [*c]GetWindowAttributesReply; - pub extern fn xcb_destroy_window_checked(c: ?*Connection, window: Window) VoidCookie; - pub extern fn xcb_destroy_window(c: ?*Connection, window: Window) VoidCookie; - pub extern fn xcb_destroy_subwindows_checked(c: ?*Connection, window: Window) VoidCookie; - pub extern fn xcb_destroy_subwindows(c: ?*Connection, window: Window) VoidCookie; - pub extern fn xcb_change_save_set_checked(c: ?*Connection, mode: u8, window: Window) VoidCookie; - pub extern fn xcb_change_save_set(c: ?*Connection, mode: u8, window: Window) VoidCookie; - pub extern fn xcb_reparent_window_checked(c: ?*Connection, window: Window, parent: Window, x: i16, y: i16) VoidCookie; - pub extern fn xcb_reparent_window(c: ?*Connection, window: Window, parent: Window, x: i16, y: i16) VoidCookie; - pub extern fn xcb_map_window_checked(c: ?*Connection, window: Window) VoidCookie; - pub extern fn xcb_map_window(c: ?*Connection, window: Window) VoidCookie; - pub extern fn xcb_map_subwindows_checked(c: ?*Connection, window: Window) VoidCookie; - pub extern fn xcb_map_subwindows(c: ?*Connection, window: Window) VoidCookie; - pub extern fn xcb_unmap_window_checked(c: ?*Connection, window: Window) VoidCookie; - pub extern fn xcb_unmap_window(c: ?*Connection, window: Window) VoidCookie; - pub extern fn xcb_unmap_subwindows_checked(c: ?*Connection, window: Window) VoidCookie; - pub extern fn xcb_unmap_subwindows(c: ?*Connection, window: Window) VoidCookie; + pub extern fn xcb_get_window_attributes(c: *Connection, window: Window) GetWindowAttributesCookie; + pub extern fn xcb_get_window_attributes_unchecked(c: *Connection, window: Window) GetWindowAttributesCookie; + pub extern fn xcb_get_window_attributes_reply(c: *Connection, cookie: GetWindowAttributesCookie, e: ?*?*GenericError) ?*GetWindowAttributesReply; + pub extern fn xcb_destroy_window_checked(c: *Connection, window: Window) VoidCookie; + pub extern fn xcb_destroy_window(c: *Connection, window: Window) VoidCookie; + pub extern fn xcb_destroy_subwindows_checked(c: *Connection, window: Window) VoidCookie; + pub extern fn xcb_destroy_subwindows(c: *Connection, window: Window) VoidCookie; + pub extern fn xcb_change_save_set_checked(c: *Connection, mode: u8, window: Window) VoidCookie; + pub extern fn xcb_change_save_set(c: *Connection, mode: u8, window: Window) VoidCookie; + pub extern fn xcb_reparent_window_checked(c: *Connection, window: Window, parent: Window, x: i16, y: i16) VoidCookie; + pub extern fn xcb_reparent_window(c: *Connection, window: Window, parent: Window, x: i16, y: i16) VoidCookie; + pub extern fn xcb_map_window_checked(c: *Connection, window: Window) VoidCookie; + pub extern fn xcb_map_window(c: *Connection, window: Window) VoidCookie; + pub extern fn xcb_map_subwindows_checked(c: *Connection, window: Window) VoidCookie; + pub extern fn xcb_map_subwindows(c: *Connection, window: Window) VoidCookie; + pub extern fn xcb_unmap_window_checked(c: *Connection, window: Window) VoidCookie; + pub extern fn xcb_unmap_window(c: *Connection, window: Window) VoidCookie; + pub extern fn xcb_unmap_subwindows_checked(c: *Connection, window: Window) VoidCookie; + pub extern fn xcb_unmap_subwindows(c: *Connection, window: Window) VoidCookie; pub extern fn xcb_configure_window_value_list_serialize(_buffer: [*c]?*anyopaque, value_mask: u16, _aux: [*c]const ConfigureWindowValueList) c_int; pub extern fn xcb_configure_window_value_list_unpack(_buffer: ?*const anyopaque, value_mask: u16, _aux: [*c]ConfigureWindowValueList) c_int; pub extern fn xcb_configure_window_value_list_sizeof(_buffer: ?*const anyopaque, value_mask: u16) c_int; pub extern fn xcb_configure_window_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_configure_window_checked(c: ?*Connection, window: Window, value_mask: u16, value_list: ?*const anyopaque) VoidCookie; - pub extern fn xcb_configure_window(c: ?*Connection, window: Window, value_mask: u16, value_list: ?*const anyopaque) VoidCookie; - pub extern fn xcb_configure_window_aux_checked(c: ?*Connection, window: Window, value_mask: u16, value_list: [*c]const ConfigureWindowValueList) VoidCookie; - pub extern fn xcb_configure_window_aux(c: ?*Connection, window: Window, value_mask: u16, value_list: [*c]const ConfigureWindowValueList) VoidCookie; + pub extern fn xcb_configure_window_checked(c: *Connection, window: Window, value_mask: u16, value_list: ?*const anyopaque) VoidCookie; + pub extern fn xcb_configure_window(c: *Connection, window: Window, value_mask: u16, value_list: ?*const anyopaque) VoidCookie; + pub extern fn xcb_configure_window_aux_checked(c: *Connection, window: Window, value_mask: u16, value_list: [*c]const ConfigureWindowValueList) VoidCookie; + pub extern fn xcb_configure_window_aux(c: *Connection, window: Window, value_mask: u16, value_list: [*c]const ConfigureWindowValueList) VoidCookie; pub extern fn xcb_configure_window_value_list(R: *const ConfigureWindowRequest) ?*anyopaque; - pub extern fn xcb_circulate_window_checked(c: ?*Connection, direction: u8, window: Window) VoidCookie; - pub extern fn xcb_circulate_window(c: ?*Connection, direction: u8, window: Window) VoidCookie; - pub extern fn xcb_get_geometry(c: ?*Connection, drawable: Drawable) GetGeometryCookie; - pub extern fn xcb_get_geometry_unchecked(c: ?*Connection, drawable: Drawable) GetGeometryCookie; - pub extern fn xcb_get_geometry_reply(c: ?*Connection, cookie: GetGeometryCookie, e: [*c][*c]GenericError) [*c]GetGeometryReply; + pub extern fn xcb_circulate_window_checked(c: *Connection, direction: u8, window: Window) VoidCookie; + pub extern fn xcb_circulate_window(c: *Connection, direction: u8, window: Window) VoidCookie; + pub extern fn xcb_get_geometry(c: *Connection, drawable: Drawable) GetGeometryCookie; + pub extern fn xcb_get_geometry_unchecked(c: *Connection, drawable: Drawable) GetGeometryCookie; + pub extern fn xcb_get_geometry_reply(c: *Connection, cookie: GetGeometryCookie, e: ?*?*GenericError) ?*GetGeometryReply; pub extern fn xcb_query_tree_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_query_tree(c: ?*Connection, window: Window) QueryTreeCookie; - pub extern fn xcb_query_tree_unchecked(c: ?*Connection, window: Window) QueryTreeCookie; + pub extern fn xcb_query_tree(c: *Connection, window: Window) QueryTreeCookie; + pub extern fn xcb_query_tree_unchecked(c: *Connection, window: Window) QueryTreeCookie; pub extern fn xcb_query_tree_children(R: *const QueryTreeReply) [*c]Window; pub extern fn xcb_query_tree_children_length(R: *const QueryTreeReply) c_int; pub extern fn xcb_query_tree_children_end(R: *const QueryTreeReply) GenericIterator; - pub extern fn xcb_query_tree_reply(c: ?*Connection, cookie: QueryTreeCookie, e: [*c][*c]GenericError) [*c]QueryTreeReply; + pub extern fn xcb_query_tree_reply(c: *Connection, cookie: QueryTreeCookie, e: ?*?*GenericError) ?*QueryTreeReply; pub extern fn xcb_intern_atom_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_intern_atom(c: ?*Connection, only_if_exists: u8, name_len: u16, name: [*c]const u8) InternAtomCookie; - pub extern fn xcb_intern_atom_unchecked(c: ?*Connection, only_if_exists: u8, name_len: u16, name: [*c]const u8) InternAtomCookie; - pub extern fn xcb_intern_atom_reply(c: ?*Connection, cookie: InternAtomCookie, e: [*c][*c]GenericError) [*c]InternAtomReply; + pub extern fn xcb_intern_atom(c: *Connection, only_if_exists: u8, name_len: u16, name: [*]const u8) InternAtomCookie; + pub extern fn xcb_intern_atom_unchecked(c: *Connection, only_if_exists: u8, name_len: u16, name: [*]const u8) InternAtomCookie; + pub extern fn xcb_intern_atom_reply(c: *Connection, cookie: InternAtomCookie, e: ?*?*GenericError) ?*InternAtomReply; pub extern fn xcb_get_atom_name_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_get_atom_name(c: ?*Connection, atom: Atom) GetAtomNameCookie; - pub extern fn xcb_get_atom_name_unchecked(c: ?*Connection, atom: Atom) GetAtomNameCookie; + pub extern fn xcb_get_atom_name(c: *Connection, atom: Atom) GetAtomNameCookie; + pub extern fn xcb_get_atom_name_unchecked(c: *Connection, atom: Atom) GetAtomNameCookie; pub extern fn xcb_get_atom_name_name(R: *const GetAtomNameReply) [*c]u8; pub extern fn xcb_get_atom_name_name_length(R: *const GetAtomNameReply) c_int; pub extern fn xcb_get_atom_name_name_end(R: *const GetAtomNameReply) GenericIterator; - pub extern fn xcb_get_atom_name_reply(c: ?*Connection, cookie: GetAtomNameCookie, e: [*c][*c]GenericError) [*c]GetAtomNameReply; + pub extern fn xcb_get_atom_name_reply(c: *Connection, cookie: GetAtomNameCookie, e: ?*?*GenericError) ?*GetAtomNameReply; pub extern fn xcb_change_property_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_change_property_checked(c: ?*Connection, mode: u8, window: Window, property: Atom, @"type": Atom, format: u8, data_len: u32, data: ?*const anyopaque) VoidCookie; - pub extern fn xcb_change_property(c: ?*Connection, mode: u8, window: Window, property: Atom, @"type": Atom, format: u8, data_len: u32, data: ?*const anyopaque) VoidCookie; + pub extern fn xcb_change_property_checked(c: *Connection, mode: PropMode, window: Window, property: Atom, @"type": Atom, format: u8, data_len: u32, data: ?*const anyopaque) VoidCookie; + pub extern fn xcb_change_property(c: *Connection, mode: PropMode, window: Window, property: Atom, @"type": Atom, format: u8, data_len: u32, data: ?*const anyopaque) VoidCookie; pub extern fn xcb_change_property_data(R: *const ChangePropertyRequest) ?*anyopaque; pub extern fn xcb_change_property_data_length(R: *const ChangePropertyRequest) c_int; pub extern fn xcb_change_property_data_end(R: *const ChangePropertyRequest) GenericIterator; - pub extern fn xcb_delete_property_checked(c: ?*Connection, window: Window, property: Atom) VoidCookie; - pub extern fn xcb_delete_property(c: ?*Connection, window: Window, property: Atom) VoidCookie; + pub extern fn xcb_delete_property_checked(c: *Connection, window: Window, property: Atom) VoidCookie; + pub extern fn xcb_delete_property(c: *Connection, window: Window, property: Atom) VoidCookie; pub extern fn xcb_get_property_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_get_property(c: ?*Connection, _delete: u8, window: Window, property: Atom, @"type": Atom, long_offset: u32, long_length: u32) GetPropertyCookie; - pub extern fn xcb_get_property_unchecked(c: ?*Connection, _delete: u8, window: Window, property: Atom, @"type": Atom, long_offset: u32, long_length: u32) GetPropertyCookie; + pub extern fn xcb_get_property(c: *Connection, _delete: u8, window: Window, property: Atom, @"type": Atom, long_offset: u32, long_length: u32) GetPropertyCookie; + pub extern fn xcb_get_property_unchecked(c: *Connection, _delete: u8, window: Window, property: Atom, @"type": Atom, long_offset: u32, long_length: u32) GetPropertyCookie; pub extern fn xcb_get_property_value(R: *const GetPropertyReply) ?*anyopaque; pub extern fn xcb_get_property_value_length(R: *const GetPropertyReply) c_int; pub extern fn xcb_get_property_value_end(R: *const GetPropertyReply) GenericIterator; - pub extern fn xcb_get_property_reply(c: ?*Connection, cookie: GetPropertyCookie, e: [*c][*c]GenericError) [*c]GetPropertyReply; + pub extern fn xcb_get_property_reply(c: *Connection, cookie: GetPropertyCookie, e: ?*?*GenericError) ?*GetPropertyReply; pub extern fn xcb_list_properties_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_list_properties(c: ?*Connection, window: Window) ListPropertiesCookie; - pub extern fn xcb_list_properties_unchecked(c: ?*Connection, window: Window) ListPropertiesCookie; + pub extern fn xcb_list_properties(c: *Connection, window: Window) ListPropertiesCookie; + pub extern fn xcb_list_properties_unchecked(c: *Connection, window: Window) ListPropertiesCookie; pub extern fn xcb_list_properties_atoms(R: *const ListPropertiesReply) [*c]Atom; pub extern fn xcb_list_properties_atoms_length(R: *const ListPropertiesReply) c_int; pub extern fn xcb_list_properties_atoms_end(R: *const ListPropertiesReply) GenericIterator; - pub extern fn xcb_list_properties_reply(c: ?*Connection, cookie: ListPropertiesCookie, e: [*c][*c]GenericError) [*c]ListPropertiesReply; - pub extern fn xcb_set_selection_owner_checked(c: ?*Connection, owner: Window, selection: Atom, time: Timestamp) VoidCookie; - pub extern fn xcb_set_selection_owner(c: ?*Connection, owner: Window, selection: Atom, time: Timestamp) VoidCookie; - pub extern fn xcb_get_selection_owner(c: ?*Connection, selection: Atom) GetSelectionOwnerCookie; - pub extern fn xcb_get_selection_owner_unchecked(c: ?*Connection, selection: Atom) GetSelectionOwnerCookie; - pub extern fn xcb_get_selection_owner_reply(c: ?*Connection, cookie: GetSelectionOwnerCookie, e: [*c][*c]GenericError) [*c]GetSelectionOwnerReply; - pub extern fn xcb_convert_selection_checked(c: ?*Connection, requestor: Window, selection: Atom, target: Atom, property: Atom, time: Timestamp) VoidCookie; - pub extern fn xcb_convert_selection(c: ?*Connection, requestor: Window, selection: Atom, target: Atom, property: Atom, time: Timestamp) VoidCookie; - pub extern fn xcb_send_event_checked(c: ?*Connection, propagate: u8, destination: Window, event_mask: u32, event: [*c]const u8) VoidCookie; - pub extern fn xcb_send_event(c: ?*Connection, propagate: u8, destination: Window, event_mask: u32, event: [*c]const u8) VoidCookie; - pub extern fn xcb_grab_pointer(c: ?*Connection, owner_events: u8, grab_window: Window, event_mask: u16, pointer_mode: u8, keyboard_mode: u8, confine_to: Window, cursor: Cursor, time: Timestamp) GrabPointerCookie; - pub extern fn xcb_grab_pointer_unchecked(c: ?*Connection, owner_events: u8, grab_window: Window, event_mask: u16, pointer_mode: u8, keyboard_mode: u8, confine_to: Window, cursor: Cursor, time: Timestamp) GrabPointerCookie; - pub extern fn xcb_grab_pointer_reply(c: ?*Connection, cookie: GrabPointerCookie, e: [*c][*c]GenericError) [*c]GrabPointerReply; - pub extern fn xcb_ungrab_pointer_checked(c: ?*Connection, time: Timestamp) VoidCookie; - pub extern fn xcb_ungrab_pointer(c: ?*Connection, time: Timestamp) VoidCookie; - pub extern fn xcb_grab_button_checked(c: ?*Connection, owner_events: u8, grab_window: Window, event_mask: u16, pointer_mode: u8, keyboard_mode: u8, confine_to: Window, cursor: Cursor, button: u8, modifiers: u16) VoidCookie; - pub extern fn xcb_grab_button(c: ?*Connection, owner_events: u8, grab_window: Window, event_mask: u16, pointer_mode: u8, keyboard_mode: u8, confine_to: Window, cursor: Cursor, button: u8, modifiers: u16) VoidCookie; - pub extern fn xcb_ungrab_button_checked(c: ?*Connection, button: u8, grab_window: Window, modifiers: u16) VoidCookie; - pub extern fn xcb_ungrab_button(c: ?*Connection, button: u8, grab_window: Window, modifiers: u16) VoidCookie; - pub extern fn xcb_change_active_pointer_grab_checked(c: ?*Connection, cursor: Cursor, time: Timestamp, event_mask: u16) VoidCookie; - pub extern fn xcb_change_active_pointer_grab(c: ?*Connection, cursor: Cursor, time: Timestamp, event_mask: u16) VoidCookie; - pub extern fn xcb_grab_keyboard(c: ?*Connection, owner_events: u8, grab_window: Window, time: Timestamp, pointer_mode: u8, keyboard_mode: u8) GrabKeyboardCookie; - pub extern fn xcb_grab_keyboard_unchecked(c: ?*Connection, owner_events: u8, grab_window: Window, time: Timestamp, pointer_mode: u8, keyboard_mode: u8) GrabKeyboardCookie; - pub extern fn xcb_grab_keyboard_reply(c: ?*Connection, cookie: GrabKeyboardCookie, e: [*c][*c]GenericError) [*c]GrabKeyboardReply; - pub extern fn xcb_ungrab_keyboard_checked(c: ?*Connection, time: Timestamp) VoidCookie; - pub extern fn xcb_ungrab_keyboard(c: ?*Connection, time: Timestamp) VoidCookie; - pub extern fn xcb_grab_key_checked(c: ?*Connection, owner_events: u8, grab_window: Window, modifiers: u16, key: Keycode, pointer_mode: u8, keyboard_mode: u8) VoidCookie; - pub extern fn xcb_grab_key(c: ?*Connection, owner_events: u8, grab_window: Window, modifiers: u16, key: Keycode, pointer_mode: u8, keyboard_mode: u8) VoidCookie; - pub extern fn xcb_ungrab_key_checked(c: ?*Connection, key: Keycode, grab_window: Window, modifiers: u16) VoidCookie; - pub extern fn xcb_ungrab_key(c: ?*Connection, key: Keycode, grab_window: Window, modifiers: u16) VoidCookie; - pub extern fn xcb_allow_events_checked(c: ?*Connection, mode: u8, time: Timestamp) VoidCookie; - pub extern fn xcb_allow_events(c: ?*Connection, mode: u8, time: Timestamp) VoidCookie; - pub extern fn xcb_grab_server_checked(c: ?*Connection) VoidCookie; - pub extern fn xcb_grab_server(c: ?*Connection) VoidCookie; - pub extern fn xcb_ungrab_server_checked(c: ?*Connection) VoidCookie; - pub extern fn xcb_ungrab_server(c: ?*Connection) VoidCookie; - pub extern fn xcb_query_pointer(c: ?*Connection, window: Window) QueryPointerCookie; - pub extern fn xcb_query_pointer_unchecked(c: ?*Connection, window: Window) QueryPointerCookie; - pub extern fn xcb_query_pointer_reply(c: ?*Connection, cookie: QueryPointerCookie, e: [*c][*c]GenericError) [*c]QueryPointerReply; + pub extern fn xcb_list_properties_reply(c: *Connection, cookie: ListPropertiesCookie, e: ?*?*GenericError) ?*ListPropertiesReply; + pub extern fn xcb_set_selection_owner_checked(c: *Connection, owner: Window, selection: Atom, time: Timestamp) VoidCookie; + pub extern fn xcb_set_selection_owner(c: *Connection, owner: Window, selection: Atom, time: Timestamp) VoidCookie; + pub extern fn xcb_get_selection_owner(c: *Connection, selection: Atom) GetSelectionOwnerCookie; + pub extern fn xcb_get_selection_owner_unchecked(c: *Connection, selection: Atom) GetSelectionOwnerCookie; + pub extern fn xcb_get_selection_owner_reply(c: *Connection, cookie: GetSelectionOwnerCookie, e: ?*?*GenericError) ?*GetSelectionOwnerReply; + pub extern fn xcb_convert_selection_checked(c: *Connection, requestor: Window, selection: Atom, target: Atom, property: Atom, time: Timestamp) VoidCookie; + pub extern fn xcb_convert_selection(c: *Connection, requestor: Window, selection: Atom, target: Atom, property: Atom, time: Timestamp) VoidCookie; + pub extern fn xcb_send_event_checked(c: *Connection, propagate: u8, destination: Window, event_mask: u32, event: [*c]const u8) VoidCookie; + pub extern fn xcb_send_event(c: *Connection, propagate: u8, destination: Window, event_mask: u32, event: [*c]const u8) VoidCookie; + pub extern fn xcb_grab_pointer(c: *Connection, owner_events: u8, grab_window: Window, event_mask: u16, pointer_mode: u8, keyboard_mode: u8, confine_to: Window, cursor: Cursor, time: Timestamp) GrabPointerCookie; + pub extern fn xcb_grab_pointer_unchecked(c: *Connection, owner_events: u8, grab_window: Window, event_mask: u16, pointer_mode: u8, keyboard_mode: u8, confine_to: Window, cursor: Cursor, time: Timestamp) GrabPointerCookie; + pub extern fn xcb_grab_pointer_reply(c: *Connection, cookie: GrabPointerCookie, e: ?*?*GenericError) ?*GrabPointerReply; + pub extern fn xcb_ungrab_pointer_checked(c: *Connection, time: Timestamp) VoidCookie; + pub extern fn xcb_ungrab_pointer(c: *Connection, time: Timestamp) VoidCookie; + pub extern fn xcb_grab_button_checked(c: *Connection, owner_events: u8, grab_window: Window, event_mask: u16, pointer_mode: u8, keyboard_mode: u8, confine_to: Window, cursor: Cursor, button: u8, modifiers: u16) VoidCookie; + pub extern fn xcb_grab_button(c: *Connection, owner_events: u8, grab_window: Window, event_mask: u16, pointer_mode: u8, keyboard_mode: u8, confine_to: Window, cursor: Cursor, button: u8, modifiers: u16) VoidCookie; + pub extern fn xcb_ungrab_button_checked(c: *Connection, button: u8, grab_window: Window, modifiers: u16) VoidCookie; + pub extern fn xcb_ungrab_button(c: *Connection, button: u8, grab_window: Window, modifiers: u16) VoidCookie; + pub extern fn xcb_change_active_pointer_grab_checked(c: *Connection, cursor: Cursor, time: Timestamp, event_mask: u16) VoidCookie; + pub extern fn xcb_change_active_pointer_grab(c: *Connection, cursor: Cursor, time: Timestamp, event_mask: u16) VoidCookie; + pub extern fn xcb_grab_keyboard(c: *Connection, owner_events: u8, grab_window: Window, time: Timestamp, pointer_mode: u8, keyboard_mode: u8) GrabKeyboardCookie; + pub extern fn xcb_grab_keyboard_unchecked(c: *Connection, owner_events: u8, grab_window: Window, time: Timestamp, pointer_mode: u8, keyboard_mode: u8) GrabKeyboardCookie; + pub extern fn xcb_grab_keyboard_reply(c: *Connection, cookie: GrabKeyboardCookie, e: ?*?*GenericError) ?*GrabKeyboardReply; + pub extern fn xcb_ungrab_keyboard_checked(c: *Connection, time: Timestamp) VoidCookie; + pub extern fn xcb_ungrab_keyboard(c: *Connection, time: Timestamp) VoidCookie; + pub extern fn xcb_grab_key_checked(c: *Connection, owner_events: u8, grab_window: Window, modifiers: u16, key: Keycode, pointer_mode: u8, keyboard_mode: u8) VoidCookie; + pub extern fn xcb_grab_key(c: *Connection, owner_events: u8, grab_window: Window, modifiers: u16, key: Keycode, pointer_mode: u8, keyboard_mode: u8) VoidCookie; + pub extern fn xcb_ungrab_key_checked(c: *Connection, key: Keycode, grab_window: Window, modifiers: u16) VoidCookie; + pub extern fn xcb_ungrab_key(c: *Connection, key: Keycode, grab_window: Window, modifiers: u16) VoidCookie; + pub extern fn xcb_allow_events_checked(c: *Connection, mode: u8, time: Timestamp) VoidCookie; + pub extern fn xcb_allow_events(c: *Connection, mode: u8, time: Timestamp) VoidCookie; + pub extern fn xcb_grab_server_checked(c: *Connection) VoidCookie; + pub extern fn xcb_grab_server(c: *Connection) VoidCookie; + pub extern fn xcb_ungrab_server_checked(c: *Connection) VoidCookie; + pub extern fn xcb_ungrab_server(c: *Connection) VoidCookie; + pub extern fn xcb_query_pointer(c: *Connection, window: Window) QueryPointerCookie; + pub extern fn xcb_query_pointer_unchecked(c: *Connection, window: Window) QueryPointerCookie; + pub extern fn xcb_query_pointer_reply(c: *Connection, cookie: QueryPointerCookie, e: ?*?*GenericError) ?*QueryPointerReply; pub extern fn xcb_timecoord_next(i: *TimecoordIterator) void; pub extern fn xcb_timecoord_end(i: TimecoordIterator) GenericIterator; pub extern fn xcb_get_motion_events_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_get_motion_events(c: ?*Connection, window: Window, start: Timestamp, stop: Timestamp) GetMotionEventsCookie; - pub extern fn xcb_get_motion_events_unchecked(c: ?*Connection, window: Window, start: Timestamp, stop: Timestamp) GetMotionEventsCookie; + pub extern fn xcb_get_motion_events(c: *Connection, window: Window, start: Timestamp, stop: Timestamp) GetMotionEventsCookie; + pub extern fn xcb_get_motion_events_unchecked(c: *Connection, window: Window, start: Timestamp, stop: Timestamp) GetMotionEventsCookie; pub extern fn xcb_get_motion_events_events(R: *const GetMotionEventsReply) [*c]Timecoord; pub extern fn xcb_get_motion_events_events_length(R: *const GetMotionEventsReply) c_int; pub extern fn xcb_get_motion_events_events_iterator(R: *const GetMotionEventsReply) TimecoordIterator; - pub extern fn xcb_get_motion_events_reply(c: ?*Connection, cookie: GetMotionEventsCookie, e: [*c][*c]GenericError) [*c]GetMotionEventsReply; - pub extern fn xcb_translate_coordinates(c: ?*Connection, src_window: Window, dst_window: Window, src_x: i16, src_y: i16) TranslateCoordinatesCookie; - pub extern fn xcb_translate_coordinates_unchecked(c: ?*Connection, src_window: Window, dst_window: Window, src_x: i16, src_y: i16) TranslateCoordinatesCookie; - pub extern fn xcb_translate_coordinates_reply(c: ?*Connection, cookie: TranslateCoordinatesCookie, e: [*c][*c]GenericError) [*c]TranslateCoordinatesReply; - pub extern fn xcb_warp_pointer_checked(c: ?*Connection, src_window: Window, dst_window: Window, src_x: i16, src_y: i16, src_width: u16, src_height: u16, dst_x: i16, dst_y: i16) VoidCookie; - pub extern fn xcb_warp_pointer(c: ?*Connection, src_window: Window, dst_window: Window, src_x: i16, src_y: i16, src_width: u16, src_height: u16, dst_x: i16, dst_y: i16) VoidCookie; - pub extern fn xcb_set_input_focus_checked(c: ?*Connection, revert_to: u8, focus: Window, time: Timestamp) VoidCookie; - pub extern fn xcb_set_input_focus(c: ?*Connection, revert_to: u8, focus: Window, time: Timestamp) VoidCookie; - pub extern fn xcb_get_input_focus(c: ?*Connection) GetInputFocusCookie; - pub extern fn xcb_get_input_focus_unchecked(c: ?*Connection) GetInputFocusCookie; - pub extern fn xcb_get_input_focus_reply(c: ?*Connection, cookie: GetInputFocusCookie, e: [*c][*c]GenericError) [*c]GetInputFocusReply; - pub extern fn xcb_query_keymap(c: ?*Connection) QueryKeymapCookie; - pub extern fn xcb_query_keymap_unchecked(c: ?*Connection) QueryKeymapCookie; - pub extern fn xcb_query_keymap_reply(c: ?*Connection, cookie: QueryKeymapCookie, e: [*c][*c]GenericError) [*c]QueryKeymapReply; + pub extern fn xcb_get_motion_events_reply(c: *Connection, cookie: GetMotionEventsCookie, e: ?*?*GenericError) ?*GetMotionEventsReply; + pub extern fn xcb_translate_coordinates(c: *Connection, src_window: Window, dst_window: Window, src_x: i16, src_y: i16) TranslateCoordinatesCookie; + pub extern fn xcb_translate_coordinates_unchecked(c: *Connection, src_window: Window, dst_window: Window, src_x: i16, src_y: i16) TranslateCoordinatesCookie; + pub extern fn xcb_translate_coordinates_reply(c: *Connection, cookie: TranslateCoordinatesCookie, e: ?*?*GenericError) ?*TranslateCoordinatesReply; + pub extern fn xcb_warp_pointer_checked(c: *Connection, src_window: Window, dst_window: Window, src_x: i16, src_y: i16, src_width: u16, src_height: u16, dst_x: i16, dst_y: i16) VoidCookie; + pub extern fn xcb_warp_pointer(c: *Connection, src_window: Window, dst_window: Window, src_x: i16, src_y: i16, src_width: u16, src_height: u16, dst_x: i16, dst_y: i16) VoidCookie; + pub extern fn xcb_set_input_focus_checked(c: *Connection, revert_to: u8, focus: Window, time: Timestamp) VoidCookie; + pub extern fn xcb_set_input_focus(c: *Connection, revert_to: u8, focus: Window, time: Timestamp) VoidCookie; + pub extern fn xcb_get_input_focus(c: *Connection) GetInputFocusCookie; + pub extern fn xcb_get_input_focus_unchecked(c: *Connection) GetInputFocusCookie; + pub extern fn xcb_get_input_focus_reply(c: *Connection, cookie: GetInputFocusCookie, e: ?*?*GenericError) ?*GetInputFocusReply; + pub extern fn xcb_query_keymap(c: *Connection) QueryKeymapCookie; + pub extern fn xcb_query_keymap_unchecked(c: *Connection) QueryKeymapCookie; + pub extern fn xcb_query_keymap_reply(c: *Connection, cookie: QueryKeymapCookie, e: ?*?*GenericError) ?*QueryKeymapReply; pub extern fn xcb_open_font_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_open_font_checked(c: ?*Connection, fid: Font, name_len: u16, name: [*c]const u8) VoidCookie; - pub extern fn xcb_open_font(c: ?*Connection, fid: Font, name_len: u16, name: [*c]const u8) VoidCookie; + pub extern fn xcb_open_font_checked(c: *Connection, fid: Font, name_len: u16, name: [*c]const u8) VoidCookie; + pub extern fn xcb_open_font(c: *Connection, fid: Font, name_len: u16, name: [*c]const u8) VoidCookie; pub extern fn xcb_open_font_name(R: *const OpenFontRequest) [*c]u8; pub extern fn xcb_open_font_name_length(R: *const OpenFontRequest) c_int; pub extern fn xcb_open_font_name_end(R: *const OpenFontRequest) GenericIterator; - pub extern fn xcb_close_font_checked(c: ?*Connection, font: Font) VoidCookie; - pub extern fn xcb_close_font(c: ?*Connection, font: Font) VoidCookie; + pub extern fn xcb_close_font_checked(c: *Connection, font: Font) VoidCookie; + pub extern fn xcb_close_font(c: *Connection, font: Font) VoidCookie; pub extern fn xcb_fontprop_next(i: *FontpropIterator) void; pub extern fn xcb_fontprop_end(i: FontpropIterator) GenericIterator; pub extern fn xcb_charinfo_next(i: *CharinfoIterator) void; pub extern fn xcb_charinfo_end(i: CharinfoIterator) GenericIterator; pub extern fn xcb_query_font_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_query_font(c: ?*Connection, font: Fontable) QueryFontCookie; - pub extern fn xcb_query_font_unchecked(c: ?*Connection, font: Fontable) QueryFontCookie; + pub extern fn xcb_query_font(c: *Connection, font: Fontable) QueryFontCookie; + pub extern fn xcb_query_font_unchecked(c: *Connection, font: Fontable) QueryFontCookie; pub extern fn xcb_query_font_properties(R: *const QueryFontReply) [*c]Fontprop; pub extern fn xcb_query_font_properties_length(R: *const QueryFontReply) c_int; pub extern fn xcb_query_font_properties_iterator(R: *const QueryFontReply) FontpropIterator; pub extern fn xcb_query_font_char_infos(R: *const QueryFontReply) [*c]Charinfo; pub extern fn xcb_query_font_char_infos_length(R: *const QueryFontReply) c_int; pub extern fn xcb_query_font_char_infos_iterator(R: *const QueryFontReply) CharinfoIterator; - pub extern fn xcb_query_font_reply(c: ?*Connection, cookie: QueryFontCookie, e: [*c][*c]GenericError) [*c]QueryFontReply; + pub extern fn xcb_query_font_reply(c: *Connection, cookie: QueryFontCookie, e: ?*?*GenericError) ?*QueryFontReply; pub extern fn xcb_query_text_extents_sizeof(_buffer: ?*const anyopaque, string_len: u32) c_int; - pub extern fn xcb_query_text_extents(c: ?*Connection, font: Fontable, string_len: u32, string: [*c]const Char2B) QueryTextExtentsCookie; - pub extern fn xcb_query_text_extents_unchecked(c: ?*Connection, font: Fontable, string_len: u32, string: [*c]const Char2B) QueryTextExtentsCookie; - pub extern fn xcb_query_text_extents_reply(c: ?*Connection, cookie: QueryTextExtentsCookie, e: [*c][*c]GenericError) [*c]QueryTextExtentsReply; + pub extern fn xcb_query_text_extents(c: *Connection, font: Fontable, string_len: u32, string: [*c]const Char2B) QueryTextExtentsCookie; + pub extern fn xcb_query_text_extents_unchecked(c: *Connection, font: Fontable, string_len: u32, string: [*c]const Char2B) QueryTextExtentsCookie; + pub extern fn xcb_query_text_extents_reply(c: *Connection, cookie: QueryTextExtentsCookie, e: ?*?*GenericError) ?*QueryTextExtentsReply; pub extern fn xcb_str_sizeof(_buffer: ?*const anyopaque) c_int; pub extern fn xcb_str_name(R: *const Str) [*c]u8; pub extern fn xcb_str_name_length(R: *const Str) c_int; @@ -4363,298 +5321,298 @@ pub const import = struct { pub extern fn xcb_str_next(i: *StrIterator) void; pub extern fn xcb_str_end(i: StrIterator) GenericIterator; pub extern fn xcb_list_fonts_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_list_fonts(c: ?*Connection, max_names: u16, pattern_len: u16, pattern: [*c]const u8) ListFontsCookie; - pub extern fn xcb_list_fonts_unchecked(c: ?*Connection, max_names: u16, pattern_len: u16, pattern: [*c]const u8) ListFontsCookie; + pub extern fn xcb_list_fonts(c: *Connection, max_names: u16, pattern_len: u16, pattern: [*c]const u8) ListFontsCookie; + pub extern fn xcb_list_fonts_unchecked(c: *Connection, max_names: u16, pattern_len: u16, pattern: [*c]const u8) ListFontsCookie; pub extern fn xcb_list_fonts_names_length(R: *const ListFontsReply) c_int; pub extern fn xcb_list_fonts_names_iterator(R: *const ListFontsReply) StrIterator; - pub extern fn xcb_list_fonts_reply(c: ?*Connection, cookie: ListFontsCookie, e: [*c][*c]GenericError) [*c]ListFontsReply; + pub extern fn xcb_list_fonts_reply(c: *Connection, cookie: ListFontsCookie, e: ?*?*GenericError) ?*ListFontsReply; pub extern fn xcb_list_fonts_with_info_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_list_fonts_with_info(c: ?*Connection, max_names: u16, pattern_len: u16, pattern: [*c]const u8) ListFontsWithInfoCookie; - pub extern fn xcb_list_fonts_with_info_unchecked(c: ?*Connection, max_names: u16, pattern_len: u16, pattern: [*c]const u8) ListFontsWithInfoCookie; + pub extern fn xcb_list_fonts_with_info(c: *Connection, max_names: u16, pattern_len: u16, pattern: [*c]const u8) ListFontsWithInfoCookie; + pub extern fn xcb_list_fonts_with_info_unchecked(c: *Connection, max_names: u16, pattern_len: u16, pattern: [*c]const u8) ListFontsWithInfoCookie; pub extern fn xcb_list_fonts_with_info_properties(R: *const ListFontsWithInfoReply) [*c]Fontprop; pub extern fn xcb_list_fonts_with_info_properties_length(R: *const ListFontsWithInfoReply) c_int; pub extern fn xcb_list_fonts_with_info_properties_iterator(R: *const ListFontsWithInfoReply) FontpropIterator; pub extern fn xcb_list_fonts_with_info_name(R: *const ListFontsWithInfoReply) [*c]u8; pub extern fn xcb_list_fonts_with_info_name_length(R: *const ListFontsWithInfoReply) c_int; pub extern fn xcb_list_fonts_with_info_name_end(R: *const ListFontsWithInfoReply) GenericIterator; - pub extern fn xcb_list_fonts_with_info_reply(c: ?*Connection, cookie: ListFontsWithInfoCookie, e: [*c][*c]GenericError) [*c]ListFontsWithInfoReply; + pub extern fn xcb_list_fonts_with_info_reply(c: *Connection, cookie: ListFontsWithInfoCookie, e: ?*?*GenericError) ?*ListFontsWithInfoReply; pub extern fn xcb_set_font_path_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_set_font_path_checked(c: ?*Connection, font_qty: u16, font: [*c]const Str) VoidCookie; - pub extern fn xcb_set_font_path(c: ?*Connection, font_qty: u16, font: [*c]const Str) VoidCookie; + pub extern fn xcb_set_font_path_checked(c: *Connection, font_qty: u16, font: [*c]const Str) VoidCookie; + pub extern fn xcb_set_font_path(c: *Connection, font_qty: u16, font: [*c]const Str) VoidCookie; pub extern fn xcb_set_font_path_font_length(R: *const SetFontPathRequest) c_int; pub extern fn xcb_set_font_path_font_iterator(R: *const SetFontPathRequest) StrIterator; pub extern fn xcb_get_font_path_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_get_font_path(c: ?*Connection) GetFontPathCookie; - pub extern fn xcb_get_font_path_unchecked(c: ?*Connection) GetFontPathCookie; + pub extern fn xcb_get_font_path(c: *Connection) GetFontPathCookie; + pub extern fn xcb_get_font_path_unchecked(c: *Connection) GetFontPathCookie; pub extern fn xcb_get_font_path_path_length(R: *const GetFontPathReply) c_int; pub extern fn xcb_get_font_path_path_iterator(R: *const GetFontPathReply) StrIterator; - pub extern fn xcb_get_font_path_reply(c: ?*Connection, cookie: GetFontPathCookie, e: [*c][*c]GenericError) [*c]GetFontPathReply; - pub extern fn xcb_create_pixmap_checked(c: ?*Connection, depth: u8, pid: Pixmap, drawable: Drawable, width: u16, height: u16) VoidCookie; - pub extern fn xcb_create_pixmap(c: ?*Connection, depth: u8, pid: Pixmap, drawable: Drawable, width: u16, height: u16) VoidCookie; - pub extern fn xcb_free_pixmap_checked(c: ?*Connection, pixmap: Pixmap) VoidCookie; - pub extern fn xcb_free_pixmap(c: ?*Connection, pixmap: Pixmap) VoidCookie; + pub extern fn xcb_get_font_path_reply(c: *Connection, cookie: GetFontPathCookie, e: ?*?*GenericError) ?*GetFontPathReply; + pub extern fn xcb_create_pixmap_checked(c: *Connection, depth: u8, pid: Pixmap, drawable: Drawable, width: u16, height: u16) VoidCookie; + pub extern fn xcb_create_pixmap(c: *Connection, depth: u8, pid: Pixmap, drawable: Drawable, width: u16, height: u16) VoidCookie; + pub extern fn xcb_free_pixmap_checked(c: *Connection, pixmap: Pixmap) VoidCookie; + pub extern fn xcb_free_pixmap(c: *Connection, pixmap: Pixmap) VoidCookie; pub extern fn xcb_create_gc_value_list_serialize(_buffer: [*c]?*anyopaque, value_mask: u32, _aux: [*c]const CreateGcValueList) c_int; pub extern fn xcb_create_gc_value_list_unpack(_buffer: ?*const anyopaque, value_mask: u32, _aux: [*c]CreateGcValueList) c_int; pub extern fn xcb_create_gc_value_list_sizeof(_buffer: ?*const anyopaque, value_mask: u32) c_int; pub extern fn xcb_create_gc_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_create_gc_checked(c: ?*Connection, cid: Gcontext, drawable: Drawable, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; - pub extern fn xcb_create_gc(c: ?*Connection, cid: Gcontext, drawable: Drawable, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; - pub extern fn xcb_create_gc_aux_checked(c: ?*Connection, cid: Gcontext, drawable: Drawable, value_mask: u32, value_list: [*c]const CreateGcValueList) VoidCookie; - pub extern fn xcb_create_gc_aux(c: ?*Connection, cid: Gcontext, drawable: Drawable, value_mask: u32, value_list: [*c]const CreateGcValueList) VoidCookie; + pub extern fn xcb_create_gc_checked(c: *Connection, cid: Gcontext, drawable: Drawable, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; + pub extern fn xcb_create_gc(c: *Connection, cid: Gcontext, drawable: Drawable, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; + pub extern fn xcb_create_gc_aux_checked(c: *Connection, cid: Gcontext, drawable: Drawable, value_mask: u32, value_list: [*c]const CreateGcValueList) VoidCookie; + pub extern fn xcb_create_gc_aux(c: *Connection, cid: Gcontext, drawable: Drawable, value_mask: u32, value_list: [*c]const CreateGcValueList) VoidCookie; pub extern fn xcb_create_gc_value_list(R: *const CreateGcRequest) ?*anyopaque; pub extern fn xcb_change_gc_value_list_serialize(_buffer: [*c]?*anyopaque, value_mask: u32, _aux: [*c]const ChangeGcValueList) c_int; pub extern fn xcb_change_gc_value_list_unpack(_buffer: ?*const anyopaque, value_mask: u32, _aux: [*c]ChangeGcValueList) c_int; pub extern fn xcb_change_gc_value_list_sizeof(_buffer: ?*const anyopaque, value_mask: u32) c_int; pub extern fn xcb_change_gc_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_change_gc_checked(c: ?*Connection, gc: Gcontext, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; - pub extern fn xcb_change_gc(c: ?*Connection, gc: Gcontext, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; - pub extern fn xcb_change_gc_aux_checked(c: ?*Connection, gc: Gcontext, value_mask: u32, value_list: [*c]const ChangeGcValueList) VoidCookie; - pub extern fn xcb_change_gc_aux(c: ?*Connection, gc: Gcontext, value_mask: u32, value_list: [*c]const ChangeGcValueList) VoidCookie; + pub extern fn xcb_change_gc_checked(c: *Connection, gc: Gcontext, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; + pub extern fn xcb_change_gc(c: *Connection, gc: Gcontext, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; + pub extern fn xcb_change_gc_aux_checked(c: *Connection, gc: Gcontext, value_mask: u32, value_list: [*c]const ChangeGcValueList) VoidCookie; + pub extern fn xcb_change_gc_aux(c: *Connection, gc: Gcontext, value_mask: u32, value_list: [*c]const ChangeGcValueList) VoidCookie; pub extern fn xcb_change_gc_value_list(R: *const ChangeGcRequest) ?*anyopaque; - pub extern fn xcb_copy_gc_checked(c: ?*Connection, src_gc: Gcontext, dst_gc: Gcontext, value_mask: u32) VoidCookie; - pub extern fn xcb_copy_gc(c: ?*Connection, src_gc: Gcontext, dst_gc: Gcontext, value_mask: u32) VoidCookie; + pub extern fn xcb_copy_gc_checked(c: *Connection, src_gc: Gcontext, dst_gc: Gcontext, value_mask: u32) VoidCookie; + pub extern fn xcb_copy_gc(c: *Connection, src_gc: Gcontext, dst_gc: Gcontext, value_mask: u32) VoidCookie; pub extern fn xcb_set_dashes_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_set_dashes_checked(c: ?*Connection, gc: Gcontext, dash_offset: u16, dashes_len: u16, dashes: [*c]const u8) VoidCookie; - pub extern fn xcb_set_dashes(c: ?*Connection, gc: Gcontext, dash_offset: u16, dashes_len: u16, dashes: [*c]const u8) VoidCookie; + pub extern fn xcb_set_dashes_checked(c: *Connection, gc: Gcontext, dash_offset: u16, dashes_len: u16, dashes: [*c]const u8) VoidCookie; + pub extern fn xcb_set_dashes(c: *Connection, gc: Gcontext, dash_offset: u16, dashes_len: u16, dashes: [*c]const u8) VoidCookie; pub extern fn xcb_set_dashes_dashes(R: *const SetDashesRequest) [*c]u8; pub extern fn xcb_set_dashes_dashes_length(R: *const SetDashesRequest) c_int; pub extern fn xcb_set_dashes_dashes_end(R: *const SetDashesRequest) GenericIterator; pub extern fn xcb_set_clip_rectangles_sizeof(_buffer: ?*const anyopaque, rectangles_len: u32) c_int; - pub extern fn xcb_set_clip_rectangles_checked(c: ?*Connection, ordering: u8, gc: Gcontext, clip_x_origin: i16, clip_y_origin: i16, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie; - pub extern fn xcb_set_clip_rectangles(c: ?*Connection, ordering: u8, gc: Gcontext, clip_x_origin: i16, clip_y_origin: i16, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie; + pub extern fn xcb_set_clip_rectangles_checked(c: *Connection, ordering: u8, gc: Gcontext, clip_x_origin: i16, clip_y_origin: i16, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie; + pub extern fn xcb_set_clip_rectangles(c: *Connection, ordering: u8, gc: Gcontext, clip_x_origin: i16, clip_y_origin: i16, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie; pub extern fn xcb_set_clip_rectangles_rectangles(R: *const SetClipRectanglesRequest) [*c]Rectangle; pub extern fn xcb_set_clip_rectangles_rectangles_length(R: *const SetClipRectanglesRequest) c_int; pub extern fn xcb_set_clip_rectangles_rectangles_iterator(R: *const SetClipRectanglesRequest) RectangleIterator; - pub extern fn xcb_free_gc_checked(c: ?*Connection, gc: Gcontext) VoidCookie; - pub extern fn xcb_free_gc(c: ?*Connection, gc: Gcontext) VoidCookie; - pub extern fn xcb_clear_area_checked(c: ?*Connection, exposures: u8, window: Window, x: i16, y: i16, width: u16, height: u16) VoidCookie; - pub extern fn xcb_clear_area(c: ?*Connection, exposures: u8, window: Window, x: i16, y: i16, width: u16, height: u16) VoidCookie; - pub extern fn xcb_copy_area_checked(c: ?*Connection, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16) VoidCookie; - pub extern fn xcb_copy_area(c: ?*Connection, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16) VoidCookie; - pub extern fn xcb_copy_plane_checked(c: ?*Connection, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16, bit_plane: u32) VoidCookie; - pub extern fn xcb_copy_plane(c: ?*Connection, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16, bit_plane: u32) VoidCookie; + pub extern fn xcb_free_gc_checked(c: *Connection, gc: Gcontext) VoidCookie; + pub extern fn xcb_free_gc(c: *Connection, gc: Gcontext) VoidCookie; + pub extern fn xcb_clear_area_checked(c: *Connection, exposures: u8, window: Window, x: i16, y: i16, width: u16, height: u16) VoidCookie; + pub extern fn xcb_clear_area(c: *Connection, exposures: u8, window: Window, x: i16, y: i16, width: u16, height: u16) VoidCookie; + pub extern fn xcb_copy_area_checked(c: *Connection, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16) VoidCookie; + pub extern fn xcb_copy_area(c: *Connection, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16) VoidCookie; + pub extern fn xcb_copy_plane_checked(c: *Connection, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16, bit_plane: u32) VoidCookie; + pub extern fn xcb_copy_plane(c: *Connection, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16, bit_plane: u32) VoidCookie; pub extern fn xcb_poly_point_sizeof(_buffer: ?*const anyopaque, points_len: u32) c_int; - pub extern fn xcb_poly_point_checked(c: ?*Connection, coordinate_mode: u8, drawable: Drawable, gc: Gcontext, points_len: u32, points: [*c]const Point) VoidCookie; - pub extern fn xcb_poly_point(c: ?*Connection, coordinate_mode: u8, drawable: Drawable, gc: Gcontext, points_len: u32, points: [*c]const Point) VoidCookie; + pub extern fn xcb_poly_point_checked(c: *Connection, coordinate_mode: u8, drawable: Drawable, gc: Gcontext, points_len: u32, points: [*c]const Point) VoidCookie; + pub extern fn xcb_poly_point(c: *Connection, coordinate_mode: u8, drawable: Drawable, gc: Gcontext, points_len: u32, points: [*c]const Point) VoidCookie; pub extern fn xcb_poly_point_points(R: *const PolyPointRequest) [*c]Point; pub extern fn xcb_poly_point_points_length(R: *const PolyPointRequest) c_int; pub extern fn xcb_poly_point_points_iterator(R: *const PolyPointRequest) PointIterator; pub extern fn xcb_poly_line_sizeof(_buffer: ?*const anyopaque, points_len: u32) c_int; - pub extern fn xcb_poly_line_checked(c: ?*Connection, coordinate_mode: u8, drawable: Drawable, gc: Gcontext, points_len: u32, points: [*c]const Point) VoidCookie; - pub extern fn xcb_poly_line(c: ?*Connection, coordinate_mode: u8, drawable: Drawable, gc: Gcontext, points_len: u32, points: [*c]const Point) VoidCookie; + pub extern fn xcb_poly_line_checked(c: *Connection, coordinate_mode: u8, drawable: Drawable, gc: Gcontext, points_len: u32, points: [*c]const Point) VoidCookie; + pub extern fn xcb_poly_line(c: *Connection, coordinate_mode: u8, drawable: Drawable, gc: Gcontext, points_len: u32, points: [*c]const Point) VoidCookie; pub extern fn xcb_poly_line_points(R: *const PolyLineRequest) [*c]Point; pub extern fn xcb_poly_line_points_length(R: *const PolyLineRequest) c_int; pub extern fn xcb_poly_line_points_iterator(R: *const PolyLineRequest) PointIterator; pub extern fn xcb_segment_next(i: *SegmentIterator) void; pub extern fn xcb_segment_end(i: SegmentIterator) GenericIterator; pub extern fn xcb_poly_segment_sizeof(_buffer: ?*const anyopaque, segments_len: u32) c_int; - pub extern fn xcb_poly_segment_checked(c: ?*Connection, drawable: Drawable, gc: Gcontext, segments_len: u32, segments: [*c]const Segment) VoidCookie; - pub extern fn xcb_poly_segment(c: ?*Connection, drawable: Drawable, gc: Gcontext, segments_len: u32, segments: [*c]const Segment) VoidCookie; + pub extern fn xcb_poly_segment_checked(c: *Connection, drawable: Drawable, gc: Gcontext, segments_len: u32, segments: [*c]const Segment) VoidCookie; + pub extern fn xcb_poly_segment(c: *Connection, drawable: Drawable, gc: Gcontext, segments_len: u32, segments: [*c]const Segment) VoidCookie; pub extern fn xcb_poly_segment_segments(R: *const PolySegmentRequest) [*c]Segment; pub extern fn xcb_poly_segment_segments_length(R: *const PolySegmentRequest) c_int; pub extern fn xcb_poly_segment_segments_iterator(R: *const PolySegmentRequest) SegmentIterator; pub extern fn xcb_poly_rectangle_sizeof(_buffer: ?*const anyopaque, rectangles_len: u32) c_int; - pub extern fn xcb_poly_rectangle_checked(c: ?*Connection, drawable: Drawable, gc: Gcontext, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie; - pub extern fn xcb_poly_rectangle(c: ?*Connection, drawable: Drawable, gc: Gcontext, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie; + pub extern fn xcb_poly_rectangle_checked(c: *Connection, drawable: Drawable, gc: Gcontext, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie; + pub extern fn xcb_poly_rectangle(c: *Connection, drawable: Drawable, gc: Gcontext, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie; pub extern fn xcb_poly_rectangle_rectangles(R: *const PolyRectangleRequest) [*c]Rectangle; pub extern fn xcb_poly_rectangle_rectangles_length(R: *const PolyRectangleRequest) c_int; pub extern fn xcb_poly_rectangle_rectangles_iterator(R: *const PolyRectangleRequest) RectangleIterator; pub extern fn xcb_poly_arc_sizeof(_buffer: ?*const anyopaque, arcs_len: u32) c_int; - pub extern fn xcb_poly_arc_checked(c: ?*Connection, drawable: Drawable, gc: Gcontext, arcs_len: u32, arcs: [*c]const Arc) VoidCookie; - pub extern fn xcb_poly_arc(c: ?*Connection, drawable: Drawable, gc: Gcontext, arcs_len: u32, arcs: [*c]const Arc) VoidCookie; + pub extern fn xcb_poly_arc_checked(c: *Connection, drawable: Drawable, gc: Gcontext, arcs_len: u32, arcs: [*c]const Arc) VoidCookie; + pub extern fn xcb_poly_arc(c: *Connection, drawable: Drawable, gc: Gcontext, arcs_len: u32, arcs: [*c]const Arc) VoidCookie; pub extern fn xcb_poly_arc_arcs(R: *const PolyArcRequest) [*c]Arc; pub extern fn xcb_poly_arc_arcs_length(R: *const PolyArcRequest) c_int; pub extern fn xcb_poly_arc_arcs_iterator(R: *const PolyArcRequest) ArcIterator; pub extern fn xcb_fill_poly_sizeof(_buffer: ?*const anyopaque, points_len: u32) c_int; - pub extern fn xcb_fill_poly_checked(c: ?*Connection, drawable: Drawable, gc: Gcontext, shape: u8, coordinate_mode: u8, points_len: u32, points: [*c]const Point) VoidCookie; - pub extern fn xcb_fill_poly(c: ?*Connection, drawable: Drawable, gc: Gcontext, shape: u8, coordinate_mode: u8, points_len: u32, points: [*c]const Point) VoidCookie; + pub extern fn xcb_fill_poly_checked(c: *Connection, drawable: Drawable, gc: Gcontext, shape: u8, coordinate_mode: u8, points_len: u32, points: [*c]const Point) VoidCookie; + pub extern fn xcb_fill_poly(c: *Connection, drawable: Drawable, gc: Gcontext, shape: u8, coordinate_mode: u8, points_len: u32, points: [*c]const Point) VoidCookie; pub extern fn xcb_fill_poly_points(R: *const FillPolyRequest) [*c]Point; pub extern fn xcb_fill_poly_points_length(R: *const FillPolyRequest) c_int; pub extern fn xcb_fill_poly_points_iterator(R: *const FillPolyRequest) PointIterator; pub extern fn xcb_poly_fill_rectangle_sizeof(_buffer: ?*const anyopaque, rectangles_len: u32) c_int; - pub extern fn xcb_poly_fill_rectangle_checked(c: ?*Connection, drawable: Drawable, gc: Gcontext, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie; - pub extern fn xcb_poly_fill_rectangle(c: ?*Connection, drawable: Drawable, gc: Gcontext, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie; + pub extern fn xcb_poly_fill_rectangle_checked(c: *Connection, drawable: Drawable, gc: Gcontext, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie; + pub extern fn xcb_poly_fill_rectangle(c: *Connection, drawable: Drawable, gc: Gcontext, rectangles_len: u32, rectangles: [*c]const Rectangle) VoidCookie; pub extern fn xcb_poly_fill_rectangle_rectangles(R: *const PolyFillRectangleRequest) [*c]Rectangle; pub extern fn xcb_poly_fill_rectangle_rectangles_length(R: *const PolyFillRectangleRequest) c_int; pub extern fn xcb_poly_fill_rectangle_rectangles_iterator(R: *const PolyFillRectangleRequest) RectangleIterator; pub extern fn xcb_poly_fill_arc_sizeof(_buffer: ?*const anyopaque, arcs_len: u32) c_int; - pub extern fn xcb_poly_fill_arc_checked(c: ?*Connection, drawable: Drawable, gc: Gcontext, arcs_len: u32, arcs: [*c]const Arc) VoidCookie; - pub extern fn xcb_poly_fill_arc(c: ?*Connection, drawable: Drawable, gc: Gcontext, arcs_len: u32, arcs: [*c]const Arc) VoidCookie; + pub extern fn xcb_poly_fill_arc_checked(c: *Connection, drawable: Drawable, gc: Gcontext, arcs_len: u32, arcs: [*c]const Arc) VoidCookie; + pub extern fn xcb_poly_fill_arc(c: *Connection, drawable: Drawable, gc: Gcontext, arcs_len: u32, arcs: [*c]const Arc) VoidCookie; pub extern fn xcb_poly_fill_arc_arcs(R: *const PolyFillArcRequest) [*c]Arc; pub extern fn xcb_poly_fill_arc_arcs_length(R: *const PolyFillArcRequest) c_int; pub extern fn xcb_poly_fill_arc_arcs_iterator(R: *const PolyFillArcRequest) ArcIterator; pub extern fn xcb_put_image_sizeof(_buffer: ?*const anyopaque, data_len: u32) c_int; - pub extern fn xcb_put_image_checked(c: ?*Connection, format: u8, drawable: Drawable, gc: Gcontext, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data_len: u32, data: [*c]const u8) VoidCookie; - pub extern fn xcb_put_image(c: ?*Connection, format: u8, drawable: Drawable, gc: Gcontext, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data_len: u32, data: [*c]const u8) VoidCookie; + pub extern fn xcb_put_image_checked(c: *Connection, format: u8, drawable: Drawable, gc: Gcontext, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data_len: u32, data: [*c]const u8) VoidCookie; + pub extern fn xcb_put_image(c: *Connection, format: u8, drawable: Drawable, gc: Gcontext, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data_len: u32, data: [*c]const u8) VoidCookie; pub extern fn xcb_put_image_data(R: *const PutImageRequest) [*c]u8; pub extern fn xcb_put_image_data_length(R: *const PutImageRequest) c_int; pub extern fn xcb_put_image_data_end(R: *const PutImageRequest) GenericIterator; pub extern fn xcb_get_image_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_get_image(c: ?*Connection, format: u8, drawable: Drawable, x: i16, y: i16, width: u16, height: u16, plane_mask: u32) GetImageCookie; - pub extern fn xcb_get_image_unchecked(c: ?*Connection, format: u8, drawable: Drawable, x: i16, y: i16, width: u16, height: u16, plane_mask: u32) GetImageCookie; + pub extern fn xcb_get_image(c: *Connection, format: u8, drawable: Drawable, x: i16, y: i16, width: u16, height: u16, plane_mask: u32) GetImageCookie; + pub extern fn xcb_get_image_unchecked(c: *Connection, format: u8, drawable: Drawable, x: i16, y: i16, width: u16, height: u16, plane_mask: u32) GetImageCookie; pub extern fn xcb_get_image_data(R: *const GetImageReply) [*c]u8; pub extern fn xcb_get_image_data_length(R: *const GetImageReply) c_int; pub extern fn xcb_get_image_data_end(R: *const GetImageReply) GenericIterator; - pub extern fn xcb_get_image_reply(c: ?*Connection, cookie: GetImageCookie, e: [*c][*c]GenericError) [*c]GetImageReply; + pub extern fn xcb_get_image_reply(c: *Connection, cookie: GetImageCookie, e: ?*?*GenericError) ?*GetImageReply; pub extern fn xcb_poly_text_8_sizeof(_buffer: ?*const anyopaque, items_len: u32) c_int; - pub extern fn xcb_poly_text_8_checked(c: ?*Connection, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items_len: u32, items: [*c]const u8) VoidCookie; - pub extern fn xcb_poly_text_8(c: ?*Connection, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items_len: u32, items: [*c]const u8) VoidCookie; + pub extern fn xcb_poly_text_8_checked(c: *Connection, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items_len: u32, items: [*c]const u8) VoidCookie; + pub extern fn xcb_poly_text_8(c: *Connection, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items_len: u32, items: [*c]const u8) VoidCookie; pub extern fn xcb_poly_text_8_items(R: *const PolyText8Request) [*c]u8; pub extern fn xcb_poly_text_8_items_length(R: *const PolyText8Request) c_int; pub extern fn xcb_poly_text_8_items_end(R: *const PolyText8Request) GenericIterator; pub extern fn xcb_poly_text_16_sizeof(_buffer: ?*const anyopaque, items_len: u32) c_int; - pub extern fn xcb_poly_text_16_checked(c: ?*Connection, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items_len: u32, items: [*c]const u8) VoidCookie; - pub extern fn xcb_poly_text_16(c: ?*Connection, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items_len: u32, items: [*c]const u8) VoidCookie; + pub extern fn xcb_poly_text_16_checked(c: *Connection, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items_len: u32, items: [*c]const u8) VoidCookie; + pub extern fn xcb_poly_text_16(c: *Connection, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items_len: u32, items: [*c]const u8) VoidCookie; pub extern fn xcb_poly_text_16_items(R: *const PolyText16Request) [*c]u8; pub extern fn xcb_poly_text_16_items_length(R: *const PolyText16Request) c_int; pub extern fn xcb_poly_text_16_items_end(R: *const PolyText16Request) GenericIterator; pub extern fn xcb_image_text_8_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_image_text_8_checked(c: ?*Connection, string_len: u8, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: [*c]const u8) VoidCookie; - pub extern fn xcb_image_text_8(c: ?*Connection, string_len: u8, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: [*c]const u8) VoidCookie; + pub extern fn xcb_image_text_8_checked(c: *Connection, string_len: u8, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: [*c]const u8) VoidCookie; + pub extern fn xcb_image_text_8(c: *Connection, string_len: u8, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: [*c]const u8) VoidCookie; pub extern fn xcb_image_text_8_string(R: *const ImageText8Request) [*c]u8; pub extern fn xcb_image_text_8_string_length(R: *const ImageText8Request) c_int; pub extern fn xcb_image_text_8_string_end(R: *const ImageText8Request) GenericIterator; pub extern fn xcb_image_text_16_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_image_text_16_checked(c: ?*Connection, string_len: u8, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: [*c]const Char2B) VoidCookie; - pub extern fn xcb_image_text_16(c: ?*Connection, string_len: u8, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: [*c]const Char2B) VoidCookie; + pub extern fn xcb_image_text_16_checked(c: *Connection, string_len: u8, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: [*c]const Char2B) VoidCookie; + pub extern fn xcb_image_text_16(c: *Connection, string_len: u8, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: [*c]const Char2B) VoidCookie; pub extern fn xcb_image_text_16_string(R: *const ImageText16Request) [*c]Char2B; pub extern fn xcb_image_text_16_string_length(R: *const ImageText16Request) c_int; pub extern fn xcb_image_text_16_string_iterator(R: *const ImageText16Request) Char2BIterator; - pub extern fn xcb_create_colormap_checked(c: ?*Connection, alloc: u8, mid: Colormap, window: Window, visual: Visualid) VoidCookie; - pub extern fn xcb_create_colormap(c: ?*Connection, alloc: u8, mid: Colormap, window: Window, visual: Visualid) VoidCookie; - pub extern fn xcb_free_colormap_checked(c: ?*Connection, cmap: Colormap) VoidCookie; - pub extern fn xcb_free_colormap(c: ?*Connection, cmap: Colormap) VoidCookie; - pub extern fn xcb_copy_colormap_and_free_checked(c: ?*Connection, mid: Colormap, src_cmap: Colormap) VoidCookie; - pub extern fn xcb_copy_colormap_and_free(c: ?*Connection, mid: Colormap, src_cmap: Colormap) VoidCookie; - pub extern fn xcb_install_colormap_checked(c: ?*Connection, cmap: Colormap) VoidCookie; - pub extern fn xcb_install_colormap(c: ?*Connection, cmap: Colormap) VoidCookie; - pub extern fn xcb_uninstall_colormap_checked(c: ?*Connection, cmap: Colormap) VoidCookie; - pub extern fn xcb_uninstall_colormap(c: ?*Connection, cmap: Colormap) VoidCookie; + pub extern fn xcb_create_colormap_checked(c: *Connection, alloc: u8, mid: Colormap, window: Window, visual: Visualid) VoidCookie; + pub extern fn xcb_create_colormap(c: *Connection, alloc: u8, mid: Colormap, window: Window, visual: Visualid) VoidCookie; + pub extern fn xcb_free_colormap_checked(c: *Connection, cmap: Colormap) VoidCookie; + pub extern fn xcb_free_colormap(c: *Connection, cmap: Colormap) VoidCookie; + pub extern fn xcb_copy_colormap_and_free_checked(c: *Connection, mid: Colormap, src_cmap: Colormap) VoidCookie; + pub extern fn xcb_copy_colormap_and_free(c: *Connection, mid: Colormap, src_cmap: Colormap) VoidCookie; + pub extern fn xcb_install_colormap_checked(c: *Connection, cmap: Colormap) VoidCookie; + pub extern fn xcb_install_colormap(c: *Connection, cmap: Colormap) VoidCookie; + pub extern fn xcb_uninstall_colormap_checked(c: *Connection, cmap: Colormap) VoidCookie; + pub extern fn xcb_uninstall_colormap(c: *Connection, cmap: Colormap) VoidCookie; pub extern fn xcb_list_installed_colormaps_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_list_installed_colormaps(c: ?*Connection, window: Window) ListInstalledColormapsCookie; - pub extern fn xcb_list_installed_colormaps_unchecked(c: ?*Connection, window: Window) ListInstalledColormapsCookie; + pub extern fn xcb_list_installed_colormaps(c: *Connection, window: Window) ListInstalledColormapsCookie; + pub extern fn xcb_list_installed_colormaps_unchecked(c: *Connection, window: Window) ListInstalledColormapsCookie; pub extern fn xcb_list_installed_colormaps_cmaps(R: *const ListInstalledColormapsReply) [*c]Colormap; pub extern fn xcb_list_installed_colormaps_cmaps_length(R: *const ListInstalledColormapsReply) c_int; pub extern fn xcb_list_installed_colormaps_cmaps_end(R: *const ListInstalledColormapsReply) GenericIterator; - pub extern fn xcb_list_installed_colormaps_reply(c: ?*Connection, cookie: ListInstalledColormapsCookie, e: [*c][*c]GenericError) [*c]ListInstalledColormapsReply; - pub extern fn xcb_alloc_color(c: ?*Connection, cmap: Colormap, red: u16, green: u16, blue: u16) AllocColorCookie; - pub extern fn xcb_alloc_color_unchecked(c: ?*Connection, cmap: Colormap, red: u16, green: u16, blue: u16) AllocColorCookie; - pub extern fn xcb_alloc_color_reply(c: ?*Connection, cookie: AllocColorCookie, e: [*c][*c]GenericError) [*c]AllocColorReply; + pub extern fn xcb_list_installed_colormaps_reply(c: *Connection, cookie: ListInstalledColormapsCookie, e: ?*?*GenericError) ?*ListInstalledColormapsReply; + pub extern fn xcb_alloc_color(c: *Connection, cmap: Colormap, red: u16, green: u16, blue: u16) AllocColorCookie; + pub extern fn xcb_alloc_color_unchecked(c: *Connection, cmap: Colormap, red: u16, green: u16, blue: u16) AllocColorCookie; + pub extern fn xcb_alloc_color_reply(c: *Connection, cookie: AllocColorCookie, e: ?*?*GenericError) ?*AllocColorReply; pub extern fn xcb_alloc_named_color_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_alloc_named_color(c: ?*Connection, cmap: Colormap, name_len: u16, name: [*c]const u8) AllocNamedColorCookie; - pub extern fn xcb_alloc_named_color_unchecked(c: ?*Connection, cmap: Colormap, name_len: u16, name: [*c]const u8) AllocNamedColorCookie; - pub extern fn xcb_alloc_named_color_reply(c: ?*Connection, cookie: AllocNamedColorCookie, e: [*c][*c]GenericError) [*c]AllocNamedColorReply; + pub extern fn xcb_alloc_named_color(c: *Connection, cmap: Colormap, name_len: u16, name: [*c]const u8) AllocNamedColorCookie; + pub extern fn xcb_alloc_named_color_unchecked(c: *Connection, cmap: Colormap, name_len: u16, name: [*c]const u8) AllocNamedColorCookie; + pub extern fn xcb_alloc_named_color_reply(c: *Connection, cookie: AllocNamedColorCookie, e: ?*?*GenericError) ?*AllocNamedColorReply; pub extern fn xcb_alloc_color_cells_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_alloc_color_cells(c: ?*Connection, contiguous: u8, cmap: Colormap, colors: u16, planes: u16) AllocColorCellsCookie; - pub extern fn xcb_alloc_color_cells_unchecked(c: ?*Connection, contiguous: u8, cmap: Colormap, colors: u16, planes: u16) AllocColorCellsCookie; + pub extern fn xcb_alloc_color_cells(c: *Connection, contiguous: u8, cmap: Colormap, colors: u16, planes: u16) AllocColorCellsCookie; + pub extern fn xcb_alloc_color_cells_unchecked(c: *Connection, contiguous: u8, cmap: Colormap, colors: u16, planes: u16) AllocColorCellsCookie; pub extern fn xcb_alloc_color_cells_pixels(R: *const AllocColorCellsReply) [*c]u32; pub extern fn xcb_alloc_color_cells_pixels_length(R: *const AllocColorCellsReply) c_int; pub extern fn xcb_alloc_color_cells_pixels_end(R: *const AllocColorCellsReply) GenericIterator; pub extern fn xcb_alloc_color_cells_masks(R: *const AllocColorCellsReply) [*c]u32; pub extern fn xcb_alloc_color_cells_masks_length(R: *const AllocColorCellsReply) c_int; pub extern fn xcb_alloc_color_cells_masks_end(R: *const AllocColorCellsReply) GenericIterator; - pub extern fn xcb_alloc_color_cells_reply(c: ?*Connection, cookie: AllocColorCellsCookie, e: [*c][*c]GenericError) [*c]AllocColorCellsReply; + pub extern fn xcb_alloc_color_cells_reply(c: *Connection, cookie: AllocColorCellsCookie, e: ?*?*GenericError) ?*AllocColorCellsReply; pub extern fn xcb_alloc_color_planes_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_alloc_color_planes(c: ?*Connection, contiguous: u8, cmap: Colormap, colors: u16, reds: u16, greens: u16, blues: u16) AllocColorPlanesCookie; - pub extern fn xcb_alloc_color_planes_unchecked(c: ?*Connection, contiguous: u8, cmap: Colormap, colors: u16, reds: u16, greens: u16, blues: u16) AllocColorPlanesCookie; + pub extern fn xcb_alloc_color_planes(c: *Connection, contiguous: u8, cmap: Colormap, colors: u16, reds: u16, greens: u16, blues: u16) AllocColorPlanesCookie; + pub extern fn xcb_alloc_color_planes_unchecked(c: *Connection, contiguous: u8, cmap: Colormap, colors: u16, reds: u16, greens: u16, blues: u16) AllocColorPlanesCookie; pub extern fn xcb_alloc_color_planes_pixels(R: *const AllocColorPlanesReply) [*c]u32; pub extern fn xcb_alloc_color_planes_pixels_length(R: *const AllocColorPlanesReply) c_int; pub extern fn xcb_alloc_color_planes_pixels_end(R: *const AllocColorPlanesReply) GenericIterator; - pub extern fn xcb_alloc_color_planes_reply(c: ?*Connection, cookie: AllocColorPlanesCookie, e: [*c][*c]GenericError) [*c]AllocColorPlanesReply; + pub extern fn xcb_alloc_color_planes_reply(c: *Connection, cookie: AllocColorPlanesCookie, e: ?*?*GenericError) ?*AllocColorPlanesReply; pub extern fn xcb_free_colors_sizeof(_buffer: ?*const anyopaque, pixels_len: u32) c_int; - pub extern fn xcb_free_colors_checked(c: ?*Connection, cmap: Colormap, plane_mask: u32, pixels_len: u32, pixels: [*c]const u32) VoidCookie; - pub extern fn xcb_free_colors(c: ?*Connection, cmap: Colormap, plane_mask: u32, pixels_len: u32, pixels: [*c]const u32) VoidCookie; + pub extern fn xcb_free_colors_checked(c: *Connection, cmap: Colormap, plane_mask: u32, pixels_len: u32, pixels: [*c]const u32) VoidCookie; + pub extern fn xcb_free_colors(c: *Connection, cmap: Colormap, plane_mask: u32, pixels_len: u32, pixels: [*c]const u32) VoidCookie; pub extern fn xcb_free_colors_pixels(R: *const FreeColorsRequest) [*c]u32; pub extern fn xcb_free_colors_pixels_length(R: *const FreeColorsRequest) c_int; pub extern fn xcb_free_colors_pixels_end(R: *const FreeColorsRequest) GenericIterator; pub extern fn xcb_coloritem_next(i: *ColoritemIterator) void; pub extern fn xcb_coloritem_end(i: ColoritemIterator) GenericIterator; pub extern fn xcb_store_colors_sizeof(_buffer: ?*const anyopaque, items_len: u32) c_int; - pub extern fn xcb_store_colors_checked(c: ?*Connection, cmap: Colormap, items_len: u32, items: [*c]const Coloritem) VoidCookie; - pub extern fn xcb_store_colors(c: ?*Connection, cmap: Colormap, items_len: u32, items: [*c]const Coloritem) VoidCookie; + pub extern fn xcb_store_colors_checked(c: *Connection, cmap: Colormap, items_len: u32, items: [*c]const Coloritem) VoidCookie; + pub extern fn xcb_store_colors(c: *Connection, cmap: Colormap, items_len: u32, items: [*c]const Coloritem) VoidCookie; pub extern fn xcb_store_colors_items(R: *const StoreColorsRequest) [*c]Coloritem; pub extern fn xcb_store_colors_items_length(R: *const StoreColorsRequest) c_int; pub extern fn xcb_store_colors_items_iterator(R: *const StoreColorsRequest) ColoritemIterator; pub extern fn xcb_store_named_color_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_store_named_color_checked(c: ?*Connection, flags: u8, cmap: Colormap, pixel: u32, name_len: u16, name: [*c]const u8) VoidCookie; - pub extern fn xcb_store_named_color(c: ?*Connection, flags: u8, cmap: Colormap, pixel: u32, name_len: u16, name: [*c]const u8) VoidCookie; + pub extern fn xcb_store_named_color_checked(c: *Connection, flags: u8, cmap: Colormap, pixel: u32, name_len: u16, name: [*c]const u8) VoidCookie; + pub extern fn xcb_store_named_color(c: *Connection, flags: u8, cmap: Colormap, pixel: u32, name_len: u16, name: [*c]const u8) VoidCookie; pub extern fn xcb_store_named_color_name(R: *const StoreNamedColorRequest) [*c]u8; pub extern fn xcb_store_named_color_name_length(R: *const StoreNamedColorRequest) c_int; pub extern fn xcb_store_named_color_name_end(R: *const StoreNamedColorRequest) GenericIterator; pub extern fn xcb_rgb_next(i: *RgbIterator) void; pub extern fn xcb_rgb_end(i: RgbIterator) GenericIterator; pub extern fn xcb_query_colors_sizeof(_buffer: ?*const anyopaque, pixels_len: u32) c_int; - pub extern fn xcb_query_colors(c: ?*Connection, cmap: Colormap, pixels_len: u32, pixels: [*c]const u32) QueryColorsCookie; - pub extern fn xcb_query_colors_unchecked(c: ?*Connection, cmap: Colormap, pixels_len: u32, pixels: [*c]const u32) QueryColorsCookie; + pub extern fn xcb_query_colors(c: *Connection, cmap: Colormap, pixels_len: u32, pixels: [*c]const u32) QueryColorsCookie; + pub extern fn xcb_query_colors_unchecked(c: *Connection, cmap: Colormap, pixels_len: u32, pixels: [*c]const u32) QueryColorsCookie; pub extern fn xcb_query_colors_colors(R: *const QueryColorsReply) [*c]Rgb; pub extern fn xcb_query_colors_colors_length(R: *const QueryColorsReply) c_int; pub extern fn xcb_query_colors_colors_iterator(R: *const QueryColorsReply) RgbIterator; - pub extern fn xcb_query_colors_reply(c: ?*Connection, cookie: QueryColorsCookie, e: [*c][*c]GenericError) [*c]QueryColorsReply; + pub extern fn xcb_query_colors_reply(c: *Connection, cookie: QueryColorsCookie, e: ?*?*GenericError) ?*QueryColorsReply; pub extern fn xcb_lookup_color_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_lookup_color(c: ?*Connection, cmap: Colormap, name_len: u16, name: [*c]const u8) LookupColorCookie; - pub extern fn xcb_lookup_color_unchecked(c: ?*Connection, cmap: Colormap, name_len: u16, name: [*c]const u8) LookupColorCookie; - pub extern fn xcb_lookup_color_reply(c: ?*Connection, cookie: LookupColorCookie, e: [*c][*c]GenericError) [*c]LookupColorReply; - pub extern fn xcb_create_cursor_checked(c: ?*Connection, cid: Cursor, source: Pixmap, mask: Pixmap, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, x: u16, y: u16) VoidCookie; - pub extern fn xcb_create_cursor(c: ?*Connection, cid: Cursor, source: Pixmap, mask: Pixmap, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, x: u16, y: u16) VoidCookie; - pub extern fn xcb_create_glyph_cursor_checked(c: ?*Connection, cid: Cursor, source_font: Font, mask_font: Font, source_char: u16, mask_char: u16, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) VoidCookie; - pub extern fn xcb_create_glyph_cursor(c: ?*Connection, cid: Cursor, source_font: Font, mask_font: Font, source_char: u16, mask_char: u16, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) VoidCookie; - pub extern fn xcb_free_cursor_checked(c: ?*Connection, cursor: Cursor) VoidCookie; - pub extern fn xcb_free_cursor(c: ?*Connection, cursor: Cursor) VoidCookie; - pub extern fn xcb_recolor_cursor_checked(c: ?*Connection, cursor: Cursor, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) VoidCookie; - pub extern fn xcb_recolor_cursor(c: ?*Connection, cursor: Cursor, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) VoidCookie; - pub extern fn xcb_query_best_size(c: ?*Connection, _class: u8, drawable: Drawable, width: u16, height: u16) QueryBestSizeCookie; - pub extern fn xcb_query_best_size_unchecked(c: ?*Connection, _class: u8, drawable: Drawable, width: u16, height: u16) QueryBestSizeCookie; - pub extern fn xcb_query_best_size_reply(c: ?*Connection, cookie: QueryBestSizeCookie, e: [*c][*c]GenericError) [*c]QueryBestSizeReply; + pub extern fn xcb_lookup_color(c: *Connection, cmap: Colormap, name_len: u16, name: [*c]const u8) LookupColorCookie; + pub extern fn xcb_lookup_color_unchecked(c: *Connection, cmap: Colormap, name_len: u16, name: [*c]const u8) LookupColorCookie; + pub extern fn xcb_lookup_color_reply(c: *Connection, cookie: LookupColorCookie, e: ?*?*GenericError) ?*LookupColorReply; + pub extern fn xcb_create_cursor_checked(c: *Connection, cid: Cursor, source: Pixmap, mask: Pixmap, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, x: u16, y: u16) VoidCookie; + pub extern fn xcb_create_cursor(c: *Connection, cid: Cursor, source: Pixmap, mask: Pixmap, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, x: u16, y: u16) VoidCookie; + pub extern fn xcb_create_glyph_cursor_checked(c: *Connection, cid: Cursor, source_font: Font, mask_font: Font, source_char: u16, mask_char: u16, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) VoidCookie; + pub extern fn xcb_create_glyph_cursor(c: *Connection, cid: Cursor, source_font: Font, mask_font: Font, source_char: u16, mask_char: u16, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) VoidCookie; + pub extern fn xcb_free_cursor_checked(c: *Connection, cursor: Cursor) VoidCookie; + pub extern fn xcb_free_cursor(c: *Connection, cursor: Cursor) VoidCookie; + pub extern fn xcb_recolor_cursor_checked(c: *Connection, cursor: Cursor, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) VoidCookie; + pub extern fn xcb_recolor_cursor(c: *Connection, cursor: Cursor, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) VoidCookie; + pub extern fn xcb_query_best_size(c: *Connection, _class: u8, drawable: Drawable, width: u16, height: u16) QueryBestSizeCookie; + pub extern fn xcb_query_best_size_unchecked(c: *Connection, _class: u8, drawable: Drawable, width: u16, height: u16) QueryBestSizeCookie; + pub extern fn xcb_query_best_size_reply(c: *Connection, cookie: QueryBestSizeCookie, e: ?*?*GenericError) ?*QueryBestSizeReply; pub extern fn xcb_query_extension_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_query_extension(c: ?*Connection, name_len: u16, name: [*c]const u8) QueryExtensionCookie; - pub extern fn xcb_query_extension_unchecked(c: ?*Connection, name_len: u16, name: [*c]const u8) QueryExtensionCookie; - pub extern fn xcb_query_extension_reply(c: ?*Connection, cookie: QueryExtensionCookie, e: [*c][*c]GenericError) [*c]QueryExtensionReply; + pub extern fn xcb_query_extension(c: *Connection, name_len: u16, name: [*c]const u8) QueryExtensionCookie; + pub extern fn xcb_query_extension_unchecked(c: *Connection, name_len: u16, name: [*c]const u8) QueryExtensionCookie; + pub extern fn xcb_query_extension_reply(c: *Connection, cookie: QueryExtensionCookie, e: ?*?*GenericError) ?*QueryExtensionReply; pub extern fn xcb_list_extensions_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_list_extensions(c: ?*Connection) ListExtensionsCookie; - pub extern fn xcb_list_extensions_unchecked(c: ?*Connection) ListExtensionsCookie; + pub extern fn xcb_list_extensions(c: *Connection) ListExtensionsCookie; + pub extern fn xcb_list_extensions_unchecked(c: *Connection) ListExtensionsCookie; pub extern fn xcb_list_extensions_names_length(R: *const ListExtensionsReply) c_int; pub extern fn xcb_list_extensions_names_iterator(R: *const ListExtensionsReply) StrIterator; - pub extern fn xcb_list_extensions_reply(c: ?*Connection, cookie: ListExtensionsCookie, e: [*c][*c]GenericError) [*c]ListExtensionsReply; + pub extern fn xcb_list_extensions_reply(c: *Connection, cookie: ListExtensionsCookie, e: ?*?*GenericError) ?*ListExtensionsReply; pub extern fn xcb_change_keyboard_mapping_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_change_keyboard_mapping_checked(c: ?*Connection, keycode_count: u8, first_keycode: Keycode, keysyms_per_keycode: u8, keysyms: [*c]const Keysym) VoidCookie; - pub extern fn xcb_change_keyboard_mapping(c: ?*Connection, keycode_count: u8, first_keycode: Keycode, keysyms_per_keycode: u8, keysyms: [*c]const Keysym) VoidCookie; + pub extern fn xcb_change_keyboard_mapping_checked(c: *Connection, keycode_count: u8, first_keycode: Keycode, keysyms_per_keycode: u8, keysyms: [*c]const Keysym) VoidCookie; + pub extern fn xcb_change_keyboard_mapping(c: *Connection, keycode_count: u8, first_keycode: Keycode, keysyms_per_keycode: u8, keysyms: [*c]const Keysym) VoidCookie; pub extern fn xcb_change_keyboard_mapping_keysyms(R: *const ChangeKeyboardMappingRequest) [*c]Keysym; pub extern fn xcb_change_keyboard_mapping_keysyms_length(R: *const ChangeKeyboardMappingRequest) c_int; pub extern fn xcb_change_keyboard_mapping_keysyms_end(R: *const ChangeKeyboardMappingRequest) GenericIterator; pub extern fn xcb_get_keyboard_mapping_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_get_keyboard_mapping(c: ?*Connection, first_keycode: Keycode, count: u8) GetKeyboardMappingCookie; - pub extern fn xcb_get_keyboard_mapping_unchecked(c: ?*Connection, first_keycode: Keycode, count: u8) GetKeyboardMappingCookie; + pub extern fn xcb_get_keyboard_mapping(c: *Connection, first_keycode: Keycode, count: u8) GetKeyboardMappingCookie; + pub extern fn xcb_get_keyboard_mapping_unchecked(c: *Connection, first_keycode: Keycode, count: u8) GetKeyboardMappingCookie; pub extern fn xcb_get_keyboard_mapping_keysyms(R: *const GetKeyboardMappingReply) [*c]Keysym; pub extern fn xcb_get_keyboard_mapping_keysyms_length(R: *const GetKeyboardMappingReply) c_int; pub extern fn xcb_get_keyboard_mapping_keysyms_end(R: *const GetKeyboardMappingReply) GenericIterator; - pub extern fn xcb_get_keyboard_mapping_reply(c: ?*Connection, cookie: GetKeyboardMappingCookie, e: [*c][*c]GenericError) [*c]GetKeyboardMappingReply; + pub extern fn xcb_get_keyboard_mapping_reply(c: *Connection, cookie: GetKeyboardMappingCookie, e: ?*?*GenericError) ?*GetKeyboardMappingReply; pub extern fn xcb_change_keyboard_control_value_list_serialize(_buffer: [*c]?*anyopaque, value_mask: u32, _aux: [*c]const ChangeKeyboardControlValueList) c_int; pub extern fn xcb_change_keyboard_control_value_list_unpack(_buffer: ?*const anyopaque, value_mask: u32, _aux: [*c]ChangeKeyboardControlValueList) c_int; pub extern fn xcb_change_keyboard_control_value_list_sizeof(_buffer: ?*const anyopaque, value_mask: u32) c_int; pub extern fn xcb_change_keyboard_control_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_change_keyboard_control_checked(c: ?*Connection, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; - pub extern fn xcb_change_keyboard_control(c: ?*Connection, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; - pub extern fn xcb_change_keyboard_control_aux_checked(c: ?*Connection, value_mask: u32, value_list: [*c]const ChangeKeyboardControlValueList) VoidCookie; - pub extern fn xcb_change_keyboard_control_aux(c: ?*Connection, value_mask: u32, value_list: [*c]const ChangeKeyboardControlValueList) VoidCookie; + pub extern fn xcb_change_keyboard_control_checked(c: *Connection, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; + pub extern fn xcb_change_keyboard_control(c: *Connection, value_mask: u32, value_list: ?*const anyopaque) VoidCookie; + pub extern fn xcb_change_keyboard_control_aux_checked(c: *Connection, value_mask: u32, value_list: [*c]const ChangeKeyboardControlValueList) VoidCookie; + pub extern fn xcb_change_keyboard_control_aux(c: *Connection, value_mask: u32, value_list: [*c]const ChangeKeyboardControlValueList) VoidCookie; pub extern fn xcb_change_keyboard_control_value_list(R: *const ChangeKeyboardControlRequest) ?*anyopaque; - pub extern fn xcb_get_keyboard_control(c: ?*Connection) GetKeyboardControlCookie; - pub extern fn xcb_get_keyboard_control_unchecked(c: ?*Connection) GetKeyboardControlCookie; - pub extern fn xcb_get_keyboard_control_reply(c: ?*Connection, cookie: GetKeyboardControlCookie, e: [*c][*c]GenericError) [*c]GetKeyboardControlReply; - pub extern fn xcb_bell_checked(c: ?*Connection, percent: i8) VoidCookie; - pub extern fn xcb_bell(c: ?*Connection, percent: i8) VoidCookie; - pub extern fn xcb_change_pointer_control_checked(c: ?*Connection, acceleration_numerator: i16, acceleration_denominator: i16, threshold: i16, do_acceleration: u8, do_threshold: u8) VoidCookie; - pub extern fn xcb_change_pointer_control(c: ?*Connection, acceleration_numerator: i16, acceleration_denominator: i16, threshold: i16, do_acceleration: u8, do_threshold: u8) VoidCookie; - pub extern fn xcb_get_pointer_control(c: ?*Connection) GetPointerControlCookie; - pub extern fn xcb_get_pointer_control_unchecked(c: ?*Connection) GetPointerControlCookie; - pub extern fn xcb_get_pointer_control_reply(c: ?*Connection, cookie: GetPointerControlCookie, e: [*c][*c]GenericError) [*c]GetPointerControlReply; - pub extern fn xcb_set_screen_saver_checked(c: ?*Connection, timeout: i16, interval: i16, prefer_blanking: u8, allow_exposures: u8) VoidCookie; - pub extern fn xcb_set_screen_saver(c: ?*Connection, timeout: i16, interval: i16, prefer_blanking: u8, allow_exposures: u8) VoidCookie; - pub extern fn xcb_get_screen_saver(c: ?*Connection) GetScreenSaverCookie; - pub extern fn xcb_get_screen_saver_unchecked(c: ?*Connection) GetScreenSaverCookie; - pub extern fn xcb_get_screen_saver_reply(c: ?*Connection, cookie: GetScreenSaverCookie, e: [*c][*c]GenericError) [*c]GetScreenSaverReply; + pub extern fn xcb_get_keyboard_control(c: *Connection) GetKeyboardControlCookie; + pub extern fn xcb_get_keyboard_control_unchecked(c: *Connection) GetKeyboardControlCookie; + pub extern fn xcb_get_keyboard_control_reply(c: *Connection, cookie: GetKeyboardControlCookie, e: ?*?*GenericError) ?*GetKeyboardControlReply; + pub extern fn xcb_bell_checked(c: *Connection, percent: i8) VoidCookie; + pub extern fn xcb_bell(c: *Connection, percent: i8) VoidCookie; + pub extern fn xcb_change_pointer_control_checked(c: *Connection, acceleration_numerator: i16, acceleration_denominator: i16, threshold: i16, do_acceleration: u8, do_threshold: u8) VoidCookie; + pub extern fn xcb_change_pointer_control(c: *Connection, acceleration_numerator: i16, acceleration_denominator: i16, threshold: i16, do_acceleration: u8, do_threshold: u8) VoidCookie; + pub extern fn xcb_get_pointer_control(c: *Connection) GetPointerControlCookie; + pub extern fn xcb_get_pointer_control_unchecked(c: *Connection) GetPointerControlCookie; + pub extern fn xcb_get_pointer_control_reply(c: *Connection, cookie: GetPointerControlCookie, e: ?*?*GenericError) ?*GetPointerControlReply; + pub extern fn xcb_set_screen_saver_checked(c: *Connection, timeout: i16, interval: i16, prefer_blanking: u8, allow_exposures: u8) VoidCookie; + pub extern fn xcb_set_screen_saver(c: *Connection, timeout: i16, interval: i16, prefer_blanking: u8, allow_exposures: u8) VoidCookie; + pub extern fn xcb_get_screen_saver(c: *Connection) GetScreenSaverCookie; + pub extern fn xcb_get_screen_saver_unchecked(c: *Connection) GetScreenSaverCookie; + pub extern fn xcb_get_screen_saver_reply(c: *Connection, cookie: GetScreenSaverCookie, e: ?*?*GenericError) ?*GetScreenSaverReply; pub extern fn xcb_change_hosts_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_change_hosts_checked(c: ?*Connection, mode: u8, family: u8, address_len: u16, address: [*c]const u8) VoidCookie; - pub extern fn xcb_change_hosts(c: ?*Connection, mode: u8, family: u8, address_len: u16, address: [*c]const u8) VoidCookie; + pub extern fn xcb_change_hosts_checked(c: *Connection, mode: u8, family: u8, address_len: u16, address: [*c]const u8) VoidCookie; + pub extern fn xcb_change_hosts(c: *Connection, mode: u8, family: u8, address_len: u16, address: [*c]const u8) VoidCookie; pub extern fn xcb_change_hosts_address(R: *const ChangeHostsRequest) [*c]u8; pub extern fn xcb_change_hosts_address_length(R: *const ChangeHostsRequest) c_int; pub extern fn xcb_change_hosts_address_end(R: *const ChangeHostsRequest) GenericIterator; @@ -4665,75 +5623,75 @@ pub const import = struct { pub extern fn xcb_host_next(i: *HostIterator) void; pub extern fn xcb_host_end(i: HostIterator) GenericIterator; pub extern fn xcb_list_hosts_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_list_hosts(c: ?*Connection) ListHostsCookie; - pub extern fn xcb_list_hosts_unchecked(c: ?*Connection) ListHostsCookie; + pub extern fn xcb_list_hosts(c: *Connection) ListHostsCookie; + pub extern fn xcb_list_hosts_unchecked(c: *Connection) ListHostsCookie; pub extern fn xcb_list_hosts_hosts_length(R: *const ListHostsReply) c_int; pub extern fn xcb_list_hosts_hosts_iterator(R: *const ListHostsReply) HostIterator; - pub extern fn xcb_list_hosts_reply(c: ?*Connection, cookie: ListHostsCookie, e: [*c][*c]GenericError) [*c]ListHostsReply; - pub extern fn xcb_set_access_control_checked(c: ?*Connection, mode: u8) VoidCookie; - pub extern fn xcb_set_access_control(c: ?*Connection, mode: u8) VoidCookie; - pub extern fn xcb_set_close_down_mode_checked(c: ?*Connection, mode: u8) VoidCookie; - pub extern fn xcb_set_close_down_mode(c: ?*Connection, mode: u8) VoidCookie; - pub extern fn xcb_kill_client_checked(c: ?*Connection, resource: u32) VoidCookie; - pub extern fn xcb_kill_client(c: ?*Connection, resource: u32) VoidCookie; + pub extern fn xcb_list_hosts_reply(c: *Connection, cookie: ListHostsCookie, e: ?*?*GenericError) ?*ListHostsReply; + pub extern fn xcb_set_access_control_checked(c: *Connection, mode: u8) VoidCookie; + pub extern fn xcb_set_access_control(c: *Connection, mode: u8) VoidCookie; + pub extern fn xcb_set_close_down_mode_checked(c: *Connection, mode: u8) VoidCookie; + pub extern fn xcb_set_close_down_mode(c: *Connection, mode: u8) VoidCookie; + pub extern fn xcb_kill_client_checked(c: *Connection, resource: u32) VoidCookie; + pub extern fn xcb_kill_client(c: *Connection, resource: u32) VoidCookie; pub extern fn xcb_rotate_properties_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_rotate_properties_checked(c: ?*Connection, window: Window, atoms_len: u16, delta: i16, atoms: [*c]const Atom) VoidCookie; - pub extern fn xcb_rotate_properties(c: ?*Connection, window: Window, atoms_len: u16, delta: i16, atoms: [*c]const Atom) VoidCookie; + pub extern fn xcb_rotate_properties_checked(c: *Connection, window: Window, atoms_len: u16, delta: i16, atoms: [*c]const Atom) VoidCookie; + pub extern fn xcb_rotate_properties(c: *Connection, window: Window, atoms_len: u16, delta: i16, atoms: [*c]const Atom) VoidCookie; pub extern fn xcb_rotate_properties_atoms(R: *const RotatePropertiesRequest) [*c]Atom; pub extern fn xcb_rotate_properties_atoms_length(R: *const RotatePropertiesRequest) c_int; pub extern fn xcb_rotate_properties_atoms_end(R: *const RotatePropertiesRequest) GenericIterator; - pub extern fn xcb_force_screen_saver_checked(c: ?*Connection, mode: u8) VoidCookie; - pub extern fn xcb_force_screen_saver(c: ?*Connection, mode: u8) VoidCookie; + pub extern fn xcb_force_screen_saver_checked(c: *Connection, mode: u8) VoidCookie; + pub extern fn xcb_force_screen_saver(c: *Connection, mode: u8) VoidCookie; pub extern fn xcb_set_pointer_mapping_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_set_pointer_mapping(c: ?*Connection, map_len: u8, map: [*c]const u8) SetPointerMappingCookie; - pub extern fn xcb_set_pointer_mapping_unchecked(c: ?*Connection, map_len: u8, map: [*c]const u8) SetPointerMappingCookie; - pub extern fn xcb_set_pointer_mapping_reply(c: ?*Connection, cookie: SetPointerMappingCookie, e: [*c][*c]GenericError) [*c]SetPointerMappingReply; + pub extern fn xcb_set_pointer_mapping(c: *Connection, map_len: u8, map: [*c]const u8) SetPointerMappingCookie; + pub extern fn xcb_set_pointer_mapping_unchecked(c: *Connection, map_len: u8, map: [*c]const u8) SetPointerMappingCookie; + pub extern fn xcb_set_pointer_mapping_reply(c: *Connection, cookie: SetPointerMappingCookie, e: ?*?*GenericError) ?*SetPointerMappingReply; pub extern fn xcb_get_pointer_mapping_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_get_pointer_mapping(c: ?*Connection) GetPointerMappingCookie; - pub extern fn xcb_get_pointer_mapping_unchecked(c: ?*Connection) GetPointerMappingCookie; + pub extern fn xcb_get_pointer_mapping(c: *Connection) GetPointerMappingCookie; + pub extern fn xcb_get_pointer_mapping_unchecked(c: *Connection) GetPointerMappingCookie; pub extern fn xcb_get_pointer_mapping_map(R: *const GetPointerMappingReply) [*c]u8; pub extern fn xcb_get_pointer_mapping_map_length(R: *const GetPointerMappingReply) c_int; pub extern fn xcb_get_pointer_mapping_map_end(R: *const GetPointerMappingReply) GenericIterator; - pub extern fn xcb_get_pointer_mapping_reply(c: ?*Connection, cookie: GetPointerMappingCookie, e: [*c][*c]GenericError) [*c]GetPointerMappingReply; + pub extern fn xcb_get_pointer_mapping_reply(c: *Connection, cookie: GetPointerMappingCookie, e: ?*?*GenericError) ?*GetPointerMappingReply; pub extern fn xcb_set_modifier_mapping_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_set_modifier_mapping(c: ?*Connection, keycodes_per_modifier: u8, keycodes: [*c]const Keycode) SetModifierMappingCookie; - pub extern fn xcb_set_modifier_mapping_unchecked(c: ?*Connection, keycodes_per_modifier: u8, keycodes: [*c]const Keycode) SetModifierMappingCookie; - pub extern fn xcb_set_modifier_mapping_reply(c: ?*Connection, cookie: SetModifierMappingCookie, e: [*c][*c]GenericError) [*c]SetModifierMappingReply; + pub extern fn xcb_set_modifier_mapping(c: *Connection, keycodes_per_modifier: u8, keycodes: [*c]const Keycode) SetModifierMappingCookie; + pub extern fn xcb_set_modifier_mapping_unchecked(c: *Connection, keycodes_per_modifier: u8, keycodes: [*c]const Keycode) SetModifierMappingCookie; + pub extern fn xcb_set_modifier_mapping_reply(c: *Connection, cookie: SetModifierMappingCookie, e: ?*?*GenericError) ?*SetModifierMappingReply; pub extern fn xcb_get_modifier_mapping_sizeof(_buffer: ?*const anyopaque) c_int; - pub extern fn xcb_get_modifier_mapping(c: ?*Connection) GetModifierMappingCookie; - pub extern fn xcb_get_modifier_mapping_unchecked(c: ?*Connection) GetModifierMappingCookie; + pub extern fn xcb_get_modifier_mapping(c: *Connection) GetModifierMappingCookie; + pub extern fn xcb_get_modifier_mapping_unchecked(c: *Connection) GetModifierMappingCookie; pub extern fn xcb_get_modifier_mapping_keycodes(R: *const GetModifierMappingReply) [*c]Keycode; pub extern fn xcb_get_modifier_mapping_keycodes_length(R: *const GetModifierMappingReply) c_int; pub extern fn xcb_get_modifier_mapping_keycodes_end(R: *const GetModifierMappingReply) GenericIterator; - pub extern fn xcb_get_modifier_mapping_reply(c: ?*Connection, cookie: GetModifierMappingCookie, e: [*c][*c]GenericError) [*c]GetModifierMappingReply; - pub extern fn xcb_no_operation_checked(c: ?*Connection) VoidCookie; - pub extern fn xcb_no_operation(c: ?*Connection) VoidCookie; - pub extern fn xcb_flush(c: ?*Connection) c_int; - pub extern fn xcb_get_maximum_request_length(c: ?*Connection) u32; - pub extern fn xcb_prefetch_maximum_request_length(c: ?*Connection) void; - pub extern fn xcb_wait_for_event(c: ?*Connection) [*c]GenericEvent; - pub extern fn xcb_poll_for_event(c: ?*Connection) [*c]GenericEvent; - pub extern fn xcb_poll_for_queued_event(c: ?*Connection) [*c]GenericEvent; - pub extern fn xcb_poll_for_special_event(c: ?*Connection, se: ?*SpecialEvent) [*c]GenericEvent; - pub extern fn xcb_wait_for_special_event(c: ?*Connection, se: ?*SpecialEvent) [*c]GenericEvent; - pub extern fn xcb_register_for_special_xge(c: ?*Connection, ext: ?*Extension, eid: u32, stamp: [*c]u32) ?*SpecialEvent; - pub extern fn xcb_unregister_for_special_event(c: ?*Connection, se: ?*SpecialEvent) void; - pub extern fn xcb_request_check(c: ?*Connection, cookie: VoidCookie) [*c]GenericError; - pub extern fn xcb_discard_reply(c: ?*Connection, sequence: c_uint) void; - pub extern fn xcb_discard_reply64(c: ?*Connection, sequence: u64) void; - pub extern fn xcb_get_extension_data(c: ?*Connection, ext: ?*Extension) [*c]const QueryExtensionReply; - pub extern fn xcb_prefetch_extension_data(c: ?*Connection, ext: ?*Extension) void; - pub extern fn xcb_get_setup(c: ?*Connection) [*c]const Setup; - pub extern fn xcb_get_file_descriptor(c: ?*Connection) c_int; - pub extern fn xcb_connection_has_error(c: ?*Connection) c_int; - pub extern fn xcb_connect_to_fd(fd: c_int, auth_info: [*c]AuthInfo) ?*Connection; - pub extern fn xcb_disconnect(c: ?*Connection) void; + pub extern fn xcb_get_modifier_mapping_reply(c: *Connection, cookie: GetModifierMappingCookie, e: ?*?*GenericError) ?*GetModifierMappingReply; + pub extern fn xcb_no_operation_checked(c: *Connection) VoidCookie; + pub extern fn xcb_no_operation(c: *Connection) VoidCookie; + pub extern fn xcb_flush(c: *Connection) c_int; + pub extern fn xcb_get_maximum_request_length(c: *Connection) u32; + pub extern fn xcb_prefetch_maximum_request_length(c: *Connection) void; + pub extern fn xcb_wait_for_event(c: *Connection) ?*GenericEvent; + pub extern fn xcb_poll_for_event(c: *Connection) ?*GenericEvent; + pub extern fn xcb_poll_for_queued_event(c: *Connection) ?*GenericEvent; + pub extern fn xcb_poll_for_special_event(c: *Connection, se: ?*SpecialEvent) ?*GenericEvent; + pub extern fn xcb_wait_for_special_event(c: *Connection, se: ?*SpecialEvent) ?*GenericEvent; + pub extern fn xcb_register_for_special_xge(c: *Connection, ext: ?*Extension, eid: u32, stamp: [*c]u32) ?*SpecialEvent; + pub extern fn xcb_unregister_for_special_event(c: *Connection, se: ?*SpecialEvent) void; + pub extern fn xcb_request_check(c: *Connection, cookie: VoidCookie) [*c]GenericError; + pub extern fn xcb_discard_reply(c: *Connection, sequence: c_uint) void; + pub extern fn xcb_discard_reply64(c: *Connection, sequence: u64) void; + pub extern fn xcb_get_extension_data(c: *Connection, ext: ?*Extension) [*c]const QueryExtensionReply; + pub extern fn xcb_prefetch_extension_data(c: *Connection, ext: ?*Extension) void; + pub extern fn xcb_get_setup(c: *Connection) *const Setup; + pub extern fn xcb_get_file_descriptor(c: *Connection) c_int; + pub extern fn xcb_connection_has_error(c: *Connection) c_int; + pub extern fn xcb_connect_to_fd(fd: c_int, auth_info: ?*AuthInfo) *Connection; + pub extern fn xcb_disconnect(c: *Connection) void; pub extern fn xcb_parse_display(name: [*c]const u8, host: [*c][*c]u8, display: [*c]c_int, screen: [*c]c_int) c_int; - pub extern fn xcb_connect(displayname: [*c]const u8, screenp: [*c]c_int) *Connection; - pub extern fn xcb_connect_to_display_with_auth_info(display: [*c]const u8, auth: [*c]AuthInfo, screen: [*c]c_int) ?*Connection; - pub extern fn xcb_generate_id(c: ?*Connection) u32; - pub extern fn xcb_total_read(c: ?*Connection) u64; - pub extern fn xcb_total_written(c: ?*Connection) u64; + pub extern fn xcb_connect(displayname: ?[*:0]const u8, screenp: ?*c_int) *Connection; + pub extern fn xcb_connect_to_display_with_auth_info(display: ?[*:0]const u8, auth: ?*AuthInfo, screen: ?*c_int) *Connection; + pub extern fn xcb_generate_id(c: *Connection) u32; + pub extern fn xcb_total_read(c: *Connection) u64; + pub extern fn xcb_total_written(c: *Connection) u64; }; test "refAllDecls" {