diff --git a/src/3rdparty/wayland/extensions/qtkey-extension.xml b/src/3rdparty/wayland/extensions/qtkey-extension.xml index fc4d14dac8c..e90c331902a 100644 --- a/src/3rdparty/wayland/extensions/qtkey-extension.xml +++ b/src/3rdparty/wayland/extensions/qtkey-extension.xml @@ -1,4 +1,4 @@ - + Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies). diff --git a/src/3rdparty/wayland/extensions/windowmanager.xml b/src/3rdparty/wayland/extensions/windowmanager.xml index 71fb2723952..4d789e51a46 100644 --- a/src/3rdparty/wayland/extensions/windowmanager.xml +++ b/src/3rdparty/wayland/extensions/windowmanager.xml @@ -1,4 +1,4 @@ - + Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies). diff --git a/src/3rdparty/wayland/protocols/README b/src/3rdparty/wayland/protocols/README new file mode 100644 index 00000000000..d37bad09f63 --- /dev/null +++ b/src/3rdparty/wayland/protocols/README @@ -0,0 +1 @@ +wayland.xml from wayland version defined in qtwayland/README diff --git a/src/3rdparty/wayland/protocols/wayland.xml b/src/3rdparty/wayland/protocols/wayland.xml new file mode 100644 index 00000000000..cc8fb063fb6 --- /dev/null +++ b/src/3rdparty/wayland/protocols/wayland.xml @@ -0,0 +1,1332 @@ + + + + + Copyright © 2008-2011 Kristian Høgsberg + Copyright © 2010-2011 Intel Corporation + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that copyright notice and this permission + notice appear in supporting documentation, and that the name of + the copyright holders not be used in advertising or publicity + pertaining to distribution of the software without specific, + written prior permission. The copyright holders make no + representations about the suitability of this software for any + purpose. It is provided "as is" without express or implied + warranty. + + THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS + SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY + SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, + ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + THIS SOFTWARE. + + + + + The core global object. This is a special singleton object. It + is used for internal Wayland protocol features. + + + + + The sync request asks the server to emit the 'done' event + on the provided wl_callback object. Since requests are + handled in-order, this can be used as a barrier to ensure all + previous requests have been handled. + + + + + + + This request creates a registry object that allows the client + to list and bind the global objects available from the + compositor. + + + + + + + The error event is sent out when a fatal (non-recoverable) + error has occurred. The @object_id argument is the object + where the error occurred, most often in response to a request + to that object. The @code identifies the error and is defined + by the object interface. As such, each interface defines its + own set of error codes. The @message is an brief description + of the error, for (debugging) convenience. + + + + + + + + + These errors are global and can be emitted in response to any + server request. + + + + + + + + + This event is used internally by the object ID management + logic. When a client deletes an object, the server will send + this event to acknowledge that it has seen the delete request. + When the client receive this event, it will know that it can + safely reuse the object ID + + + + + + + + The global registry object. The server has a number of global + objects that are available to all clients. These objects + typically represent an actual object in the server (for example, + an input device) or they are singleton objects that provides + extension functionality. + + When a client creates a registry object, the registry object + will emit a global event for each global currently in the + registry. Globals come and go as a result of device hotplugs, + reconfiguration or other events, and the registry will send out + @global and @global_remove events to keep the client up to date + with the changes. To mark the end of the initial burst of + events, the client can use the wl_display.sync request + immediately after calling wl_display.get_registry. + + A client can 'bind' to a global object by using the bind + request. This creates a client side handle that lets the object + emit events to the client and lets the client invoke requests on + the object. + + + + + Binds a new, client-created object to the server using @name as + the identifier. + + + + + + + + Notify the client of global objects. + + + + + + + + + Notify the client of removed global objects. This event + notifies the client that the global identifies by @name is no + longer available. If the client bound to the global using the + 'bind' request, the client should now destroy that object. + The object remains valid and requests to the object will be + ignored until the client destroys it, to avoid races between + the global going away and a client sending a request to it. + + + + + + + + + + + + + + A compositor. This object is a singleton global. The + compositor is in charge of combining the contents of multiple + surfaces into one displayable output. + + + + + Ask the compositor to create a new surface. + + + + + + + Ask the compositor to create a new region. + + + + + + + + The wl_shm_pool object encapsulates a piece of memory shared + between the compositor and client. Through the wl_shm_pool + object, the client can allocate shared memory wl_buffer objects. + The objects will share the same underlying mapped memory. + Reusing the mapped memory avoids the setup/teardown overhead and + is useful when interactively resizing a surface or for many + small buffers. + + + + + Create a wl_buffer from the pool. The buffer is created a + offset bytes into the pool and has width and height as + specified. The stride arguments specifies the number of bytes + from beginning of one row to the beginning of the next. The + format is the pixel format of the buffer and must be one of + those advertised through the wl_shm.format event. + + A buffer will keep a reference to the pool it was created from + so it is valid to destroy the pool immediately after creating + a buffer from it. + + + + + + + + + + + + + Destroy the pool. + + + + + + This request will cause the server to remap the backing memory + for the pool from the fd passed when the pool was creating but + using the new size. + + + + + + + + + Support for shared memory buffers. + + + + + + + + + + + + + + + + This creates wl_shm_pool object, which can be used to create + shared memory based wl_buffer objects. The server will mmap + size bytes of the passed fd, to use as backing memory for then + pool. + + + + + + + + + + + + + + + A buffer provides the content for a wl_surface. Buffers are + created through factory interfaces such as wl_drm, wl_shm or + similar. It has a width and a height and can be attached to a + wl_surface, but the mechanism by which a client provides and + updates the contents is defined by the buffer factory interface. + + + + + Destroy a buffer. If and how you need to release the backing + storage is defined by the buffer factory interface. + + For possible side-effects to a surface, see wl_surface.attach. + + + + + + Sent when this wl_buffer is no longer used by the compositor. + The client is now free to re-use or destroy this buffer and its + backing storage. + + If a client receives a release event before the frame callback + requested in the same wl_surface.commit that attaches this + wl_buffer to a surface, then the client is immediately free to + re-use the buffer and its backing storage, and does not need a + second buffer for the next surface content update. Typically + this is possible, when the compositor maintains a copy of the + wl_surface contents, e.g. as a GL texture. This is an important + optimization for GL(ES) compositors with wl_shm clients. + + + + + + + + A wl_data_offer represents a piece of data offered for transfer + by another client (the source client). It is used by the + copy-and-paste and drag-and-drop mechanisms. The offer + describes the different mime types that the data can be + converted to and provides the mechanism for transferring the + data directly from the source client. + + + + + Indicate that the client can accept the given mime-type, or + NULL for not accepted. Use for feedback during drag and drop. + + + + + + + + + To transfer the offered data, the client issues this request + and indicates the mime-type it wants to receive. The transfer + happens through the passed fd (typically a pipe(7) file + descriptor). The source client writes the data in the + mime-type representation requested and then closes the fd. + The receiving client reads from the read end of the pipe until + EOF and the closes its end, at which point the transfer is + complete. + + + + + + + + + + Sent immediately after creating the wl_data_offer object. One + event per offered mime type. + + + + + + + + + The wl_data_source object is the source side of a wl_data_offer. + It is created by the source client in a data transfer and + provides a way to describe the offered data and a way to respond + to requests to transfer the data. + + + + + This request adds a mime-type to the set of mime-types + advertised to targets. Can be called several times to offer + multiple types. + + + + + + + Destroy the data source. + + + + + + Sent when a target accepts pointer_focus or motion events. If + a target does not accept any of the offered types, type is NULL. + + + + + + + + Request for data from another client. Send the data as the + specified mime-type over the passed fd, then close the fd. + + + + + + + + + This data source has been replaced by another data source. + The client should clean up and destroy this data source. + + + + + + + + + This request asks the compositor to start a drag and drop + operation on behalf of the client. + + The source argument is the data source that provides the data + for the eventual data transfer. If source is NULL, enter, leave + and motion events are sent only to the client that initiated the + drag and the client is expected to handle the data passing + internally. + + The origin surface is the surface where the drag originates and + the client must have an active implicit grab that matches the + serial. + + The icon surface is an optional (can be nil) surface that + provides an icon to be moved around with the cursor. Initially, + the top-left corner of the icon surface is placed at the cursor + hotspot, but subsequent wl_surface.attach request can move the + relative position. Attach requests must be confirmed with + wl_surface.commit as usual. + + The current and pending input regions of the icon wl_surface are + cleared, and wl_surface.set_input_region is ignored until the + wl_surface is no longer used as the icon surface. When the use + as an icon ends, the the current and pending input regions + become undefined, and the wl_surface is unmapped. + + + + + + + + + + + + + + + The data_offer event introduces a new wl_data_offer object, + which will subsequently be used in either the + data_device.enter event (for drag and drop) or the + data_device.selection event (for selections). Immediately + following the data_device_data_offer event, the new data_offer + object will send out data_offer.offer events to describe the + mime-types it offers. + + + + + + + + This event is sent when an active drag-and-drop pointer enters + a surface owned by the client. The position of the pointer at + enter time is provided by the @x an @y arguments, in surface + local coordinates. + + + + + + + + + + + + This event is sent when the drag-and-drop pointer leaves the + surface and the session ends. The client must destroy the + wl_data_offer introduced at enter time at this point. + + + + + + This event is sent when the drag-and-drop pointer moves within + the currently focused surface. The new position of the pointer + is provided by the @x an @y arguments, in surface local + coordinates. + + + + + + + + + + + The selection event is sent out to notify the client of a new + wl_data_offer for the selection for this device. The + data_device.data_offer and the data_offer.offer events are + sent out immediately before this event to introduce the data + offer object. The selection event is sent to a client + immediately before receiving keyboard focus and when a new + selection is set while the client has keyboard focus. The + data_offer is valid until a new data_offer or NULL is received + or until the client loses keyboard focus. + + + + + + + + The wl_data_device_manager is a a singleton global object that + provides access to inter-client data transfer mechanisms such as + copy and paste and drag and drop. These mechanisms are tied to + a wl_seat and this interface lets a client get a wl_data_device + corresponding to a wl_seat. + + + + + + + + + + + + + + + + + + + + + + + An interface implemented by a wl_surface. On server side the + object is automatically destroyed when the related wl_surface is + destroyed. On client side, wl_shell_surface_destroy() must be + called before destroying the wl_surface object. + + + + + A client must respond to a ping event with a pong request or + the client may be deemed unresponsive. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Make the surface a toplevel window. + + + + + + + + + + Map the surface relative to an existing surface. The x and y + arguments specify the locations of the upper left corner of + the surface relative to the upper left corner of the parent + surface. The flags argument controls overflow/clipping + behaviour when the surface would intersect a screen edge, + panel or such. And possibly whether the offset only + determines the initial position or if the surface is locked to + that relative position during moves. + + + + + + + + + + + Map the surface as a fullscreen surface. If an output parameter is + given then the surface will be made fullscreen on that output. If the + client does not specify the output then the compositor will apply its + policy - usually choosing the output on which the surface has the + biggest surface area. + + The client may specify a method to resolve a size conflict between the + output size and the surface size - this is provided through the + fullscreen_method parameter. + + The framerate parameter is used only when the fullscreen_method is set + to "driver", to indicate the preferred framerate. framerate=0 indicates + that the app does not care about framerate. The framerate is + specified in mHz, that is framerate of 60000 is 60Hz. + + The compositor must reply to this request with a configure event with + the dimensions for the output on which the surface will be made fullscreen. + + + + + + + + + Hints to indicate compositor how to deal with a conflict between the + dimensions for the surface and the dimensions of the output. As a hint + the compositor is free to ignore this parameter. + + "default" The client has no preference on fullscreen behavior, + policies are determined by compositor. + + "scale" The client prefers scaling by the compositor. Scaling would + always preserve surface's aspect ratio with surface centered on the + output + + "driver" The client wants to switch video mode to the smallest mode + that can fit the client buffer. If the sizes do not match the + compositor must add black borders. + + "fill" The surface is centered on the output on the screen with no + scaling. If the surface is of insufficient size the compositor must + add black borders. + + + + + + + + + + Popup surfaces. Will switch an implicit grab into + owner-events mode, and grab will continue after the implicit + grab ends (button released). Once the implicit grab is over, + the popup grab continues until the window is destroyed or a + mouse button is pressed in any other clients window. A click + in any of the clients surfaces is reported as normal, however, + clicks in other clients surfaces will be discarded and trigger + the callback. + + TODO: Grab keyboard too, maybe just terminate on any click + inside or outside the surface? + + + + + + + + + + + + + A request from the client to notify the compositor the maximized + operation. The compositor will reply with a configure event telling + the expected new surface size. The operation is completed on the + next buffer attach to this surface. + A maximized client will fill the fullscreen of the output it is bound + to, except the panel area. This is the main difference between + a maximized shell surface and a fullscreen shell surface. + + + + + + + + + + + + + The surface class identifies the general class of applications + to which the surface belongs. The class is the file name of + the applications .desktop file (absolute path if non-standard + location). + + + + + + + Ping a client to check if it is receiving events and sending + requests. A client is expected to reply with a pong request. + + + + + + + The configure event asks the client to resize its surface. + The size is a hint, in the sense that the client is free to + ignore it if it doesn't resize, pick a smaller size (to + satisfy aspect ratio or resize in steps of NxM pixels). The + client is free to dismiss all but the last configure event it + received. + + + + + + + + + + The popup_done event is sent out when a popup grab is broken, + that is, when the users clicks a surface that doesn't belong + to the client owning the popup surface. + + + + + + + A surface. This is an image that is displayed on the screen. + It has a location, size and pixel contents. + + + + + Deletes the surface and invalidates its object id. + + + + + + Set the contents of a buffer into this surface. The x and y + arguments specify the location of the new pending buffer's upper + left corner, relative to the current buffer's upper left corner. In + other words, the x and y, and the width and height of the wl_buffer + together define in which directions the surface's size changes. + + Surface contents are double-buffered state, see wl_surface.commit. + + The initial surface contents are void; there is no content. + wl_surface.attach assigns the given wl_buffer as the pending wl_buffer. + wl_surface.commit applies the pending wl_buffer as the new + surface contents, and the size of the surface becomes the size of + the wl_buffer. The wl_buffer is also kept as pending, until + changed by wl_surface.attach or the wl_buffer is destroyed. + + Committing a pending wl_buffer allows the compositor to read the + pixels in the wl_buffer. The compositor may access the pixels at any + time after the wl_surface.commit request. When the compositor will + not access the pixels anymore, it will send the wl_buffer.release + event. Only after receiving wl_buffer.release, the client may re-use + the wl_buffer. A wl_buffer, that has been attached and then replaced + by another attach instead of committed, will not receive a release + event, and is not used by the compositor. + + Destroying the wl_buffer after wl_buffer.release does not change the + surface contents, even if the wl_buffer is still pending for the + next commit. In such case, the next commit does not change the + surface contents. However, if the client destroys the wl_buffer + before receiving wl_buffer.release, the surface contents become + undefined immediately. + + Only if wl_surface.attach is sent with a nil wl_buffer, the + following wl_surface.commit will remove the surface content. + + + + + + + + + + This request is used to describe the regions where the pending + buffer (or if pending buffer is none, the current buffer as updated + in-place) on the next wl_surface.commit will be different from the + current buffer, and needs to be repainted. The pending buffer can be + set by wl_surface.attach. The compositor ignores the parts of the + damage that fall outside of the surface. + + Damage is double-buffered state, see wl_surface.commit. + + The initial value for pending damage is empty: no damage. + wl_surface.damage adds pending damage: the new pending damage is the + union of old pending damage and the given rectangle. + wl_surface.commit assigns pending damage as the current damage, and + clears pending damage. The server will clear the current damage as + it repaints the surface. + + + + + + + + + + + Request notification when the next frame is displayed. Useful + for throttling redrawing operations, and driving animations. + The frame request will take effect on the next wl_surface.commit. + The notification will only be posted for one frame unless + requested again. + + A server should avoid signalling the frame callbacks if the + surface is not visible in any way, e.g. the surface is off-screen, + or completely obscured by other opaque surfaces. + + A client can request a frame callback even without an attach, + damage, or any other state changes. wl_surface.commit triggers a + display update, so the callback event will arrive after the next + output refresh where the surface is visible. + + + + + + + + This request sets the region of the surface that contains + opaque content. The opaque region is an optimization hint for + the compositor that lets it optimize out redrawing of content + behind opaque regions. Setting an opaque region is not + required for correct behaviour, but marking transparent + content as opaque will result in repaint artifacts. + The compositor ignores the parts of the opaque region that fall + outside of the surface. + + Opaque region is double-buffered state, see wl_surface.commit. + + wl_surface.set_opaque_region changes the pending opaque region. + wl_surface.commit copies the pending region to the current region. + Otherwise the pending and current regions are never changed. + + The initial value for opaque region is empty. Setting the pending + opaque region has copy semantics, and the wl_region object can be + destroyed immediately. A nil wl_region causes the pending opaque + region to be set to empty. + + + + + + + + This request sets the region of the surface that can receive + pointer and touch events. Input events happening outside of + this region will try the next surface in the server surface + stack. The compositor ignores the parts of the input region that + fall outside of the surface. + + Input region is double-buffered state, see wl_surface.commit. + + wl_surface.set_input_region changes the pending input region. + wl_surface.commit copies the pending region to the current region. + Otherwise the pending and current regions are never changed, + except cursor and icon surfaces are special cases, see + wl_pointer.set_cursor and wl_data_device.start_drag. + + The initial value for input region is infinite. That means the whole + surface will accept input. Setting the pending input region has copy + semantics, and the wl_region object can be destroyed immediately. A + nil wl_region causes the input region to be set to infinite. + + + + + + + + Surface state (input, opaque, and damage regions, attached buffers, + etc.) is double-buffered. Protocol requests modify the pending + state, as opposed to current state in use by the compositor. Commit + request atomically applies all pending state, replacing the current + state. After commit, the new pending state is as documented for each + related request. + + On commit, a pending wl_buffer is applied first, all other state + second. This means that all coordinates in double-buffered state are + relative to the new wl_buffer coming into use, except for + wl_surface.attach itself. If the pending wl_buffer is none, the + coordinates are relative to the current surface contents. + + All requests that need a commit to become effective are documented + to affect double-buffered state. + + Other interfaces may add further double-buffered surface state. + + + + + + This is emitted whenever a surface's creation, movement, or resizing + results in some part of it being within the scanout region of an + output. + + + + + + + This is emitted whenever a surface's creation, movement, or resizing + results in it no longer having any part of it within the scanout region + of an output. + + + + + + + + A group of keyboards, pointer (mice, for example) and touch + devices . This object is published as a global during start up, + or when such a device is hot plugged. A seat typically has a + pointer and maintains a keyboard_focus and a pointer_focus. + + + + + This is a bitmask of capabilities this seat has; if a member is + set, then it is present on the seat. + + + + + + + + + + This is emitted whenever a seat gains or loses the pointer, + keyboard or touch capabilities. The argument is a wl_seat_caps_mask + enum containing the complete set of capabilities this seat has. + + + + + + + The ID provided will be initialized to the wl_pointer interface + for this seat. + + + + + + + The ID provided will be initialized to the wl_keyboard interface + for this seat. + + + + + + + The ID provided will be initialized to the wl_touch interface + for this seat. + + + + + + + + + Set the pointer surface, i.e., the surface that contains the + pointer image (cursor). This request only takes effect if the pointer + focus for this device is one of the requesting client's surfaces + or the surface parameter is the current pointer surface. If + there was a previous surface set with this request it is + replaced. If surface is NULL, the pointer image is hidden. + + The parameters hotspot_x and hotspot_y define the position of + the pointer surface relative to the pointer location. Its + top-left corner is always at (x, y) - (hotspot_x, hotspot_y), + where (x, y) are the coordinates of the pointer location. + + On surface.attach requests to the pointer surface, hotspot_x + and hotspot_y are decremented by the x and y parameters + passed to the request. Attach must be confirmed by + wl_surface.commit as usual. + + The hotspot can also be updated by passing the currently set + pointer surface to this request with new values for hotspot_x + and hotspot_y. + + The current and pending input regions of the wl_surface are + cleared, and wl_surface.set_input_region is ignored until the + wl_surface is no longer used as the cursor. When the use as a + cursor ends, the current and pending input regions become + undefined, and the wl_surface is unmapped. + + + + + + + + + + + Notification that this seat's pointer is focused on a certain + surface. When an seat's focus enters a surface, the pointer image + is undefined and a client should respond to this event by setting + an appropriate pointer image. + + + + + + + + + + + + + + + + + + Notification of pointer location change. The arguments surface_[xy] + are the location relative to the focused surface. + + + + + + + + + + Describes the physical state of a button which provoked the button + event. + + + + + + + + Mouse button click and release notifications. The location + of the click is given by the last motion or pointer_focus event. + + + + + + + + + + + + + + + + + Scroll and other axis notifications. + + For scroll events (vertical and horizontal scroll axes), the + value parameter is the length of a vector along the specified + axis in a coordinate space identical to those of motion events, + representing a relative movement along the specified axis. + + For devices that support movements non-parallel to axes multiple + axis events will be emitted. + + When applicable, for example for touch pads, the server can + choose to emit scroll events where the motion vector is + equivalent to a motion event vector. + + When applicable, clients can transform its view relative to the + scroll distance. + + + + + + + + + + + + + + + This enum specifies the format of the keymap provided to the client + with the wl_keyboard::keymap event. + + + + + + + This event provides a file descriptor to the client which can be + memory-mapped to provide a keyboard mapping description. + + + + + + + + + + + + + + + + + + + + Describes the physical state of a key which provoked the key event. + + + + + + + + A key was pressed or released. + + + + + + + + + + + Notifies clients that the modifier and/or group state has + changed, and it should update its local state. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates the end of a contact point list. + + + + + + Sent if the compositor decides the touch stream is a global + gesture. No further events are sent to the clients from that + particular gesture. + + + + + + + + An output describes part of the compositor geometry. The + compositor work in the 'compositor coordinate system' and an + output corresponds to rectangular area in that space that is + actually visible. This typically corresponds to a monitor that + displays part of the compositor space. This object is published + as global during start up, or when a screen is hot plugged. + + + + + + + + + + + + + + This describes the transform that a compositor will apply to a + surface to compensate for the rotation or mirroring of an + output device. + + The flipped values correspond to an initial flip around a + vertical axis followed by rotation. + + The purpose is mainly to allow clients render accordingly and + tell the compositor, so that for fullscreen surfaces, the + compositor will still be able to scan out directly from client + surfaces. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The mode event describes an available mode for the output. + The event is sent when binding to the output object and there + will always be one mode, the current mode. The event is sent + again if an output changes mode, for the mode that is now + current. In other words, the current mode is always the last + mode that was received with the current flag set. + + + + + + + + + + + Region. + + + + + Destroy the region. This will invalidate the object id. + + + + + + Add the specified rectangle to the region + + + + + + + + + + + Subtract the specified rectangle from the region + + + + + + + + + + + diff --git a/src/tools/qtwaylandscanner/qtwaylandscanner.cpp b/src/tools/qtwaylandscanner/qtwaylandscanner.cpp index 86fc4937cb4..fe91b796b11 100644 --- a/src/tools/qtwaylandscanner/qtwaylandscanner.cpp +++ b/src/tools/qtwaylandscanner/qtwaylandscanner.cpp @@ -593,10 +593,7 @@ void process(QXmlStreamReader &xml) printf(" void %s::bind_func(struct ::wl_client *client, void *data, uint32_t version, uint32_t id)\n", interfaceName); printf(" {\n"); printf(" Q_UNUSED(version);\n"); - printf(" %s *that = static_cast<%s *>(data);\n", interfaceName, interfaceName); - printf(" Resource *resource = that->bind(client, id);\n"); - printf(" resource->handle->destroy = destroy_func;\n"); - printf(" that->%s_bind_resource(resource);\n", interfaceNameStripped); + printf(" static_cast<%s *>(data)->bind(client, id);\n", interfaceName); printf(" }\n"); printf("\n"); @@ -622,6 +619,8 @@ void process(QXmlStreamReader &xml) printf(" resource->handle = wl_client_add_object(client, &::%s_interface, &m_%s_interface, id, resource);\n", interfaceName, interfaceName); else printf(" resource->handle = wl_client_add_object(client, &::%s_interface, 0, id, resource);\n", interfaceName); + printf(" resource->handle->destroy = destroy_func;\n"); + printf(" %s_bind_resource(resource);\n", interfaceNameStripped); printf(" wl_list_init(&resource->handle->link);\n"); printf(" return resource;\n"); printf(" }\n");