+#include "wayland-client.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_xdg_shell_unstable_v6 The xdg_shell_unstable_v6 protocol
+ * @section page_ifaces_xdg_shell_unstable_v6 Interfaces
+ * - @subpage page_iface_zxdg_shell_v6 - create desktop-style surfaces
+ * - @subpage page_iface_zxdg_positioner_v6 - child surface positioner
+ * - @subpage page_iface_zxdg_surface_v6 - desktop user interface surface base interface
+ * - @subpage page_iface_zxdg_toplevel_v6 - toplevel surface
+ * - @subpage page_iface_zxdg_popup_v6 - short-lived, popup surfaces for menus
+ * @section page_copyright_xdg_shell_unstable_v6 Copyright
+ *
+ *
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013 Rafael Antognolli
+ * Copyright © 2013 Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+struct wl_output;
+struct wl_seat;
+struct wl_surface;
+struct zxdg_popup_v6;
+struct zxdg_positioner_v6;
+struct zxdg_shell_v6;
+struct zxdg_surface_v6;
+struct zxdg_toplevel_v6;
+
+/**
+ * @page page_iface_zxdg_shell_v6 zxdg_shell_v6
+ * @section page_iface_zxdg_shell_v6_desc Description
+ *
+ * xdg_shell allows clients to turn a wl_surface into a "real window"
+ * which can be dragged, resized, stacked, and moved around by the
+ * user. Everything about this interface is suited towards traditional
+ * desktop environments.
+ * @section page_iface_zxdg_shell_v6_api API
+ * See @ref iface_zxdg_shell_v6.
+ */
+/**
+ * @defgroup iface_zxdg_shell_v6 The zxdg_shell_v6 interface
+ *
+ * xdg_shell allows clients to turn a wl_surface into a "real window"
+ * which can be dragged, resized, stacked, and moved around by the
+ * user. Everything about this interface is suited towards traditional
+ * desktop environments.
+ */
+extern const struct wl_interface zxdg_shell_v6_interface;
+/**
+ * @page page_iface_zxdg_positioner_v6 zxdg_positioner_v6
+ * @section page_iface_zxdg_positioner_v6_desc Description
+ *
+ * The xdg_positioner provides a collection of rules for the placement of a
+ * child surface relative to a parent surface. Rules can be defined to ensure
+ * the child surface remains within the visible area's borders, and to
+ * specify how the child surface changes its position, such as sliding along
+ * an axis, or flipping around a rectangle.
+ *
+ * See the various requests for details about possible rules.
+ *
+ * At the time of the request, the compositor makes a copy of the rules
+ * specified by the xdg_positioner. Thus, after the request is complete the
+ * xdg_positioner object can be destroyed or reused; further changes to the
+ * object will have no effect on previous usages.
+ *
+ * For an xdg_positioner object to be considered complete, it must have a
+ * non-zero size set by set_size, and a non-zero anchor rectangle set by
+ * set_anchor_rect. Passing an incomplete xdg_positioner object when
+ * positioning a surface raises an error.
+ * @section page_iface_zxdg_positioner_v6_api API
+ * See @ref iface_zxdg_positioner_v6.
+ */
+/**
+ * @defgroup iface_zxdg_positioner_v6 The zxdg_positioner_v6 interface
+ *
+ * The xdg_positioner provides a collection of rules for the placement of a
+ * child surface relative to a parent surface. Rules can be defined to ensure
+ * the child surface remains within the visible area's borders, and to
+ * specify how the child surface changes its position, such as sliding along
+ * an axis, or flipping around a rectangle.
+ *
+ * See the various requests for details about possible rules.
+ *
+ * At the time of the request, the compositor makes a copy of the rules
+ * specified by the xdg_positioner. Thus, after the request is complete the
+ * xdg_positioner object can be destroyed or reused; further changes to the
+ * object will have no effect on previous usages.
+ *
+ * For an xdg_positioner object to be considered complete, it must have a
+ * non-zero size set by set_size, and a non-zero anchor rectangle set by
+ * set_anchor_rect. Passing an incomplete xdg_positioner object when
+ * positioning a surface raises an error.
+ */
+extern const struct wl_interface zxdg_positioner_v6_interface;
+/**
+ * @page page_iface_zxdg_surface_v6 zxdg_surface_v6
+ * @section page_iface_zxdg_surface_v6_desc Description
+ *
+ * An interface that may be implemented by a wl_surface, for
+ * implementations that provide a desktop-style user interface.
+ *
+ * It provides a base set of functionality required to construct user
+ * interface elements requiring management by the compositor, such as
+ * toplevel windows, menus, etc. The types of functionality are split into
+ * xdg_surface roles.
+ *
+ * Creating an xdg_surface does not set the role for a wl_surface. In order
+ * to map an xdg_surface, the client must create a role-specific object
+ * using, e.g., get_toplevel, get_popup. The wl_surface for any given
+ * xdg_surface can have at most one role, and may not be assigned any role
+ * not based on xdg_surface.
+ *
+ * A role must be assigned before any other requests are made to the
+ * xdg_surface object.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_surface state to take effect.
+ *
+ * Creating an xdg_surface from a wl_surface which has a buffer attached or
+ * committed is a client error, and any attempts by a client to attach or
+ * manipulate a buffer prior to the first xdg_surface.configure call must
+ * also be treated as errors.
+ *
+ * For a surface to be mapped by the compositor, the following conditions
+ * must be met: (1) the client has assigned a xdg_surface based role to the
+ * surface, (2) the client has set and committed the xdg_surface state and
+ * the role dependent state to the surface and (3) the client has committed a
+ * buffer to the surface.
+ * @section page_iface_zxdg_surface_v6_api API
+ * See @ref iface_zxdg_surface_v6.
+ */
+/**
+ * @defgroup iface_zxdg_surface_v6 The zxdg_surface_v6 interface
+ *
+ * An interface that may be implemented by a wl_surface, for
+ * implementations that provide a desktop-style user interface.
+ *
+ * It provides a base set of functionality required to construct user
+ * interface elements requiring management by the compositor, such as
+ * toplevel windows, menus, etc. The types of functionality are split into
+ * xdg_surface roles.
+ *
+ * Creating an xdg_surface does not set the role for a wl_surface. In order
+ * to map an xdg_surface, the client must create a role-specific object
+ * using, e.g., get_toplevel, get_popup. The wl_surface for any given
+ * xdg_surface can have at most one role, and may not be assigned any role
+ * not based on xdg_surface.
+ *
+ * A role must be assigned before any other requests are made to the
+ * xdg_surface object.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_surface state to take effect.
+ *
+ * Creating an xdg_surface from a wl_surface which has a buffer attached or
+ * committed is a client error, and any attempts by a client to attach or
+ * manipulate a buffer prior to the first xdg_surface.configure call must
+ * also be treated as errors.
+ *
+ * For a surface to be mapped by the compositor, the following conditions
+ * must be met: (1) the client has assigned a xdg_surface based role to the
+ * surface, (2) the client has set and committed the xdg_surface state and
+ * the role dependent state to the surface and (3) the client has committed a
+ * buffer to the surface.
+ */
+extern const struct wl_interface zxdg_surface_v6_interface;
+/**
+ * @page page_iface_zxdg_toplevel_v6 zxdg_toplevel_v6
+ * @section page_iface_zxdg_toplevel_v6_desc Description
+ *
+ * This interface defines an xdg_surface role which allows a surface to,
+ * among other things, set window-like properties such as maximize,
+ * fullscreen, and minimize, set application-specific metadata like title and
+ * id, and well as trigger user interactive operations such as interactive
+ * resize and move.
+ * @section page_iface_zxdg_toplevel_v6_api API
+ * See @ref iface_zxdg_toplevel_v6.
+ */
+/**
+ * @defgroup iface_zxdg_toplevel_v6 The zxdg_toplevel_v6 interface
+ *
+ * This interface defines an xdg_surface role which allows a surface to,
+ * among other things, set window-like properties such as maximize,
+ * fullscreen, and minimize, set application-specific metadata like title and
+ * id, and well as trigger user interactive operations such as interactive
+ * resize and move.
+ */
+extern const struct wl_interface zxdg_toplevel_v6_interface;
+/**
+ * @page page_iface_zxdg_popup_v6 zxdg_popup_v6
+ * @section page_iface_zxdg_popup_v6_desc Description
+ *
+ * A popup surface is a short-lived, temporary surface. It can be used to
+ * implement for example menus, popovers, tooltips and other similar user
+ * interface concepts.
+ *
+ * A popup can be made to take an explicit grab. See xdg_popup.grab for
+ * details.
+ *
+ * When the popup is dismissed, a popup_done event will be sent out, and at
+ * the same time the surface will be unmapped. See the xdg_popup.popup_done
+ * event for details.
+ *
+ * Explicitly destroying the xdg_popup object will also dismiss the popup and
+ * unmap the surface. Clients that want to dismiss the popup when another
+ * surface of their own is clicked should dismiss the popup using the destroy
+ * request.
+ *
+ * The parent surface must have either the xdg_toplevel or xdg_popup surface
+ * role.
+ *
+ * A newly created xdg_popup will be stacked on top of all previously created
+ * xdg_popup surfaces associated with the same xdg_toplevel.
+ *
+ * The parent of an xdg_popup must be mapped (see the xdg_surface
+ * description) before the xdg_popup itself.
+ *
+ * The x and y arguments passed when creating the popup object specify
+ * where the top left of the popup should be placed, relative to the
+ * local surface coordinates of the parent surface. See
+ * xdg_surface.get_popup.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_popup state to take effect.
+ * @section page_iface_zxdg_popup_v6_api API
+ * See @ref iface_zxdg_popup_v6.
+ */
+/**
+ * @defgroup iface_zxdg_popup_v6 The zxdg_popup_v6 interface
+ *
+ * A popup surface is a short-lived, temporary surface. It can be used to
+ * implement for example menus, popovers, tooltips and other similar user
+ * interface concepts.
+ *
+ * A popup can be made to take an explicit grab. See xdg_popup.grab for
+ * details.
+ *
+ * When the popup is dismissed, a popup_done event will be sent out, and at
+ * the same time the surface will be unmapped. See the xdg_popup.popup_done
+ * event for details.
+ *
+ * Explicitly destroying the xdg_popup object will also dismiss the popup and
+ * unmap the surface. Clients that want to dismiss the popup when another
+ * surface of their own is clicked should dismiss the popup using the destroy
+ * request.
+ *
+ * The parent surface must have either the xdg_toplevel or xdg_popup surface
+ * role.
+ *
+ * A newly created xdg_popup will be stacked on top of all previously created
+ * xdg_popup surfaces associated with the same xdg_toplevel.
+ *
+ * The parent of an xdg_popup must be mapped (see the xdg_surface
+ * description) before the xdg_popup itself.
+ *
+ * The x and y arguments passed when creating the popup object specify
+ * where the top left of the popup should be placed, relative to the
+ * local surface coordinates of the parent surface. See
+ * xdg_surface.get_popup.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_popup state to take effect.
+ */
+extern const struct wl_interface zxdg_popup_v6_interface;
+
+#ifndef ZXDG_SHELL_V6_ERROR_ENUM
+#define ZXDG_SHELL_V6_ERROR_ENUM
+enum zxdg_shell_v6_error {
+ /**
+ * given wl_surface has another role
+ */
+ ZXDG_SHELL_V6_ERROR_ROLE = 0,
+ /**
+ * xdg_shell was destroyed before children
+ */
+ ZXDG_SHELL_V6_ERROR_DEFUNCT_SURFACES = 1,
+ /**
+ * the client tried to map or destroy a non-topmost popup
+ */
+ ZXDG_SHELL_V6_ERROR_NOT_THE_TOPMOST_POPUP = 2,
+ /**
+ * the client specified an invalid popup parent surface
+ */
+ ZXDG_SHELL_V6_ERROR_INVALID_POPUP_PARENT = 3,
+ /**
+ * the client provided an invalid surface state
+ */
+ ZXDG_SHELL_V6_ERROR_INVALID_SURFACE_STATE = 4,
+ /**
+ * the client provided an invalid positioner
+ */
+ ZXDG_SHELL_V6_ERROR_INVALID_POSITIONER = 5,
+};
+#endif /* ZXDG_SHELL_V6_ERROR_ENUM */
+
+/**
+ * @ingroup iface_zxdg_shell_v6
+ * @struct zxdg_shell_v6_listener
+ */
+struct zxdg_shell_v6_listener {
+ /**
+ * check if the client is alive
+ *
+ * The ping event asks the client if it's still alive. Pass the
+ * serial specified in the event back to the compositor by sending
+ * a "pong" request back with the specified serial. See
+ * xdg_shell.ping.
+ *
+ * Compositors can use this to determine if the client is still
+ * alive. It's unspecified what will happen if the client doesn't
+ * respond to the ping request, or in what timeframe. Clients
+ * should try to respond in a reasonable amount of time.
+ *
+ * A compositor is free to ping in any way it wants, but a client
+ * must always respond to any xdg_shell object it created.
+ * @param serial pass this to the pong request
+ */
+ void (*ping)(void *data,
+ struct zxdg_shell_v6 *zxdg_shell_v6,
+ uint32_t serial);
+};
+
+/**
+ * @ingroup zxdg_shell_v6_iface
+ */
+static inline int
+zxdg_shell_v6_add_listener(struct zxdg_shell_v6 *zxdg_shell_v6,
+ const struct zxdg_shell_v6_listener *listener, void *data)
+{
+ return wl_proxy_add_listener((struct wl_proxy *) zxdg_shell_v6,
+ (void (**)(void)) listener, data);
+}
+
+#define ZXDG_SHELL_V6_DESTROY 0
+#define ZXDG_SHELL_V6_CREATE_POSITIONER 1
+#define ZXDG_SHELL_V6_GET_XDG_SURFACE 2
+#define ZXDG_SHELL_V6_PONG 3
+
+/**
+ * @ingroup iface_zxdg_shell_v6
+ */
+#define ZXDG_SHELL_V6_PING_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_zxdg_shell_v6
+ */
+#define ZXDG_SHELL_V6_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_shell_v6
+ */
+#define ZXDG_SHELL_V6_CREATE_POSITIONER_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_shell_v6
+ */
+#define ZXDG_SHELL_V6_GET_XDG_SURFACE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_shell_v6
+ */
+#define ZXDG_SHELL_V6_PONG_SINCE_VERSION 1
+
+/** @ingroup iface_zxdg_shell_v6 */
+static inline void
+zxdg_shell_v6_set_user_data(struct zxdg_shell_v6 *zxdg_shell_v6, void *user_data)
+{
+ wl_proxy_set_user_data((struct wl_proxy *) zxdg_shell_v6, user_data);
+}
+
+/** @ingroup iface_zxdg_shell_v6 */
+static inline void *
+zxdg_shell_v6_get_user_data(struct zxdg_shell_v6 *zxdg_shell_v6)
+{
+ return wl_proxy_get_user_data((struct wl_proxy *) zxdg_shell_v6);
+}
+
+static inline uint32_t
+zxdg_shell_v6_get_version(struct zxdg_shell_v6 *zxdg_shell_v6)
+{
+ return wl_proxy_get_version((struct wl_proxy *) zxdg_shell_v6);
+}
+
+/**
+ * @ingroup iface_zxdg_shell_v6
+ *
+ * Destroy this xdg_shell object.
+ *
+ * Destroying a bound xdg_shell object while there are surfaces
+ * still alive created by this xdg_shell object instance is illegal
+ * and will result in a protocol error.
+ */
+static inline void
+zxdg_shell_v6_destroy(struct zxdg_shell_v6 *zxdg_shell_v6)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_shell_v6,
+ ZXDG_SHELL_V6_DESTROY);
+
+ wl_proxy_destroy((struct wl_proxy *) zxdg_shell_v6);
+}
+
+/**
+ * @ingroup iface_zxdg_shell_v6
+ *
+ * Create a positioner object. A positioner object is used to position
+ * surfaces relative to some parent surface. See the interface description
+ * and xdg_surface.get_popup for details.
+ */
+static inline struct zxdg_positioner_v6 *
+zxdg_shell_v6_create_positioner(struct zxdg_shell_v6 *zxdg_shell_v6)
+{
+ struct wl_proxy *id;
+
+ id = wl_proxy_marshal_constructor((struct wl_proxy *) zxdg_shell_v6,
+ ZXDG_SHELL_V6_CREATE_POSITIONER, &zxdg_positioner_v6_interface, NULL);
+
+ return (struct zxdg_positioner_v6 *) id;
+}
+
+/**
+ * @ingroup iface_zxdg_shell_v6
+ *
+ * This creates an xdg_surface for the given surface. While xdg_surface
+ * itself is not a role, the corresponding surface may only be assigned
+ * a role extending xdg_surface, such as xdg_toplevel or xdg_popup.
+ *
+ * This creates an xdg_surface for the given surface. An xdg_surface is
+ * used as basis to define a role to a given surface, such as xdg_toplevel
+ * or xdg_popup. It also manages functionality shared between xdg_surface
+ * based surface roles.
+ *
+ * See the documentation of xdg_surface for more details about what an
+ * xdg_surface is and how it is used.
+ */
+static inline struct zxdg_surface_v6 *
+zxdg_shell_v6_get_xdg_surface(struct zxdg_shell_v6 *zxdg_shell_v6, struct wl_surface *surface)
+{
+ struct wl_proxy *id;
+
+ id = wl_proxy_marshal_constructor((struct wl_proxy *) zxdg_shell_v6,
+ ZXDG_SHELL_V6_GET_XDG_SURFACE, &zxdg_surface_v6_interface, NULL, surface);
+
+ return (struct zxdg_surface_v6 *) id;
+}
+
+/**
+ * @ingroup iface_zxdg_shell_v6
+ *
+ * A client must respond to a ping event with a pong request or
+ * the client may be deemed unresponsive. See xdg_shell.ping.
+ */
+static inline void
+zxdg_shell_v6_pong(struct zxdg_shell_v6 *zxdg_shell_v6, uint32_t serial)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_shell_v6,
+ ZXDG_SHELL_V6_PONG, serial);
+}
+
+#ifndef ZXDG_POSITIONER_V6_ERROR_ENUM
+#define ZXDG_POSITIONER_V6_ERROR_ENUM
+enum zxdg_positioner_v6_error {
+ /**
+ * invalid input provided
+ */
+ ZXDG_POSITIONER_V6_ERROR_INVALID_INPUT = 0,
+};
+#endif /* ZXDG_POSITIONER_V6_ERROR_ENUM */
+
+#ifndef ZXDG_POSITIONER_V6_ANCHOR_ENUM
+#define ZXDG_POSITIONER_V6_ANCHOR_ENUM
+enum zxdg_positioner_v6_anchor {
+ /**
+ * the center of the anchor rectangle
+ */
+ ZXDG_POSITIONER_V6_ANCHOR_NONE = 0,
+ /**
+ * the top edge of the anchor rectangle
+ */
+ ZXDG_POSITIONER_V6_ANCHOR_TOP = 1,
+ /**
+ * the bottom edge of the anchor rectangle
+ */
+ ZXDG_POSITIONER_V6_ANCHOR_BOTTOM = 2,
+ /**
+ * the left edge of the anchor rectangle
+ */
+ ZXDG_POSITIONER_V6_ANCHOR_LEFT = 4,
+ /**
+ * the right edge of the anchor rectangle
+ */
+ ZXDG_POSITIONER_V6_ANCHOR_RIGHT = 8,
+};
+#endif /* ZXDG_POSITIONER_V6_ANCHOR_ENUM */
+
+#ifndef ZXDG_POSITIONER_V6_GRAVITY_ENUM
+#define ZXDG_POSITIONER_V6_GRAVITY_ENUM
+enum zxdg_positioner_v6_gravity {
+ /**
+ * center over the anchor edge
+ */
+ ZXDG_POSITIONER_V6_GRAVITY_NONE = 0,
+ /**
+ * position above the anchor edge
+ */
+ ZXDG_POSITIONER_V6_GRAVITY_TOP = 1,
+ /**
+ * position below the anchor edge
+ */
+ ZXDG_POSITIONER_V6_GRAVITY_BOTTOM = 2,
+ /**
+ * position to the left of the anchor edge
+ */
+ ZXDG_POSITIONER_V6_GRAVITY_LEFT = 4,
+ /**
+ * position to the right of the anchor edge
+ */
+ ZXDG_POSITIONER_V6_GRAVITY_RIGHT = 8,
+};
+#endif /* ZXDG_POSITIONER_V6_GRAVITY_ENUM */
+
+#ifndef ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_ENUM
+#define ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_ENUM
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ * vertically resize the surface
+ *
+ * Resize the surface vertically so that it is completely unconstrained.
+ */
+enum zxdg_positioner_v6_constraint_adjustment {
+ ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_NONE = 0,
+ ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_SLIDE_X = 1,
+ ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_SLIDE_Y = 2,
+ ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_FLIP_X = 4,
+ ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_FLIP_Y = 8,
+ ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_RESIZE_X = 16,
+ ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_RESIZE_Y = 32,
+};
+#endif /* ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_ENUM */
+
+#define ZXDG_POSITIONER_V6_DESTROY 0
+#define ZXDG_POSITIONER_V6_SET_SIZE 1
+#define ZXDG_POSITIONER_V6_SET_ANCHOR_RECT 2
+#define ZXDG_POSITIONER_V6_SET_ANCHOR 3
+#define ZXDG_POSITIONER_V6_SET_GRAVITY 4
+#define ZXDG_POSITIONER_V6_SET_CONSTRAINT_ADJUSTMENT 5
+#define ZXDG_POSITIONER_V6_SET_OFFSET 6
+
+
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ */
+#define ZXDG_POSITIONER_V6_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ */
+#define ZXDG_POSITIONER_V6_SET_SIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ */
+#define ZXDG_POSITIONER_V6_SET_ANCHOR_RECT_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ */
+#define ZXDG_POSITIONER_V6_SET_ANCHOR_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ */
+#define ZXDG_POSITIONER_V6_SET_GRAVITY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ */
+#define ZXDG_POSITIONER_V6_SET_CONSTRAINT_ADJUSTMENT_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ */
+#define ZXDG_POSITIONER_V6_SET_OFFSET_SINCE_VERSION 1
+
+/** @ingroup iface_zxdg_positioner_v6 */
+static inline void
+zxdg_positioner_v6_set_user_data(struct zxdg_positioner_v6 *zxdg_positioner_v6, void *user_data)
+{
+ wl_proxy_set_user_data((struct wl_proxy *) zxdg_positioner_v6, user_data);
+}
+
+/** @ingroup iface_zxdg_positioner_v6 */
+static inline void *
+zxdg_positioner_v6_get_user_data(struct zxdg_positioner_v6 *zxdg_positioner_v6)
+{
+ return wl_proxy_get_user_data((struct wl_proxy *) zxdg_positioner_v6);
+}
+
+static inline uint32_t
+zxdg_positioner_v6_get_version(struct zxdg_positioner_v6 *zxdg_positioner_v6)
+{
+ return wl_proxy_get_version((struct wl_proxy *) zxdg_positioner_v6);
+}
+
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ *
+ * Notify the compositor that the xdg_positioner will no longer be used.
+ */
+static inline void
+zxdg_positioner_v6_destroy(struct zxdg_positioner_v6 *zxdg_positioner_v6)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_positioner_v6,
+ ZXDG_POSITIONER_V6_DESTROY);
+
+ wl_proxy_destroy((struct wl_proxy *) zxdg_positioner_v6);
+}
+
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ *
+ * Set the size of the surface that is to be positioned with the positioner
+ * object. The size is in surface-local coordinates and corresponds to the
+ * window geometry. See xdg_surface.set_window_geometry.
+ *
+ * If a zero or negative size is set the invalid_input error is raised.
+ */
+static inline void
+zxdg_positioner_v6_set_size(struct zxdg_positioner_v6 *zxdg_positioner_v6, int32_t width, int32_t height)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_positioner_v6,
+ ZXDG_POSITIONER_V6_SET_SIZE, width, height);
+}
+
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ *
+ * Specify the anchor rectangle within the parent surface that the child
+ * surface will be placed relative to. The rectangle is relative to the
+ * window geometry as defined by xdg_surface.set_window_geometry of the
+ * parent surface. The rectangle must be at least 1x1 large.
+ *
+ * When the xdg_positioner object is used to position a child surface, the
+ * anchor rectangle may not extend outside the window geometry of the
+ * positioned child's parent surface.
+ *
+ * If a zero or negative size is set the invalid_input error is raised.
+ */
+static inline void
+zxdg_positioner_v6_set_anchor_rect(struct zxdg_positioner_v6 *zxdg_positioner_v6, int32_t x, int32_t y, int32_t width, int32_t height)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_positioner_v6,
+ ZXDG_POSITIONER_V6_SET_ANCHOR_RECT, x, y, width, height);
+}
+
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ *
+ * Defines a set of edges for the anchor rectangle. These are used to
+ * derive an anchor point that the child surface will be positioned
+ * relative to. If two orthogonal edges are specified (e.g. 'top' and
+ * 'left'), then the anchor point will be the intersection of the edges
+ * (e.g. the top left position of the rectangle); otherwise, the derived
+ * anchor point will be centered on the specified edge, or in the center of
+ * the anchor rectangle if no edge is specified.
+ *
+ * If two parallel anchor edges are specified (e.g. 'left' and 'right'),
+ * the invalid_input error is raised.
+ */
+static inline void
+zxdg_positioner_v6_set_anchor(struct zxdg_positioner_v6 *zxdg_positioner_v6, uint32_t anchor)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_positioner_v6,
+ ZXDG_POSITIONER_V6_SET_ANCHOR, anchor);
+}
+
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ *
+ * Defines in what direction a surface should be positioned, relative to
+ * the anchor point of the parent surface. If two orthogonal gravities are
+ * specified (e.g. 'bottom' and 'right'), then the child surface will be
+ * placed in the specified direction; otherwise, the child surface will be
+ * centered over the anchor point on any axis that had no gravity
+ * specified.
+ *
+ * If two parallel gravities are specified (e.g. 'left' and 'right'), the
+ * invalid_input error is raised.
+ */
+static inline void
+zxdg_positioner_v6_set_gravity(struct zxdg_positioner_v6 *zxdg_positioner_v6, uint32_t gravity)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_positioner_v6,
+ ZXDG_POSITIONER_V6_SET_GRAVITY, gravity);
+}
+
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ *
+ * Specify how the window should be positioned if the originally intended
+ * position caused the surface to be constrained, meaning at least
+ * partially outside positioning boundaries set by the compositor. The
+ * adjustment is set by constructing a bitmask describing the adjustment to
+ * be made when the surface is constrained on that axis.
+ *
+ * If no bit for one axis is set, the compositor will assume that the child
+ * surface should not change its position on that axis when constrained.
+ *
+ * If more than one bit for one axis is set, the order of how adjustments
+ * are applied is specified in the corresponding adjustment descriptions.
+ *
+ * The default adjustment is none.
+ */
+static inline void
+zxdg_positioner_v6_set_constraint_adjustment(struct zxdg_positioner_v6 *zxdg_positioner_v6, uint32_t constraint_adjustment)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_positioner_v6,
+ ZXDG_POSITIONER_V6_SET_CONSTRAINT_ADJUSTMENT, constraint_adjustment);
+}
+
+/**
+ * @ingroup iface_zxdg_positioner_v6
+ *
+ * Specify the surface position offset relative to the position of the
+ * anchor on the anchor rectangle and the anchor on the surface. For
+ * example if the anchor of the anchor rectangle is at (x, y), the surface
+ * has the gravity bottom|right, and the offset is (ox, oy), the calculated
+ * surface position will be (x + ox, y + oy). The offset position of the
+ * surface is the one used for constraint testing. See
+ * set_constraint_adjustment.
+ *
+ * An example use case is placing a popup menu on top of a user interface
+ * element, while aligning the user interface element of the parent surface
+ * with some user interface element placed somewhere in the popup surface.
+ */
+static inline void
+zxdg_positioner_v6_set_offset(struct zxdg_positioner_v6 *zxdg_positioner_v6, int32_t x, int32_t y)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_positioner_v6,
+ ZXDG_POSITIONER_V6_SET_OFFSET, x, y);
+}
+
+#ifndef ZXDG_SURFACE_V6_ERROR_ENUM
+#define ZXDG_SURFACE_V6_ERROR_ENUM
+enum zxdg_surface_v6_error {
+ ZXDG_SURFACE_V6_ERROR_NOT_CONSTRUCTED = 1,
+ ZXDG_SURFACE_V6_ERROR_ALREADY_CONSTRUCTED = 2,
+ ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER = 3,
+};
+#endif /* ZXDG_SURFACE_V6_ERROR_ENUM */
+
+/**
+ * @ingroup iface_zxdg_surface_v6
+ * @struct zxdg_surface_v6_listener
+ */
+struct zxdg_surface_v6_listener {
+ /**
+ * suggest a surface change
+ *
+ * The configure event marks the end of a configure sequence. A
+ * configure sequence is a set of one or more events configuring
+ * the state of the xdg_surface, including the final
+ * xdg_surface.configure event.
+ *
+ * Where applicable, xdg_surface surface roles will during a
+ * configure sequence extend this event as a latched state sent as
+ * events before the xdg_surface.configure event. Such events
+ * should be considered to make up a set of atomically applied
+ * configuration states, where the xdg_surface.configure commits
+ * the accumulated state.
+ *
+ * Clients should arrange their surface for the new states, and
+ * then send an ack_configure request with the serial sent in this
+ * configure event at some point before committing the new surface.
+ *
+ * If the client receives multiple configure events before it can
+ * respond to one, it is free to discard all but the last event it
+ * received.
+ * @param serial serial of the configure event
+ */
+ void (*configure)(void *data,
+ struct zxdg_surface_v6 *zxdg_surface_v6,
+ uint32_t serial);
+};
+
+/**
+ * @ingroup zxdg_surface_v6_iface
+ */
+static inline int
+zxdg_surface_v6_add_listener(struct zxdg_surface_v6 *zxdg_surface_v6,
+ const struct zxdg_surface_v6_listener *listener, void *data)
+{
+ return wl_proxy_add_listener((struct wl_proxy *) zxdg_surface_v6,
+ (void (**)(void)) listener, data);
+}
+
+#define ZXDG_SURFACE_V6_DESTROY 0
+#define ZXDG_SURFACE_V6_GET_TOPLEVEL 1
+#define ZXDG_SURFACE_V6_GET_POPUP 2
+#define ZXDG_SURFACE_V6_SET_WINDOW_GEOMETRY 3
+#define ZXDG_SURFACE_V6_ACK_CONFIGURE 4
+
+/**
+ * @ingroup iface_zxdg_surface_v6
+ */
+#define ZXDG_SURFACE_V6_CONFIGURE_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_zxdg_surface_v6
+ */
+#define ZXDG_SURFACE_V6_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_surface_v6
+ */
+#define ZXDG_SURFACE_V6_GET_TOPLEVEL_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_surface_v6
+ */
+#define ZXDG_SURFACE_V6_GET_POPUP_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_surface_v6
+ */
+#define ZXDG_SURFACE_V6_SET_WINDOW_GEOMETRY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_surface_v6
+ */
+#define ZXDG_SURFACE_V6_ACK_CONFIGURE_SINCE_VERSION 1
+
+/** @ingroup iface_zxdg_surface_v6 */
+static inline void
+zxdg_surface_v6_set_user_data(struct zxdg_surface_v6 *zxdg_surface_v6, void *user_data)
+{
+ wl_proxy_set_user_data((struct wl_proxy *) zxdg_surface_v6, user_data);
+}
+
+/** @ingroup iface_zxdg_surface_v6 */
+static inline void *
+zxdg_surface_v6_get_user_data(struct zxdg_surface_v6 *zxdg_surface_v6)
+{
+ return wl_proxy_get_user_data((struct wl_proxy *) zxdg_surface_v6);
+}
+
+static inline uint32_t
+zxdg_surface_v6_get_version(struct zxdg_surface_v6 *zxdg_surface_v6)
+{
+ return wl_proxy_get_version((struct wl_proxy *) zxdg_surface_v6);
+}
+
+/**
+ * @ingroup iface_zxdg_surface_v6
+ *
+ * Destroy the xdg_surface object. An xdg_surface must only be destroyed
+ * after its role object has been destroyed.
+ */
+static inline void
+zxdg_surface_v6_destroy(struct zxdg_surface_v6 *zxdg_surface_v6)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_surface_v6,
+ ZXDG_SURFACE_V6_DESTROY);
+
+ wl_proxy_destroy((struct wl_proxy *) zxdg_surface_v6);
+}
+
+/**
+ * @ingroup iface_zxdg_surface_v6
+ *
+ * This creates an xdg_toplevel object for the given xdg_surface and gives
+ * the associated wl_surface the xdg_toplevel role.
+ *
+ * See the documentation of xdg_toplevel for more details about what an
+ * xdg_toplevel is and how it is used.
+ */
+static inline struct zxdg_toplevel_v6 *
+zxdg_surface_v6_get_toplevel(struct zxdg_surface_v6 *zxdg_surface_v6)
+{
+ struct wl_proxy *id;
+
+ id = wl_proxy_marshal_constructor((struct wl_proxy *) zxdg_surface_v6,
+ ZXDG_SURFACE_V6_GET_TOPLEVEL, &zxdg_toplevel_v6_interface, NULL);
+
+ return (struct zxdg_toplevel_v6 *) id;
+}
+
+/**
+ * @ingroup iface_zxdg_surface_v6
+ *
+ * This creates an xdg_popup object for the given xdg_surface and gives the
+ * associated wl_surface the xdg_popup role.
+ *
+ * See the documentation of xdg_popup for more details about what an
+ * xdg_popup is and how it is used.
+ */
+static inline struct zxdg_popup_v6 *
+zxdg_surface_v6_get_popup(struct zxdg_surface_v6 *zxdg_surface_v6, struct zxdg_surface_v6 *parent, struct zxdg_positioner_v6 *positioner)
+{
+ struct wl_proxy *id;
+
+ id = wl_proxy_marshal_constructor((struct wl_proxy *) zxdg_surface_v6,
+ ZXDG_SURFACE_V6_GET_POPUP, &zxdg_popup_v6_interface, NULL, parent, positioner);
+
+ return (struct zxdg_popup_v6 *) id;
+}
+
+/**
+ * @ingroup iface_zxdg_surface_v6
+ *
+ * The window geometry of a surface is its "visible bounds" from the
+ * user's perspective. Client-side decorations often have invisible
+ * portions like drop-shadows which should be ignored for the
+ * purposes of aligning, placing and constraining windows.
+ *
+ * The window geometry is double buffered, and will be applied at the
+ * time wl_surface.commit of the corresponding wl_surface is called.
+ *
+ * Once the window geometry of the surface is set, it is not possible to
+ * unset it, and it will remain the same until set_window_geometry is
+ * called again, even if a new subsurface or buffer is attached.
+ *
+ * If never set, the value is the full bounds of the surface,
+ * including any subsurfaces. This updates dynamically on every
+ * commit. This unset is meant for extremely simple clients.
+ *
+ * The arguments are given in the surface-local coordinate space of
+ * the wl_surface associated with this xdg_surface.
+ *
+ * The width and height must be greater than zero. Setting an invalid size
+ * will raise an error. When applied, the effective window geometry will be
+ * the set window geometry clamped to the bounding rectangle of the
+ * combined geometry of the surface of the xdg_surface and the associated
+ * subsurfaces.
+ */
+static inline void
+zxdg_surface_v6_set_window_geometry(struct zxdg_surface_v6 *zxdg_surface_v6, int32_t x, int32_t y, int32_t width, int32_t height)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_surface_v6,
+ ZXDG_SURFACE_V6_SET_WINDOW_GEOMETRY, x, y, width, height);
+}
+
+/**
+ * @ingroup iface_zxdg_surface_v6
+ *
+ * When a configure event is received, if a client commits the
+ * surface in response to the configure event, then the client
+ * must make an ack_configure request sometime before the commit
+ * request, passing along the serial of the configure event.
+ *
+ * For instance, for toplevel surfaces the compositor might use this
+ * information to move a surface to the top left only when the client has
+ * drawn itself for the maximized or fullscreen state.
+ *
+ * If the client receives multiple configure events before it
+ * can respond to one, it only has to ack the last configure event.
+ *
+ * A client is not required to commit immediately after sending
+ * an ack_configure request - it may even ack_configure several times
+ * before its next surface commit.
+ *
+ * A client may send multiple ack_configure requests before committing, but
+ * only the last request sent before a commit indicates which configure
+ * event the client really is responding to.
+ */
+static inline void
+zxdg_surface_v6_ack_configure(struct zxdg_surface_v6 *zxdg_surface_v6, uint32_t serial)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_surface_v6,
+ ZXDG_SURFACE_V6_ACK_CONFIGURE, serial);
+}
+
+#ifndef ZXDG_TOPLEVEL_V6_RESIZE_EDGE_ENUM
+#define ZXDG_TOPLEVEL_V6_RESIZE_EDGE_ENUM
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ * edge values for resizing
+ *
+ * These values are used to indicate which edge of a surface
+ * is being dragged in a resize operation.
+ */
+enum zxdg_toplevel_v6_resize_edge {
+ ZXDG_TOPLEVEL_V6_RESIZE_EDGE_NONE = 0,
+ ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP = 1,
+ ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM = 2,
+ ZXDG_TOPLEVEL_V6_RESIZE_EDGE_LEFT = 4,
+ ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP_LEFT = 5,
+ ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM_LEFT = 6,
+ ZXDG_TOPLEVEL_V6_RESIZE_EDGE_RIGHT = 8,
+ ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP_RIGHT = 9,
+ ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM_RIGHT = 10,
+};
+#endif /* ZXDG_TOPLEVEL_V6_RESIZE_EDGE_ENUM */
+
+#ifndef ZXDG_TOPLEVEL_V6_STATE_ENUM
+#define ZXDG_TOPLEVEL_V6_STATE_ENUM
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ * the surface is now activated
+ *
+ * Client window decorations should be painted as if the window is
+ * active. Do not assume this means that the window actually has
+ * keyboard or pointer focus.
+ */
+enum zxdg_toplevel_v6_state {
+ /**
+ * the surface is maximized
+ */
+ ZXDG_TOPLEVEL_V6_STATE_MAXIMIZED = 1,
+ /**
+ * the surface is fullscreen
+ */
+ ZXDG_TOPLEVEL_V6_STATE_FULLSCREEN = 2,
+ /**
+ * the surface is being resized
+ */
+ ZXDG_TOPLEVEL_V6_STATE_RESIZING = 3,
+ /**
+ * the surface is now activated
+ */
+ ZXDG_TOPLEVEL_V6_STATE_ACTIVATED = 4,
+};
+#endif /* ZXDG_TOPLEVEL_V6_STATE_ENUM */
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ * @struct zxdg_toplevel_v6_listener
+ */
+struct zxdg_toplevel_v6_listener {
+ /**
+ * suggest a surface change
+ *
+ * This configure event asks the client to resize its toplevel
+ * surface or to change its state. The configured state should not
+ * be applied immediately. See xdg_surface.configure for details.
+ *
+ * The width and height arguments specify a hint to the window
+ * about how its surface should be resized in window geometry
+ * coordinates. See set_window_geometry.
+ *
+ * If the width or height arguments are zero, it means the client
+ * should decide its own window dimension. This may happen when the
+ * compositor need to configure the state of the surface but
+ * doesn't have any information about any previous or expected
+ * dimension.
+ *
+ * The states listed in the event specify how the width/height
+ * arguments should be interpreted, and possibly how it should be
+ * drawn.
+ *
+ * Clients must send an ack_configure in response to this event.
+ * See xdg_surface.configure and xdg_surface.ack_configure for
+ * details.
+ */
+ void (*configure)(void *data,
+ struct zxdg_toplevel_v6 *zxdg_toplevel_v6,
+ int32_t width,
+ int32_t height,
+ struct wl_array *states);
+ /**
+ * surface wants to be closed
+ *
+ * The close event is sent by the compositor when the user wants
+ * the surface to be closed. This should be equivalent to the user
+ * clicking the close button in client-side decorations, if your
+ * application has any...
+ *
+ * This is only a request that the user intends to close your
+ * window. The client may choose to ignore this request, or show a
+ * dialog to ask the user to save their data...
+ */
+ void (*close)(void *data,
+ struct zxdg_toplevel_v6 *zxdg_toplevel_v6);
+};
+
+/**
+ * @ingroup zxdg_toplevel_v6_iface
+ */
+static inline int
+zxdg_toplevel_v6_add_listener(struct zxdg_toplevel_v6 *zxdg_toplevel_v6,
+ const struct zxdg_toplevel_v6_listener *listener, void *data)
+{
+ return wl_proxy_add_listener((struct wl_proxy *) zxdg_toplevel_v6,
+ (void (**)(void)) listener, data);
+}
+
+#define ZXDG_TOPLEVEL_V6_DESTROY 0
+#define ZXDG_TOPLEVEL_V6_SET_PARENT 1
+#define ZXDG_TOPLEVEL_V6_SET_TITLE 2
+#define ZXDG_TOPLEVEL_V6_SET_APP_ID 3
+#define ZXDG_TOPLEVEL_V6_SHOW_WINDOW_MENU 4
+#define ZXDG_TOPLEVEL_V6_MOVE 5
+#define ZXDG_TOPLEVEL_V6_RESIZE 6
+#define ZXDG_TOPLEVEL_V6_SET_MAX_SIZE 7
+#define ZXDG_TOPLEVEL_V6_SET_MIN_SIZE 8
+#define ZXDG_TOPLEVEL_V6_SET_MAXIMIZED 9
+#define ZXDG_TOPLEVEL_V6_UNSET_MAXIMIZED 10
+#define ZXDG_TOPLEVEL_V6_SET_FULLSCREEN 11
+#define ZXDG_TOPLEVEL_V6_UNSET_FULLSCREEN 12
+#define ZXDG_TOPLEVEL_V6_SET_MINIMIZED 13
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_CONFIGURE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_CLOSE_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_SET_PARENT_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_SET_TITLE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_SET_APP_ID_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_SHOW_WINDOW_MENU_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_MOVE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_RESIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_SET_MAX_SIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_SET_MIN_SIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_SET_MAXIMIZED_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_UNSET_MAXIMIZED_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_SET_FULLSCREEN_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_UNSET_FULLSCREEN_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+#define ZXDG_TOPLEVEL_V6_SET_MINIMIZED_SINCE_VERSION 1
+
+/** @ingroup iface_zxdg_toplevel_v6 */
+static inline void
+zxdg_toplevel_v6_set_user_data(struct zxdg_toplevel_v6 *zxdg_toplevel_v6, void *user_data)
+{
+ wl_proxy_set_user_data((struct wl_proxy *) zxdg_toplevel_v6, user_data);
+}
+
+/** @ingroup iface_zxdg_toplevel_v6 */
+static inline void *
+zxdg_toplevel_v6_get_user_data(struct zxdg_toplevel_v6 *zxdg_toplevel_v6)
+{
+ return wl_proxy_get_user_data((struct wl_proxy *) zxdg_toplevel_v6);
+}
+
+static inline uint32_t
+zxdg_toplevel_v6_get_version(struct zxdg_toplevel_v6 *zxdg_toplevel_v6)
+{
+ return wl_proxy_get_version((struct wl_proxy *) zxdg_toplevel_v6);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Unmap and destroy the window. The window will be effectively
+ * hidden from the user's point of view, and all state like
+ * maximization, fullscreen, and so on, will be lost.
+ */
+static inline void
+zxdg_toplevel_v6_destroy(struct zxdg_toplevel_v6 *zxdg_toplevel_v6)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_DESTROY);
+
+ wl_proxy_destroy((struct wl_proxy *) zxdg_toplevel_v6);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Set the "parent" of this surface. This window should be stacked
+ * above a parent. The parent surface must be mapped as long as this
+ * surface is mapped.
+ *
+ * Parent windows should be set on dialogs, toolboxes, or other
+ * "auxiliary" surfaces, so that the parent is raised when the dialog
+ * is raised.
+ */
+static inline void
+zxdg_toplevel_v6_set_parent(struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct zxdg_toplevel_v6 *parent)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_SET_PARENT, parent);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Set a short title for the surface.
+ *
+ * This string may be used to identify the surface in a task bar,
+ * window list, or other user interface elements provided by the
+ * compositor.
+ *
+ * The string must be encoded in UTF-8.
+ */
+static inline void
+zxdg_toplevel_v6_set_title(struct zxdg_toplevel_v6 *zxdg_toplevel_v6, const char *title)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_SET_TITLE, title);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Set an application identifier for the surface.
+ *
+ * The app ID identifies the general class of applications to which
+ * the surface belongs. The compositor can use this to group multiple
+ * surfaces together, or to determine how to launch a new application.
+ *
+ * For D-Bus activatable applications, the app ID is used as the D-Bus
+ * service name.
+ *
+ * The compositor shell will try to group application surfaces together
+ * by their app ID. As a best practice, it is suggested to select app
+ * ID's that match the basename of the application's .desktop file.
+ * For example, "org.freedesktop.FooViewer" where the .desktop file is
+ * "org.freedesktop.FooViewer.desktop".
+ *
+ * See the desktop-entry specification [0] for more details on
+ * application identifiers and how they relate to well-known D-Bus
+ * names and .desktop files.
+ *
+ * [0] http://standards.freedesktop.org/desktop-entry-spec/
+ */
+static inline void
+zxdg_toplevel_v6_set_app_id(struct zxdg_toplevel_v6 *zxdg_toplevel_v6, const char *app_id)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_SET_APP_ID, app_id);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Clients implementing client-side decorations might want to show
+ * a context menu when right-clicking on the decorations, giving the
+ * user a menu that they can use to maximize or minimize the window.
+ *
+ * This request asks the compositor to pop up such a window menu at
+ * the given position, relative to the local surface coordinates of
+ * the parent surface. There are no guarantees as to what menu items
+ * the window menu contains.
+ *
+ * This request must be used in response to some sort of user action
+ * like a button press, key press, or touch down event.
+ */
+static inline void
+zxdg_toplevel_v6_show_window_menu(struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct wl_seat *seat, uint32_t serial, int32_t x, int32_t y)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_SHOW_WINDOW_MENU, seat, serial, x, y);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Start an interactive, user-driven move of the surface.
+ *
+ * This request must be used in response to some sort of user action
+ * like a button press, key press, or touch down event. The passed
+ * serial is used to determine the type of interactive move (touch,
+ * pointer, etc).
+ *
+ * The server may ignore move requests depending on the state of
+ * the surface (e.g. fullscreen or maximized), or if the passed serial
+ * is no longer valid.
+ *
+ * If triggered, the surface will lose the focus of the device
+ * (wl_pointer, wl_touch, etc) used for the move. It is up to the
+ * compositor to visually indicate that the move is taking place, such as
+ * updating a pointer cursor, during the move. There is no guarantee
+ * that the device focus will return when the move is completed.
+ */
+static inline void
+zxdg_toplevel_v6_move(struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct wl_seat *seat, uint32_t serial)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_MOVE, seat, serial);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Start a user-driven, interactive resize of the surface.
+ *
+ * This request must be used in response to some sort of user action
+ * like a button press, key press, or touch down event. The passed
+ * serial is used to determine the type of interactive resize (touch,
+ * pointer, etc).
+ *
+ * The server may ignore resize requests depending on the state of
+ * the surface (e.g. fullscreen or maximized).
+ *
+ * If triggered, the client will receive configure events with the
+ * "resize" state enum value and the expected sizes. See the "resize"
+ * enum value for more details about what is required. The client
+ * must also acknowledge configure events using "ack_configure". After
+ * the resize is completed, the client will receive another "configure"
+ * event without the resize state.
+ *
+ * If triggered, the surface also will lose the focus of the device
+ * (wl_pointer, wl_touch, etc) used for the resize. It is up to the
+ * compositor to visually indicate that the resize is taking place,
+ * such as updating a pointer cursor, during the resize. There is no
+ * guarantee that the device focus will return when the resize is
+ * completed.
+ *
+ * The edges parameter specifies how the surface should be resized,
+ * and is one of the values of the resize_edge enum. The compositor
+ * may use this information to update the surface position for
+ * example when dragging the top left corner. The compositor may also
+ * use this information to adapt its behavior, e.g. choose an
+ * appropriate cursor image.
+ */
+static inline void
+zxdg_toplevel_v6_resize(struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct wl_seat *seat, uint32_t serial, uint32_t edges)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_RESIZE, seat, serial, edges);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Set a maximum size for the window.
+ *
+ * The client can specify a maximum size so that the compositor does
+ * not try to configure the window beyond this size.
+ *
+ * The width and height arguments are in window geometry coordinates.
+ * See xdg_surface.set_window_geometry.
+ *
+ * Values set in this way are double-buffered. They will get applied
+ * on the next commit.
+ *
+ * The compositor can use this information to allow or disallow
+ * different states like maximize or fullscreen and draw accurate
+ * animations.
+ *
+ * Similarly, a tiling window manager may use this information to
+ * place and resize client windows in a more effective way.
+ *
+ * The client should not rely on the compositor to obey the maximum
+ * size. The compositor may decide to ignore the values set by the
+ * client and request a larger size.
+ *
+ * If never set, or a value of zero in the request, means that the
+ * client has no expected maximum size in the given dimension.
+ * As a result, a client wishing to reset the maximum size
+ * to an unspecified state can use zero for width and height in the
+ * request.
+ *
+ * Requesting a maximum size to be smaller than the minimum size of
+ * a surface is illegal and will result in a protocol error.
+ *
+ * The width and height must be greater than or equal to zero. Using
+ * strictly negative values for width and height will result in a
+ * protocol error.
+ */
+static inline void
+zxdg_toplevel_v6_set_max_size(struct zxdg_toplevel_v6 *zxdg_toplevel_v6, int32_t width, int32_t height)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_SET_MAX_SIZE, width, height);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Set a minimum size for the window.
+ *
+ * The client can specify a minimum size so that the compositor does
+ * not try to configure the window below this size.
+ *
+ * The width and height arguments are in window geometry coordinates.
+ * See xdg_surface.set_window_geometry.
+ *
+ * Values set in this way are double-buffered. They will get applied
+ * on the next commit.
+ *
+ * The compositor can use this information to allow or disallow
+ * different states like maximize or fullscreen and draw accurate
+ * animations.
+ *
+ * Similarly, a tiling window manager may use this information to
+ * place and resize client windows in a more effective way.
+ *
+ * The client should not rely on the compositor to obey the minimum
+ * size. The compositor may decide to ignore the values set by the
+ * client and request a smaller size.
+ *
+ * If never set, or a value of zero in the request, means that the
+ * client has no expected minimum size in the given dimension.
+ * As a result, a client wishing to reset the minimum size
+ * to an unspecified state can use zero for width and height in the
+ * request.
+ *
+ * Requesting a minimum size to be larger than the maximum size of
+ * a surface is illegal and will result in a protocol error.
+ *
+ * The width and height must be greater than or equal to zero. Using
+ * strictly negative values for width and height will result in a
+ * protocol error.
+ */
+static inline void
+zxdg_toplevel_v6_set_min_size(struct zxdg_toplevel_v6 *zxdg_toplevel_v6, int32_t width, int32_t height)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_SET_MIN_SIZE, width, height);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Maximize the surface.
+ *
+ * After requesting that the surface should be maximized, the compositor
+ * will respond by emitting a configure event with the "maximized" state
+ * and the required window geometry. The client should then update its
+ * content, drawing it in a maximized state, i.e. without shadow or other
+ * decoration outside of the window geometry. The client must also
+ * acknowledge the configure when committing the new content (see
+ * ack_configure).
+ *
+ * It is up to the compositor to decide how and where to maximize the
+ * surface, for example which output and what region of the screen should
+ * be used.
+ *
+ * If the surface was already maximized, the compositor will still emit
+ * a configure event with the "maximized" state.
+ */
+static inline void
+zxdg_toplevel_v6_set_maximized(struct zxdg_toplevel_v6 *zxdg_toplevel_v6)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_SET_MAXIMIZED);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Unmaximize the surface.
+ *
+ * After requesting that the surface should be unmaximized, the compositor
+ * will respond by emitting a configure event without the "maximized"
+ * state. If available, the compositor will include the window geometry
+ * dimensions the window had prior to being maximized in the configure
+ * request. The client must then update its content, drawing it in a
+ * regular state, i.e. potentially with shadow, etc. The client must also
+ * acknowledge the configure when committing the new content (see
+ * ack_configure).
+ *
+ * It is up to the compositor to position the surface after it was
+ * unmaximized; usually the position the surface had before maximizing, if
+ * applicable.
+ *
+ * If the surface was already not maximized, the compositor will still
+ * emit a configure event without the "maximized" state.
+ */
+static inline void
+zxdg_toplevel_v6_unset_maximized(struct zxdg_toplevel_v6 *zxdg_toplevel_v6)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_UNSET_MAXIMIZED);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Make the surface fullscreen.
+ *
+ * You can specify an output that you would prefer to be fullscreen.
+ * If this value is NULL, it's up to the compositor to choose which
+ * display will be used to map this surface.
+ *
+ * If the surface doesn't cover the whole output, the compositor will
+ * position the surface in the center of the output and compensate with
+ * black borders filling the rest of the output.
+ */
+static inline void
+zxdg_toplevel_v6_set_fullscreen(struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct wl_output *output)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_SET_FULLSCREEN, output);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ */
+static inline void
+zxdg_toplevel_v6_unset_fullscreen(struct zxdg_toplevel_v6 *zxdg_toplevel_v6)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_UNSET_FULLSCREEN);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_v6
+ *
+ * Request that the compositor minimize your surface. There is no
+ * way to know if the surface is currently minimized, nor is there
+ * any way to unset minimization on this surface.
+ *
+ * If you are looking to throttle redrawing when minimized, please
+ * instead use the wl_surface.frame event for this, as this will
+ * also work with live previews on windows in Alt-Tab, Expose or
+ * similar compositor features.
+ */
+static inline void
+zxdg_toplevel_v6_set_minimized(struct zxdg_toplevel_v6 *zxdg_toplevel_v6)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_v6,
+ ZXDG_TOPLEVEL_V6_SET_MINIMIZED);
+}
+
+#ifndef ZXDG_POPUP_V6_ERROR_ENUM
+#define ZXDG_POPUP_V6_ERROR_ENUM
+enum zxdg_popup_v6_error {
+ /**
+ * tried to grab after being mapped
+ */
+ ZXDG_POPUP_V6_ERROR_INVALID_GRAB = 0,
+};
+#endif /* ZXDG_POPUP_V6_ERROR_ENUM */
+
+/**
+ * @ingroup iface_zxdg_popup_v6
+ * @struct zxdg_popup_v6_listener
+ */
+struct zxdg_popup_v6_listener {
+ /**
+ * configure the popup surface
+ *
+ * This event asks the popup surface to configure itself given
+ * the configuration. The configured state should not be applied
+ * immediately. See xdg_surface.configure for details.
+ *
+ * The x and y arguments represent the position the popup was
+ * placed at given the xdg_positioner rule, relative to the upper
+ * left corner of the window geometry of the parent surface.
+ * @param x x position relative to parent surface window geometry
+ * @param y y position relative to parent surface window geometry
+ * @param width window geometry width
+ * @param height window geometry height
+ */
+ void (*configure)(void *data,
+ struct zxdg_popup_v6 *zxdg_popup_v6,
+ int32_t x,
+ int32_t y,
+ int32_t width,
+ int32_t height);
+ /**
+ * popup interaction is done
+ *
+ * The popup_done event is sent out when a popup is dismissed by
+ * the compositor. The client should destroy the xdg_popup object
+ * at this point.
+ */
+ void (*popup_done)(void *data,
+ struct zxdg_popup_v6 *zxdg_popup_v6);
+};
+
+/**
+ * @ingroup zxdg_popup_v6_iface
+ */
+static inline int
+zxdg_popup_v6_add_listener(struct zxdg_popup_v6 *zxdg_popup_v6,
+ const struct zxdg_popup_v6_listener *listener, void *data)
+{
+ return wl_proxy_add_listener((struct wl_proxy *) zxdg_popup_v6,
+ (void (**)(void)) listener, data);
+}
+
+#define ZXDG_POPUP_V6_DESTROY 0
+#define ZXDG_POPUP_V6_GRAB 1
+
+/**
+ * @ingroup iface_zxdg_popup_v6
+ */
+#define ZXDG_POPUP_V6_CONFIGURE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_popup_v6
+ */
+#define ZXDG_POPUP_V6_POPUP_DONE_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_zxdg_popup_v6
+ */
+#define ZXDG_POPUP_V6_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_popup_v6
+ */
+#define ZXDG_POPUP_V6_GRAB_SINCE_VERSION 1
+
+/** @ingroup iface_zxdg_popup_v6 */
+static inline void
+zxdg_popup_v6_set_user_data(struct zxdg_popup_v6 *zxdg_popup_v6, void *user_data)
+{
+ wl_proxy_set_user_data((struct wl_proxy *) zxdg_popup_v6, user_data);
+}
+
+/** @ingroup iface_zxdg_popup_v6 */
+static inline void *
+zxdg_popup_v6_get_user_data(struct zxdg_popup_v6 *zxdg_popup_v6)
+{
+ return wl_proxy_get_user_data((struct wl_proxy *) zxdg_popup_v6);
+}
+
+static inline uint32_t
+zxdg_popup_v6_get_version(struct zxdg_popup_v6 *zxdg_popup_v6)
+{
+ return wl_proxy_get_version((struct wl_proxy *) zxdg_popup_v6);
+}
+
+/**
+ * @ingroup iface_zxdg_popup_v6
+ *
+ * This destroys the popup. Explicitly destroying the xdg_popup
+ * object will also dismiss the popup, and unmap the surface.
+ *
+ * If this xdg_popup is not the "topmost" popup, a protocol error
+ * will be sent.
+ */
+static inline void
+zxdg_popup_v6_destroy(struct zxdg_popup_v6 *zxdg_popup_v6)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_popup_v6,
+ ZXDG_POPUP_V6_DESTROY);
+
+ wl_proxy_destroy((struct wl_proxy *) zxdg_popup_v6);
+}
+
+/**
+ * @ingroup iface_zxdg_popup_v6
+ *
+ * This request makes the created popup take an explicit grab. An explicit
+ * grab will be dismissed when the user dismisses the popup, or when the
+ * client destroys the xdg_popup. This can be done by the user clicking
+ * outside the surface, using the keyboard, or even locking the screen
+ * through closing the lid or a timeout.
+ *
+ * If the compositor denies the grab, the popup will be immediately
+ * dismissed.
+ *
+ * This request must be used in response to some sort of user action like a
+ * button press, key press, or touch down event. The serial number of the
+ * event should be passed as 'serial'.
+ *
+ * The parent of a grabbing popup must either be an xdg_toplevel surface or
+ * another xdg_popup with an explicit grab. If the parent is another
+ * xdg_popup it means that the popups are nested, with this popup now being
+ * the topmost popup.
+ *
+ * Nested popups must be destroyed in the reverse order they were created
+ * in, e.g. the only popup you are allowed to destroy at all times is the
+ * topmost one.
+ *
+ * When compositors choose to dismiss a popup, they may dismiss every
+ * nested grabbing popup as well. When a compositor dismisses popups, it
+ * will follow the same dismissing order as required from the client.
+ *
+ * The parent of a grabbing popup must either be another xdg_popup with an
+ * active explicit grab, or an xdg_popup or xdg_toplevel, if there are no
+ * explicit grabs already taken.
+ *
+ * If the topmost grabbing popup is destroyed, the grab will be returned to
+ * the parent of the popup, if that parent previously had an explicit grab.
+ *
+ * If the parent is a grabbing popup which has already been dismissed, this
+ * popup will be immediately dismissed. If the parent is a popup that did
+ * not take an explicit grab, an error will be raised.
+ *
+ * During a popup grab, the client owning the grab will receive pointer
+ * and touch events for all their surfaces as normal (similar to an
+ * "owner-events" grab in X11 parlance), while the top most grabbing popup
+ * will always have keyboard focus.
+ */
+static inline void
+zxdg_popup_v6_grab(struct zxdg_popup_v6 *zxdg_popup_v6, struct wl_seat *seat, uint32_t serial)
+{
+ wl_proxy_marshal((struct wl_proxy *) zxdg_popup_v6,
+ ZXDG_POPUP_V6_GRAB, seat, serial);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/irrlicht/source/Irrlicht/xdg-shell-unstable-v6-protocol.c b/lib/irrlicht/source/Irrlicht/xdg-shell-unstable-v6-protocol.c
new file mode 100644
index 000000000..f579993cf
--- /dev/null
+++ b/lib/irrlicht/source/Irrlicht/xdg-shell-unstable-v6-protocol.c
@@ -0,0 +1,162 @@
+/* Generated by wayland-scanner 1.12.0 */
+
+/*
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013 Rafael Antognolli
+ * Copyright © 2013 Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include
+#include
+#include "wayland-util.h"
+
+extern const struct wl_interface wl_output_interface;
+extern const struct wl_interface wl_seat_interface;
+extern const struct wl_interface wl_surface_interface;
+extern const struct wl_interface zxdg_popup_v6_interface;
+extern const struct wl_interface zxdg_positioner_v6_interface;
+extern const struct wl_interface zxdg_surface_v6_interface;
+extern const struct wl_interface zxdg_toplevel_v6_interface;
+
+static const struct wl_interface *types[] = {
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ &zxdg_positioner_v6_interface,
+ &zxdg_surface_v6_interface,
+ &wl_surface_interface,
+ &zxdg_toplevel_v6_interface,
+ &zxdg_popup_v6_interface,
+ &zxdg_surface_v6_interface,
+ &zxdg_positioner_v6_interface,
+ &zxdg_toplevel_v6_interface,
+ &wl_seat_interface,
+ NULL,
+ NULL,
+ NULL,
+ &wl_seat_interface,
+ NULL,
+ &wl_seat_interface,
+ NULL,
+ NULL,
+ &wl_output_interface,
+ &wl_seat_interface,
+ NULL,
+};
+
+static const struct wl_message zxdg_shell_v6_requests[] = {
+ { "destroy", "", types + 0 },
+ { "create_positioner", "n", types + 4 },
+ { "get_xdg_surface", "no", types + 5 },
+ { "pong", "u", types + 0 },
+};
+
+static const struct wl_message zxdg_shell_v6_events[] = {
+ { "ping", "u", types + 0 },
+};
+
+WL_EXPORT const struct wl_interface zxdg_shell_v6_interface = {
+ "zxdg_shell_v6", 1,
+ 4, zxdg_shell_v6_requests,
+ 1, zxdg_shell_v6_events,
+};
+
+static const struct wl_message zxdg_positioner_v6_requests[] = {
+ { "destroy", "", types + 0 },
+ { "set_size", "ii", types + 0 },
+ { "set_anchor_rect", "iiii", types + 0 },
+ { "set_anchor", "u", types + 0 },
+ { "set_gravity", "u", types + 0 },
+ { "set_constraint_adjustment", "u", types + 0 },
+ { "set_offset", "ii", types + 0 },
+};
+
+WL_EXPORT const struct wl_interface zxdg_positioner_v6_interface = {
+ "zxdg_positioner_v6", 1,
+ 7, zxdg_positioner_v6_requests,
+ 0, NULL,
+};
+
+static const struct wl_message zxdg_surface_v6_requests[] = {
+ { "destroy", "", types + 0 },
+ { "get_toplevel", "n", types + 7 },
+ { "get_popup", "noo", types + 8 },
+ { "set_window_geometry", "iiii", types + 0 },
+ { "ack_configure", "u", types + 0 },
+};
+
+static const struct wl_message zxdg_surface_v6_events[] = {
+ { "configure", "u", types + 0 },
+};
+
+WL_EXPORT const struct wl_interface zxdg_surface_v6_interface = {
+ "zxdg_surface_v6", 1,
+ 5, zxdg_surface_v6_requests,
+ 1, zxdg_surface_v6_events,
+};
+
+static const struct wl_message zxdg_toplevel_v6_requests[] = {
+ { "destroy", "", types + 0 },
+ { "set_parent", "?o", types + 11 },
+ { "set_title", "s", types + 0 },
+ { "set_app_id", "s", types + 0 },
+ { "show_window_menu", "ouii", types + 12 },
+ { "move", "ou", types + 16 },
+ { "resize", "ouu", types + 18 },
+ { "set_max_size", "ii", types + 0 },
+ { "set_min_size", "ii", types + 0 },
+ { "set_maximized", "", types + 0 },
+ { "unset_maximized", "", types + 0 },
+ { "set_fullscreen", "?o", types + 21 },
+ { "unset_fullscreen", "", types + 0 },
+ { "set_minimized", "", types + 0 },
+};
+
+static const struct wl_message zxdg_toplevel_v6_events[] = {
+ { "configure", "iia", types + 0 },
+ { "close", "", types + 0 },
+};
+
+WL_EXPORT const struct wl_interface zxdg_toplevel_v6_interface = {
+ "zxdg_toplevel_v6", 1,
+ 14, zxdg_toplevel_v6_requests,
+ 2, zxdg_toplevel_v6_events,
+};
+
+static const struct wl_message zxdg_popup_v6_requests[] = {
+ { "destroy", "", types + 0 },
+ { "grab", "ou", types + 22 },
+};
+
+static const struct wl_message zxdg_popup_v6_events[] = {
+ { "configure", "iiii", types + 0 },
+ { "popup_done", "", types + 0 },
+};
+
+WL_EXPORT const struct wl_interface zxdg_popup_v6_interface = {
+ "zxdg_popup_v6", 1,
+ 2, zxdg_popup_v6_requests,
+ 2, zxdg_popup_v6_events,
+};
+
diff --git a/sources.cmake b/sources.cmake
index d4f28ae4d..13db008ff 100644
--- a/sources.cmake
+++ b/sources.cmake
@@ -1,5 +1,5 @@
# Modify this file to change the last-modified date when you add/remove a file.
-# This will then trigger a new cmake run automatically.
+# This will then trigger a new cmake run automatically.
file(GLOB_RECURSE STK_HEADERS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "src/*.hpp")
file(GLOB_RECURSE STK_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "src/*.cpp")
file(GLOB_RECURSE STK_SHADERS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "data/shaders/*")
diff --git a/src/config/user_config.cpp b/src/config/user_config.cpp
index 79511fd2a..788efc0dc 100644
--- a/src/config/user_config.cpp
+++ b/src/config/user_config.cpp
@@ -321,7 +321,7 @@ core::stringc ListUserConfigParam::toString() const
return "";
} // toString
- // ============================================================================
+// ----------------------------------------------------------------------------
template
MapUserConfigParam::MapUserConfigParam(const char* param_name,
const char* comment)
@@ -331,7 +331,7 @@ MapUserConfigParam::MapUserConfigParam(const char* param_name,
if (comment != NULL) m_comment = comment;
} // MapUserConfigParam
- // ============================================================================
+// ----------------------------------------------------------------------------
template
MapUserConfigParam::MapUserConfigParam(const char* param_name,
const char* comment,
@@ -345,7 +345,7 @@ MapUserConfigParam::MapUserConfigParam(const char* param_name,
// add the default list
va_list arguments;
va_start(arguments, nb_elements);
-
+
struct pair_type { T key; U value; };
for (int i = 0; i < nb_elements; i++)
@@ -356,7 +356,7 @@ MapUserConfigParam::MapUserConfigParam(const char* param_name,
va_end(arguments); // Cleans up the list
} // MapUserConfigParam
- // ============================================================================
+// ----------------------------------------------------------------------------
template
MapUserConfigParam::MapUserConfigParam(const char* param_name,
GroupUserConfigParam* group,
@@ -367,7 +367,7 @@ MapUserConfigParam::MapUserConfigParam(const char* param_name,
if (comment != NULL) m_comment = comment;
} // MapUserConfigParam
- // ============================================================================
+// ----------------------------------------------------------------------------
template
MapUserConfigParam::MapUserConfigParam(const char* param_name,
GroupUserConfigParam* group,
@@ -382,30 +382,25 @@ MapUserConfigParam::MapUserConfigParam(const char* param_name,
// add the default list
va_list arguments;
va_start(arguments, nb_elements);
-
+
struct pair_type { T key; U value; };
- for (int i = 0; i < nb_elements; i++) {
+ for (int i = 0; i < nb_elements; i++)
+ {
pair_type key_value_pair = va_arg(arguments, pair_type);
m_elements.insert(std::pair(key_value_pair.key, key_value_pair.value));
}
va_end(arguments); // Cleans up the list
} // MapUserConfigParam
- // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
template
void MapUserConfigParam::write(std::ofstream& stream) const
{
- const int elts_amount = m_elements.size();
-
// comment
if (m_comment.size() > 0) stream << " \n <" << m_param_name.c_str() << "\n";
- stream << " Size=\"" << elts_amount << "\"\n";
- // actual elements
- //for (int n = 0; n::write(std::ofstream& stream) const
stream << " \n\n";
} // write
- // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
template
void MapUserConfigParam::findYourDataInAChildOf(const XMLNode* node)
@@ -425,56 +420,30 @@ void MapUserConfigParam::findYourDataInAChildOf(const XMLNode* node)
//Log::error("User Config", "Couldn't find parameter group %s", m_param_name.c_str());
return;
}
-
- int attr_count = 0;
- child->get("Size", &attr_count);
-
- for (const auto& kv : m_elements)
- {
- std::pair elt;
- elt.first = kv.first;
- elt.second = kv.second;
-
-
- bool there = false;
-
- for (const auto& kvRHS : m_elements)
- {
- if (elt.second == kvRHS.second)
- {
- there = true;
- break;
- }
-
- }
- if (!there)
- {
- m_elements.insert(elt);
- }
- }
+ child->get(&m_elements);
} // findYourDataInAChildOf
- // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
template
void MapUserConfigParam::findYourDataInAnAttributeOf(const XMLNode* node)
{
} // findYourDataInAnAttributeOf
- // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
template
void MapUserConfigParam::addElement(T element, U value)
{
m_elements[element] = value;
} // findYourDataInAnAttributeOf
- // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
template
core::stringc MapUserConfigParam::toString() const
{
return "";
} // toString
-// ============================================================================
+// ----------------------------------------------------------------------------
IntUserConfigParam::IntUserConfigParam(int default_value,
const char* param_name,
const char* comment)
diff --git a/src/graphics/command_buffer.cpp b/src/graphics/command_buffer.cpp
index 761ae122b..3c5e9762c 100644
--- a/src/graphics/command_buffer.cpp
+++ b/src/graphics/command_buffer.cpp
@@ -166,7 +166,6 @@ void SolidCommandBuffer::fill(MeshMap *mesh_map)
fillInstanceData
(mesh_map, four_tex_material_list, InstanceTypeFourTex);
-
if (!CVS->supportsAsyncInstanceUpload())
glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER);
} //SolidCommandBuffer::fill
diff --git a/src/graphics/command_buffer.hpp b/src/graphics/command_buffer.hpp
index 35021a8f4..2706b9239 100644
--- a/src/graphics/command_buffer.hpp
+++ b/src/graphics/command_buffer.hpp
@@ -218,7 +218,6 @@ protected:
mesh_map,
instance_buffer);
}
-
if (!CVS->supportsAsyncInstanceUpload())
{
glUnmapBuffer(GL_ARRAY_BUFFER);
diff --git a/src/graphics/glwrap.cpp b/src/graphics/glwrap.cpp
index e889ade21..9bbc9c002 100644
--- a/src/graphics/glwrap.cpp
+++ b/src/graphics/glwrap.cpp
@@ -160,6 +160,7 @@ void initGL()
{
if (is_gl_init)
return;
+
is_gl_init = true;
// For Mesa extension reporting
#if !defined(USE_GLES2)
@@ -167,8 +168,15 @@ void initGL()
glewExperimental = GL_TRUE;
#endif
GLenum err = glewInit();
- if (GLEW_OK != err)
- Log::fatal("GLEW", "Glew initialisation failed with error %s", glewGetErrorString(err));
+
+ if (err == GLEW_ERROR_NO_GLX_DISPLAY)
+ {
+ Log::info("GLEW", "Glew couldn't open glx display.");
+ }
+ else if (err != GLEW_OK)
+ {
+ Log::fatal("GLEW", "Glew initialization failed with error %s", glewGetErrorString(err));
+ }
#else
#ifdef ARB_DEBUG_OUTPUT
glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKKHRPROC)eglGetProcAddress("glDebugMessageCallbackKHR");
diff --git a/src/graphics/sp_mesh_loader.cpp b/src/graphics/sp_mesh_loader.cpp
index fec1a8e2c..57c1cd614 100644
--- a/src/graphics/sp_mesh_loader.cpp
+++ b/src/graphics/sp_mesh_loader.cpp
@@ -20,6 +20,7 @@
#include "utils/constants.hpp"
#include "utils/mini_glm.hpp"
+#include "../../lib/irrlicht/source/Irrlicht/CSkinnedMesh.h"
const uint8_t VERSION_NOW = 1;
#include
@@ -47,7 +48,7 @@ scene::IAnimatedMesh* SPMeshLoader::createMesh(io::IReadFile* f)
}
m_bind_frame = 0;
m_joint_count = 0;
- //m_frame_count = 0;
+ m_frame_count = 0;
m_mesh = NULL;
m_mesh = m_scene_manager->createSkinnedMesh();
io::IFileSystem* fs = m_scene_manager->getFileSystem();
@@ -196,6 +197,9 @@ scene::IAnimatedMesh* SPMeshLoader::createMesh(io::IReadFile* f)
f->read(&pre_computed_size, 2);
}
m_mesh->finalize();
+ // Because the last frame in spm is usable
+ static_cast(m_mesh)->AnimationFrames =
+ (float)m_frame_count + 1.0f;
m_all_armatures.clear();
m_to_bind_pose_matrices.clear();
m_joints.clear();
@@ -366,8 +370,8 @@ void SPMeshLoader::createAnimationData(irr::io::IReadFile* spm)
}
for (unsigned i = 0; i < armature_size; i++)
{
- //m_frame_count = std::max(m_frame_count,
- // (unsigned)m_all_armatures[i].m_frame_pose_matrices.back().first);
+ m_frame_count = std::max(m_frame_count,
+ (unsigned)m_all_armatures[i].m_frame_pose_matrices.back().first);
m_joint_count += m_all_armatures[i].m_joint_used;
}
diff --git a/src/graphics/sp_mesh_loader.hpp b/src/graphics/sp_mesh_loader.hpp
index 64e257bf8..55fc031ae 100644
--- a/src/graphics/sp_mesh_loader.hpp
+++ b/src/graphics/sp_mesh_loader.hpp
@@ -79,7 +79,7 @@ private:
unsigned id);
};
// ------------------------------------------------------------------------
- unsigned m_bind_frame, m_joint_count;//, m_frame_count;
+ unsigned m_bind_frame, m_joint_count, m_frame_count;
// ------------------------------------------------------------------------
std::vector m_all_armatures;
// ------------------------------------------------------------------------
diff --git a/src/guiengine/scalable_font.cpp b/src/guiengine/scalable_font.cpp
index 7173e177d..e106f1038 100644
--- a/src/guiengine/scalable_font.cpp
+++ b/src/guiengine/scalable_font.cpp
@@ -52,12 +52,16 @@ void ScalableFont::setShadow(const irr::video::SColor &col)
m_font_settings->setShadow(true);
m_font_settings->setShadowColor(col);
} // setShadow
-
// ----------------------------------------------------------------------------
void ScalableFont::disableShadow()
{
m_font_settings->setShadow(false);
} // setShadow
+// ----------------------------------------------------------------------------
+void ScalableFont::setBlackBorder(bool enabled)
+{
+ m_font_settings->setBlackBorder(enabled);
+} // setShadow
// ----------------------------------------------------------------------------
void ScalableFont::setScale(float scale)
diff --git a/src/guiengine/scalable_font.hpp b/src/guiengine/scalable_font.hpp
index 2f03508a8..d96164c2a 100644
--- a/src/guiengine/scalable_font.hpp
+++ b/src/guiengine/scalable_font.hpp
@@ -57,6 +57,8 @@ public:
// ------------------------------------------------------------------------
void disableShadow();
// ------------------------------------------------------------------------
+ void setBlackBorder(bool enabled);
+ // ------------------------------------------------------------------------
void updateRTL();
// ------------------------------------------------------------------------
void draw(const core::stringw& text, const core::rect& position,
diff --git a/src/input/gamepad_device.cpp b/src/input/gamepad_device.cpp
index 423c1894f..0ea8cfc0a 100644
--- a/src/input/gamepad_device.cpp
+++ b/src/input/gamepad_device.cpp
@@ -94,7 +94,10 @@ int GamePadDevice::getNumberOfButtons() const
// ----------------------------------------------------------------------------
bool GamePadDevice::isButtonPressed(const int i)
{
- return m_button_pressed[i];
+ if (i < m_button_pressed.size())
+ return m_button_pressed[i];
+ else
+ return false;
} // isButtonPressed
// ----------------------------------------------------------------------------
diff --git a/src/io/xml_node.cpp b/src/io/xml_node.cpp
index cbc8dc21a..12d38c1e7 100644
--- a/src/io/xml_node.cpp
+++ b/src/io/xml_node.cpp
@@ -18,7 +18,6 @@
#include "io/file_manager.hpp"
#include "io/xml_node.hpp"
-#include "utils/string_utils.hpp"
#include "utils/interpolation_array.hpp"
#include "utils/vec3.hpp"
diff --git a/src/io/xml_node.hpp b/src/io/xml_node.hpp
index ed990dab4..66baea9db 100644
--- a/src/io/xml_node.hpp
+++ b/src/io/xml_node.hpp
@@ -33,9 +33,11 @@ using namespace irr;
#include "utils/leak_check.hpp"
#include "utils/no_copy.hpp"
+#include "utils/string_utils.hpp"
#include "utils/time.hpp"
#include "utils/types.hpp"
+
class InterpolationArray;
class Vec3;
@@ -95,6 +97,27 @@ public:
int getHPR(core::vector3df *value) const;
int getHPR(Vec3 *value) const;
+ template
+ int get(std::map* out_map) const
+ {
+ using namespace StringUtils;
+ for (auto& p : m_attributes)
+ {
+ T val_1;
+ if (!fromString(p.first, val_1))
+ {
+ return 0;
+ }
+ U val_2;
+ if (!fromString(wideToUtf8(p.second), val_2))
+ {
+ return 0;
+ }
+ (*out_map)[val_1] = val_2;
+ }
+ return (int)m_attributes.size();
+ }
+
bool hasChildNamed(const char* name) const;
/** Handy functions to test the bit pattern returned by get(vector3df*).*/
diff --git a/src/items/attachment.cpp b/src/items/attachment.cpp
index b4b1dfd9f..1afd432d2 100644
--- a/src/items/attachment.cpp
+++ b/src/items/attachment.cpp
@@ -497,6 +497,28 @@ void Attachment::update(float dt)
bool is_shield = (m_type == ATTACH_BUBBLEGUM_SHIELD|| m_type == ATTACH_NOLOK_BUBBLEGUM_SHIELD);
float m_wanted_node_scale = is_shield ? std::max(1.0f, m_kart->getHighestPoint()*1.1f) : 1.0f;
+ int slow_flashes = 3;
+ if (is_shield && m_time_left < slow_flashes)
+ {
+ int flashes_per_second = 4;
+ int divisor = 2;
+
+ float fast_flashes = 0.5F;
+ if (m_time_left < fast_flashes)
+ {
+ flashes_per_second = 12;
+ }
+
+ float mod = (int)(m_time_left * flashes_per_second * 2) % divisor;
+ if (mod < divisor / 2)
+ {
+ m_node->setVisible(false);
+ }
+ else
+ {
+ m_node->setVisible(true);
+ }
+ }
if (m_node_scale < m_wanted_node_scale)
{
diff --git a/src/karts/controller/local_player_controller.cpp b/src/karts/controller/local_player_controller.cpp
index 2c8b96b47..55abba84f 100644
--- a/src/karts/controller/local_player_controller.cpp
+++ b/src/karts/controller/local_player_controller.cpp
@@ -239,9 +239,11 @@ void LocalPlayerController::displayPenaltyWarning()
if (m)
{
m->addMessage(_("Penalty time!!"), m_kart, 2.0f,
- GUIEngine::getSkin()->getColor("font::top"));
+ GUIEngine::getSkin()->getColor("font::top"), true /* important */,
+ false /* big font */, true /* outline */);
m->addMessage(_("Don't accelerate before go"), m_kart, 2.0f,
- GUIEngine::getSkin()->getColor("font::normal"));
+ GUIEngine::getSkin()->getColor("font::normal"), true /* important */,
+ false /* big font */, true /* outline */);
}
m_kart->playSound(m_bzzt_sound);
} // displayPenaltyWarning
diff --git a/src/karts/kart.cpp b/src/karts/kart.cpp
index 938273ad7..79edf6f93 100644
--- a/src/karts/kart.cpp
+++ b/src/karts/kart.cpp
@@ -2181,7 +2181,7 @@ void Kart::playCrashSFX(const Material* m, AbstractKart *k)
{
const float speed_for_max_volume = 15; //The speed at which the sound plays at maximum volume
const float max_volume = 1; //The maximum volume a sound is played at
- const float min_volume = 0.2; //The minimum volume a sound is played at
+ const float min_volume = 0.2f; //The minimum volume a sound is played at
float volume; //The volume the crash sound will be played at
diff --git a/src/main.cpp b/src/main.cpp
index c3868be7b..28ba7201e 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -594,6 +594,7 @@ void cmdLineHelp()
" -h, --help Show this help.\n"
" --log=N Set the verbosity to a value between\n"
" 0 (Debug) and 5 (Only Fatal messages)\n"
+ " --logbuffer=N Buffers up to N lines log lines before writing.\n"
" --root=DIR Path to add to the list of STK root directories.\n"
" You can specify more than one by separating them\n"
" with colons (:).\n"
@@ -664,6 +665,8 @@ int handleCmdLineOutputModifier()
int n;
if(CommandLine::has("--log", &n))
Log::setLogLevel(n);
+ if (CommandLine::has("--logbuffer", &n))
+ Log::setBufferSize(n);
if(CommandLine::has("--log=nocolor"))
{
@@ -1807,8 +1810,10 @@ int main(int argc, char *argv[] )
} // try
catch (std::exception &e)
{
+ Log::flushBuffers();
Log::error("main", "Exception caught : %s.",e.what());
Log::error("main", "Aborting SuperTuxKart.");
+ Log::flushBuffers();
}
/* Program closing...*/
@@ -1832,6 +1837,8 @@ int main(int argc, char *argv[] )
MemoryLeaks::checkForLeaks();
#endif
+ Log::flushBuffers();
+
#ifndef WIN32
if (user_config) //close logfiles
{
diff --git a/src/race/race_manager.cpp b/src/race/race_manager.cpp
index c1251dfd8..1c9ad2b97 100644
--- a/src/race/race_manager.cpp
+++ b/src/race/race_manager.cpp
@@ -431,7 +431,9 @@ void RaceManager::startNew(bool from_overworld)
{
if (m_continue_saved_gp)
{
- m_track_number = m_saved_gp->getNextTrack();
+ int next_track = m_saved_gp->getNextTrack();
+ if (next_track < m_tracks.size())
+ m_track_number = next_track;
m_saved_gp->loadKarts(m_kart_status);
}
else
diff --git a/src/scriptengine/script_track.cpp b/src/scriptengine/script_track.cpp
index 2ca00ea0c..a221e0ce4 100644
--- a/src/scriptengine/script_track.cpp
+++ b/src/scriptengine/script_track.cpp
@@ -295,6 +295,33 @@ namespace Scripting
return -1;
}
+ /** Remove all animation set for a skeletal animation */
+ void removeAllAnimationSet(/** \cond DOXYGEN_IGNORE */void *memory /** \endcond */)
+ {
+ if (memory)
+ {
+ ((scene::IAnimatedMeshSceneNode*)(memory))->removeAllAnimationSet();
+ }
+ }
+
+ /** Add an animation set for a skeletal animation */
+ void addAnimationSet(int start/** \cond DOXYGEN_IGNORE */, int end/** \cond DOXYGEN_IGNORE */, /** \cond DOXYGEN_IGNORE */void *memory /** \endcond */)
+ {
+ if (memory)
+ {
+ ((scene::IAnimatedMeshSceneNode*)(memory))->addAnimationSet(start, end);
+ }
+ }
+
+ /** use an current frame for a skeletal animation */
+ void useAnimationSet(int set_num /** \cond DOXYGEN_IGNORE */, void *memory /** \endcond */)
+ {
+ if (memory)
+ {
+ ((scene::IAnimatedMeshSceneNode*)(memory))->useAnimationSet(set_num);
+ }
+ }
+
/** Sets the current frame for a skeletal animation */
void setCurrentFrame(int frame /** \cond DOXYGEN_IGNORE */, void *memory /** \endcond */)
{
@@ -465,6 +492,8 @@ namespace Scripting
r = engine->RegisterObjectMethod("TrackObject", "void moveTo(const Vec3 &in, bool)", asMETHOD(::TrackObject, moveTo), asCALL_THISCALL); assert(r >= 0);
r = engine->RegisterObjectMethod("TrackObject", "Vec3 getCenterPosition()", asFUNCTION(TrackObject::getCenterPosition), asCALL_CDECL_OBJLAST); assert(r >= 0);
r = engine->RegisterObjectMethod("TrackObject", "Vec3 getOrigin()", asFUNCTION(TrackObject::getOrigin), asCALL_CDECL_OBJLAST); assert(r >= 0);
+ r = engine->RegisterObjectMethod("TrackObject", "TrackObject@ getParentLibrary()", asMETHOD(::TrackObject, getParentLibrary), asCALL_THISCALL); assert(r >= 0);
+ r = engine->RegisterObjectMethod("TrackObject", "string getName()", asMETHOD(::TrackObject, getName), asCALL_THISCALL); assert(r >= 0);
// PhysicalObject
r = engine->RegisterObjectMethod("PhysicalObject", "bool isFlattenKartObject()", asMETHOD(PhysicalObject, isFlattenKartObject), asCALL_THISCALL); assert(r >= 0);
@@ -476,6 +505,9 @@ namespace Scripting
r = engine->RegisterObjectMethod("Mesh", "void setFrameLoopOnce(int start, int end)", asFUNCTION(Mesh::setFrameLoopOnce), asCALL_CDECL_OBJLAST); assert(r >= 0);
r = engine->RegisterObjectMethod("Mesh", "int getFrameNr()", asFUNCTION(Mesh::getFrameNr), asCALL_CDECL_OBJLAST); assert(r >= 0);
r = engine->RegisterObjectMethod("Mesh", "int getAnimationSet()", asFUNCTION(Mesh::getAnimationSet), asCALL_CDECL_OBJLAST); assert(r >= 0);
+ r = engine->RegisterObjectMethod("Mesh", "void useAnimationSet(int set_num)", asFUNCTION(Mesh::useAnimationSet), asCALL_CDECL_OBJLAST); assert(r >= 0);
+ r = engine->RegisterObjectMethod("Mesh", "void addAnimationSet(int start, int end)", asFUNCTION(Mesh::addAnimationSet), asCALL_CDECL_OBJLAST); assert(r >= 0);
+ r = engine->RegisterObjectMethod("Mesh", "void removeAllAnimationSet()", asFUNCTION(Mesh::removeAllAnimationSet), asCALL_CDECL_OBJLAST); assert(r >= 0);
r = engine->RegisterObjectMethod("Mesh", "void setCurrentFrame(int frame)", asFUNCTION(Mesh::setCurrentFrame), asCALL_CDECL_OBJLAST); assert(r >= 0);
//r = engine->RegisterObjectMethod("Mesh", "void move(Vec3 &in)", asFUNCTION(movePresentation), asCALL_CDECL_OBJLAST); assert(r >= 0);
diff --git a/src/states_screens/feature_unlocked.cpp b/src/states_screens/feature_unlocked.cpp
index 8ae059181..eb69539b4 100644
--- a/src/states_screens/feature_unlocked.cpp
+++ b/src/states_screens/feature_unlocked.cpp
@@ -581,20 +581,20 @@ bool FeatureUnlockedCutScene::onEscapePressed()
void FeatureUnlockedCutScene::continueButtonPressed()
{
- //if (m_global_time < GIFT_EXIT_TO)
- //{
- // // If animation was not over yet, the button is used to skip the animation
- // while (m_global_time < GIFT_EXIT_TO)
- // {
- // // simulate all the steps of the animation until we reach the end
- // onUpdate(0.4f);
- // World::getWorld()->updateWorld(0.4f);
- // }
- //}
- //else
- //{
+ if (m_global_time < GIFT_EXIT_TO)
+ {
+ // If animation was not over yet, the button is used to skip the animation
+ while (m_global_time < GIFT_EXIT_TO)
+ {
+ // simulate all the steps of the animation until we reach the end
+ onUpdate(0.4f);
+ World::getWorld()->updateWorld(0.4f);
+ }
+ }
+ else
+ {
((CutsceneWorld*)World::getWorld())->abortCutscene();
- //}
+ }
} // continueButtonPressed
diff --git a/src/states_screens/ghost_replay_selection.cpp b/src/states_screens/ghost_replay_selection.cpp
index c5e90191b..3205ce918 100644
--- a/src/states_screens/ghost_replay_selection.cpp
+++ b/src/states_screens/ghost_replay_selection.cpp
@@ -128,7 +128,7 @@ void GhostReplaySelection::loadList()
row.push_back(GUIEngine::ListWidget::ListCell
(StringUtils::toWString(rd.m_min_time) + L"s", -1, 1, true));
row.push_back(GUIEngine::ListWidget::ListCell
- (rd.m_user_name, -1, 1, true));
+ (rd.m_user_name.empty() ? " " : rd.m_user_name, -1, 1, true));
m_replay_list_widget->addItem(StringUtils::toString(i), row);
}
} // loadList
diff --git a/src/states_screens/grand_prix_win.cpp b/src/states_screens/grand_prix_win.cpp
index 30e9bca59..4e7271c67 100644
--- a/src/states_screens/grand_prix_win.cpp
+++ b/src/states_screens/grand_prix_win.cpp
@@ -203,6 +203,7 @@ void GrandPrixWin::init()
m_unlocked_label->add();
manualAddWidget(m_unlocked_label);
+ m_unlocked_label->setColor(video::SColor(255, 255, 255, 255));
}
else
{
diff --git a/src/states_screens/main_menu_screen.cpp b/src/states_screens/main_menu_screen.cpp
index 35523b85d..17f1d3257 100644
--- a/src/states_screens/main_menu_screen.cpp
+++ b/src/states_screens/main_menu_screen.cpp
@@ -46,6 +46,7 @@
#include "states_screens/offline_kart_selection.hpp"
#include "states_screens/online_profile_achievements.hpp"
#include "states_screens/online_profile_servers.hpp"
+#include "states_screens/online_screen.hpp"
#include "states_screens/options_screen_video.hpp"
#include "states_screens/state_manager.hpp"
#include "states_screens/user_screen.hpp"
@@ -75,9 +76,6 @@ bool MainMenuScreen::m_enable_online = false;
MainMenuScreen::MainMenuScreen() : Screen("main_menu.stkgui")
{
- m_online_string = _("Online");
- //I18N: Used as a verb, appears on the main menu (login button)
- m_login_string = _("Login");
} // MainMenuScreen
// ----------------------------------------------------------------------------
@@ -151,10 +149,7 @@ void MainMenuScreen::init()
w->setBadge(LOADING_BADGE);
}
- m_online = getWidget("online");
-
- if(!m_enable_online)
- m_online->setActive(false);
+ IconButtonWidget* online = getWidget("online");
LabelWidget* w = getWidget("info_addons");
const core::stringw &news_text = NewsManager::get()->getNextNewsMessage();
@@ -179,32 +174,25 @@ void MainMenuScreen::init()
} // init
// ----------------------------------------------------------------------------
-void MainMenuScreen::onUpdate(float delta)
+void MainMenuScreen::onUpdate(float delta)
{
PlayerProfile *player = PlayerManager::getCurrentPlayer();
if(PlayerManager::getCurrentOnlineState() == PlayerProfile::OS_GUEST ||
PlayerManager::getCurrentOnlineState() == PlayerProfile::OS_SIGNED_IN)
{
m_user_id->setText(player->getLastOnlineName() + "@stk");
- m_online->setActive(true);
- m_online->setLabel(m_online_string);
}
else if (PlayerManager::getCurrentOnlineState() == PlayerProfile::OS_SIGNED_OUT)
{
- m_online->setActive(true);
- m_online->setLabel(m_login_string);
m_user_id->setText(player->getName());
}
else
{
// now must be either logging in or logging out
- m_online->setActive(false);
m_user_id->setText(player->getName());
}
- m_online->setLabel(PlayerManager::getCurrentOnlineId() ? m_online_string
- : m_login_string);
IconButtonWidget* addons_icon = getWidget("addons");
if (addons_icon != NULL)
{
@@ -472,6 +460,7 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
}
else if (selection == "story")
{
+ NetworkConfig::get()->unsetNetworking();
PlayerProfile *player = PlayerManager::getCurrentPlayer();
if (player->isFirstTime())
{
@@ -505,23 +494,30 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
}
else if (selection == "online")
{
- if(UserConfigParams::m_internet_status!=RequestManager::IPERM_ALLOWED)
+ if (MainMenuScreen::m_enable_online)
{
- new MessageDialog(_("You can not play online without internet access. "
- "If you want to play online, go to options, select "
- " tab 'User Interface', and edit "
- "\"Connect to the Internet\"."));
- return;
- }
-
- if (PlayerManager::getCurrentOnlineId())
- {
- ProfileManager::get()->setVisiting(PlayerManager::getCurrentOnlineId());
- OnlineProfileServers::getInstance()->push();
+ OnlineScreen::getInstance()->push();
}
else
{
- UserScreen::getInstance()->push();
+ if (UserConfigParams::m_internet_status != RequestManager::IPERM_ALLOWED)
+ {
+ new MessageDialog(_("You can not play online without internet access. "
+ "If you want to play online, go to options, select "
+ " tab 'User Interface', and edit "
+ "\"Connect to the Internet\"."));
+ return;
+ }
+
+ if (PlayerManager::getCurrentOnlineId())
+ {
+ ProfileManager::get()->setVisiting(PlayerManager::getCurrentOnlineId());
+ TabOnlineProfileAchievements::getInstance()->push();
+ }
+ else
+ {
+ UserScreen::getInstance()->push();
+ }
}
}
else if (selection == "addons")
diff --git a/src/states_screens/main_menu_screen.hpp b/src/states_screens/main_menu_screen.hpp
index 4e79c4532..8da6c94ab 100644
--- a/src/states_screens/main_menu_screen.hpp
+++ b/src/states_screens/main_menu_screen.hpp
@@ -32,13 +32,6 @@ class MainMenuScreen : public GUIEngine::Screen, public GUIEngine::ScreenSinglet
private:
friend class GUIEngine::ScreenSingleton;
- core::stringw m_online_string;
-
- core::stringw m_login_string;
-
- /** Keep the widget to avoid looking it up every frame. */
- GUIEngine::IconButtonWidget* m_online;
-
/** Keep the widget to to the user name. */
GUIEngine::ButtonWidget *m_user_id;
diff --git a/src/states_screens/online_lan.cpp b/src/states_screens/online_lan.cpp
new file mode 100644
index 000000000..9e22fa104
--- /dev/null
+++ b/src/states_screens/online_lan.cpp
@@ -0,0 +1,112 @@
+// SuperTuxKart - a fun racing game with go-kart
+// Copyright (C) 2010-2015 Glenn De Jonghe
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 3
+// of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+#include "states_screens/online_profile_servers.hpp"
+
+#include "audio/sfx_manager.hpp"
+#include "config/player_manager.hpp"
+#include "guiengine/engine.hpp"
+#include "guiengine/scalable_font.hpp"
+#include "guiengine/screen.hpp"
+#include "guiengine/widget.hpp"
+#include "network/network_config.hpp"
+#include "network/protocol_manager.hpp"
+#include "network/protocols/connect_to_server.hpp"
+#include "network/protocols/request_connection.hpp"
+#include "network/servers_manager.hpp"
+#include "states_screens/state_manager.hpp"
+#include "states_screens/create_server_screen.hpp"
+#include "states_screens/networking_lobby.hpp"
+#include "states_screens/online_lan.hpp"
+#include "states_screens/server_selection.hpp"
+#include "utils/translation.hpp"
+
+#include
+
+#include
+#include
+
+using namespace GUIEngine;
+using namespace irr::core;
+using namespace irr::gui;
+using namespace Online;
+
+DEFINE_SCREEN_SINGLETON( OnlineLanScreen );
+
+// -----------------------------------------------------------------------------
+
+OnlineLanScreen::OnlineLanScreen() : GUIEngine::Screen("online/lan.stkgui")
+{
+} // OnlineLanScreen
+
+// -----------------------------------------------------------------------------
+
+void OnlineLanScreen::loadedFromFile()
+{
+} // loadedFromFile
+
+// -----------------------------------------------------------------------------
+
+void OnlineLanScreen::init()
+{
+ RibbonWidget* ribbon = getWidget("lan");
+ assert(ribbon != NULL);
+ ribbon->select("find_lan_server", PLAYER_ID_GAME_MASTER);
+ ribbon->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
+} // init
+
+// -----------------------------------------------------------------------------
+
+void OnlineLanScreen::eventCallback(Widget* widget, const std::string& name, const int playerID)
+{
+ if (name == "back")
+ {
+ StateManager::get()->popMenu();
+ return;
+ }
+ if (name == "lan")
+ {
+ RibbonWidget* ribbon = dynamic_cast(widget);
+ std::string selection = ribbon->getSelectionIDString(PLAYER_ID_GAME_MASTER);
+ if (selection == "create_lan_server")
+ {
+ NetworkConfig::get()->setIsLAN();
+ NetworkConfig::get()->setIsServer(true);
+ CreateServerScreen::getInstance()->push();
+ // TODO: create lan server
+ }
+ else if (selection == "find_lan_server")
+ {
+ NetworkConfig::get()->setIsLAN();
+ NetworkConfig::get()->setIsServer(false);
+ ServerSelection::getInstance()->push();
+ }
+ }
+
+} // eventCallback
+
+// ----------------------------------------------------------------------------
+/** Also called when pressing the back button. It resets the flags to indicate
+ * a networked game.
+ */
+bool OnlineLanScreen::onEscapePressed()
+{
+ NetworkConfig::get()->unsetNetworking();
+ //StateManager::get()->popMenu();
+ return true;
+} // onEscapePressed
+
diff --git a/src/states_screens/online_lan.hpp b/src/states_screens/online_lan.hpp
new file mode 100644
index 000000000..615cb9e37
--- /dev/null
+++ b/src/states_screens/online_lan.hpp
@@ -0,0 +1,57 @@
+// SuperTuxKart - a fun racing game with go-kart
+// Copyright (C) 2013-2015 Glenn De Jonghe
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 3
+// of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+#ifndef __HEADER_OLAN_HPP__
+#define __HEADER_OLAN_HPP__
+
+#include
+#include
+
+#include "guiengine/screen.hpp"
+#include "guiengine/widgets.hpp"
+#include "states_screens/online_profile_base.hpp"
+
+namespace GUIEngine { class Widget; }
+
+
+/**
+ * \brief Online profiel overview screen
+ * \ingroup states_screens
+ */
+class OnlineLanScreen : public GUIEngine::Screen, public GUIEngine::ScreenSingleton
+{
+protected:
+ OnlineLanScreen();
+
+public:
+ friend class GUIEngine::ScreenSingleton;
+
+ /** \brief implement callback from parent class GUIEngine::Screen */
+ virtual void loadedFromFile() OVERRIDE;
+
+ /** \brief implement callback from parent class GUIEngine::Screen */
+ virtual void eventCallback(GUIEngine::Widget* widget, const std::string& name,
+ const int playerID) OVERRIDE;
+
+ /** \brief implement callback from parent class GUIEngine::Screen */
+ virtual void init() OVERRIDE;
+ virtual bool onEscapePressed() OVERRIDE;
+
+}; // class OnlineProfileServers
+
+#endif
diff --git a/src/states_screens/online_profile_base.cpp b/src/states_screens/online_profile_base.cpp
index 208123750..0088cdaf3 100644
--- a/src/states_screens/online_profile_base.cpp
+++ b/src/states_screens/online_profile_base.cpp
@@ -42,7 +42,6 @@ using namespace Online;
OnlineProfileBase::OnlineProfileBase(const std::string &filename)
: Screen(filename.c_str())
{
- m_servers_tab = NULL;
m_friends_tab = NULL;
m_achievements_tab = NULL;
m_settings_tab = NULL;
@@ -63,9 +62,6 @@ void OnlineProfileBase::loadedFromFile()
m_friends_tab = (IconButtonWidget *)m_profile_tabs->findWidgetNamed("tab_friends");
assert(m_friends_tab != NULL);
- m_servers_tab = (IconButtonWidget *)m_profile_tabs->findWidgetNamed("tab_servers");
- assert(m_servers_tab != NULL);
-
m_achievements_tab = (IconButtonWidget*)m_profile_tabs->findWidgetNamed("tab_achievements");
assert(m_profile_tabs == NULL || m_achievements_tab != NULL);
@@ -107,7 +103,6 @@ void OnlineProfileBase::init()
if (m_profile_tabs)
{
- m_servers_tab->setTooltip(_("Servers"));
m_friends_tab->setTooltip(_("Friends"));
m_achievements_tab->setTooltip(_("Achievements"));
m_settings_tab->setTooltip(_("Account Settings"));
@@ -159,8 +154,6 @@ void OnlineProfileBase::eventCallback(Widget* widget, const std::string& name,
sm->replaceTopMostScreen(TabOnlineProfileAchievements::getInstance());
else if (selection == m_settings_tab->m_properties[PROP_ID])
sm->replaceTopMostScreen(OnlineProfileSettings::getInstance());
- else if (selection == m_servers_tab->m_properties[PROP_ID])
- sm->replaceTopMostScreen(OnlineProfileServers::getInstance());
}
else if (name == "back")
{
diff --git a/src/states_screens/online_profile_base.hpp b/src/states_screens/online_profile_base.hpp
index 95a6906fa..0285edb4b 100644
--- a/src/states_screens/online_profile_base.hpp
+++ b/src/states_screens/online_profile_base.hpp
@@ -42,7 +42,6 @@ protected:
/** Pointer to the various widgets on the screen. */
GUIEngine::LabelWidget * m_header;
GUIEngine::RibbonWidget* m_profile_tabs;
- GUIEngine::IconButtonWidget * m_servers_tab;
GUIEngine::IconButtonWidget * m_friends_tab;
GUIEngine::IconButtonWidget * m_achievements_tab;
GUIEngine::IconButtonWidget * m_settings_tab;
diff --git a/src/states_screens/online_profile_servers.cpp b/src/states_screens/online_profile_servers.cpp
index 7d3400b0f..0787d2fef 100644
--- a/src/states_screens/online_profile_servers.cpp
+++ b/src/states_screens/online_profile_servers.cpp
@@ -48,7 +48,7 @@ DEFINE_SCREEN_SINGLETON( OnlineProfileServers );
// -----------------------------------------------------------------------------
-OnlineProfileServers::OnlineProfileServers() : OnlineProfileBase("online/profile_servers.stkgui")
+OnlineProfileServers::OnlineProfileServers() : GUIEngine::Screen("online/profile_servers.stkgui")
{
} // OnlineProfileServers
@@ -56,44 +56,28 @@ OnlineProfileServers::OnlineProfileServers() : OnlineProfileBase("online/profile
void OnlineProfileServers::loadedFromFile()
{
- OnlineProfileBase::loadedFromFile();
} // loadedFromFile
// -----------------------------------------------------------------------------
void OnlineProfileServers::init()
{
- OnlineProfileBase::init();
- m_profile_tabs->select( m_servers_tab->m_properties[PROP_ID], PLAYER_ID_GAME_MASTER );
- m_servers_tab->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
- // OnlineScreen::getInstance()->push();
+ RibbonWidget* ribbon = getWidget("wan");
+ assert(ribbon != NULL);
+ ribbon->select("find_wan_server", PLAYER_ID_GAME_MASTER);
+ ribbon->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
} // init
// -----------------------------------------------------------------------------
void OnlineProfileServers::eventCallback(Widget* widget, const std::string& name, const int playerID)
{
- OnlineProfileBase::eventCallback( widget, name, playerID);
-
- if (name == "lan")
+ if (name == "back")
{
- RibbonWidget* ribbon = dynamic_cast(widget);
- std::string selection = ribbon->getSelectionIDString(PLAYER_ID_GAME_MASTER);
- if (selection == "create_lan_server")
- {
- NetworkConfig::get()->setIsLAN();
- NetworkConfig::get()->setIsServer(true);
- CreateServerScreen::getInstance()->push();
- // TODO: create lan server
- }
- else if (selection == "find_lan_server")
- {
- NetworkConfig::get()->setIsLAN();
- NetworkConfig::get()->setIsServer(false);
- ServerSelection::getInstance()->push();
- }
+ StateManager::get()->popMenu();
+ return;
}
- else if (name == "wan")
+ if (name == "wan")
{
RibbonWidget* ribbon = dynamic_cast(widget);
std::string selection = ribbon->getSelectionIDString(PLAYER_ID_GAME_MASTER);
@@ -176,6 +160,6 @@ void OnlineProfileServers::doQuickPlay()
bool OnlineProfileServers::onEscapePressed()
{
NetworkConfig::get()->unsetNetworking();
- return OnlineProfileBase::onEscapePressed();
+ return true;
} // onEscapePressed
diff --git a/src/states_screens/online_profile_servers.hpp b/src/states_screens/online_profile_servers.hpp
index b840f103e..0d30b6fe6 100644
--- a/src/states_screens/online_profile_servers.hpp
+++ b/src/states_screens/online_profile_servers.hpp
@@ -33,7 +33,7 @@ namespace GUIEngine { class Widget; }
* \brief Online profiel overview screen
* \ingroup states_screens
*/
-class OnlineProfileServers : public OnlineProfileBase, public GUIEngine::ScreenSingleton
+class OnlineProfileServers : public GUIEngine::Screen, public GUIEngine::ScreenSingleton
{
protected:
OnlineProfileServers();
diff --git a/src/states_screens/online_screen.cpp b/src/states_screens/online_screen.cpp
new file mode 100644
index 000000000..e0601c56e
--- /dev/null
+++ b/src/states_screens/online_screen.cpp
@@ -0,0 +1,198 @@
+// SuperTuxKart - a fun racing game with go-kart
+// Copyright (C) 2009-2015 Marianne Gagnon
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 3
+// of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+#include "states_screens/main_menu_screen.hpp"
+
+#include "config/player_manager.hpp"
+#include "config/user_config.hpp"
+#include "graphics/irr_driver.hpp"
+#include "guiengine/scalable_font.hpp"
+#include "guiengine/widgets/label_widget.hpp"
+#include "guiengine/widgets/list_widget.hpp"
+#include "guiengine/widgets/ribbon_widget.hpp"
+#include "input/device_manager.hpp"
+#include "input/input_manager.hpp"
+#include "input/keyboard_device.hpp"
+#include "io/file_manager.hpp"
+#include "main_loop.hpp"
+#include "network/network_config.hpp"
+#include "online/request_manager.hpp"
+#include "states_screens/online_lan.hpp"
+#include "states_screens/online_profile_achievements.hpp"
+#include "states_screens/online_profile_servers.hpp"
+#include "states_screens/online_screen.hpp"
+#include "states_screens/state_manager.hpp"
+#include "states_screens/user_screen.hpp"
+#include "states_screens/dialogs/message_dialog.hpp"
+#include "tracks/track_manager.hpp"
+#include "utils/string_utils.hpp"
+
+
+#include
+
+
+using namespace GUIEngine;
+using namespace Online;
+
+DEFINE_SCREEN_SINGLETON( OnlineScreen );
+
+// ----------------------------------------------------------------------------
+
+OnlineScreen::OnlineScreen() : Screen("online/online.stkgui")
+{
+ m_online_string = _("Your profile");
+ //I18N: Used as a verb, appears on the main networking menu (login button)
+ m_login_string = _("Login");
+} // OnlineScreen
+
+// ----------------------------------------------------------------------------
+
+void OnlineScreen::loadedFromFile()
+{
+} // loadedFromFile
+
+// ----------------------------------------------------------------------------
+
+void OnlineScreen::beforeAddingWidget()
+{
+ bool is_logged_in = false;
+ PlayerProfile *player = PlayerManager::getCurrentPlayer();
+ if (PlayerManager::getCurrentOnlineState() == PlayerProfile::OS_GUEST ||
+ PlayerManager::getCurrentOnlineState() == PlayerProfile::OS_SIGNED_IN)
+ {
+ is_logged_in = true;
+ }
+
+ IconButtonWidget* wan = getWidget("wan");
+ wan->setActive(is_logged_in);
+ wan->setVisible(is_logged_in);
+} // beforeAddingWidget
+
+// ----------------------------------------------------------------------------
+//
+void OnlineScreen::init()
+{
+ Screen::init();
+
+ m_online = getWidget("online");
+
+ if (!MainMenuScreen::m_enable_online)
+ m_online->setActive(false);
+
+ m_user_id = getWidget("user-id");
+ assert(m_user_id);
+
+ RibbonWidget* r = getWidget("menu_toprow");
+ r->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
+
+} // init
+
+// ----------------------------------------------------------------------------
+
+void OnlineScreen::onUpdate(float delta)
+{
+ PlayerProfile *player = PlayerManager::getCurrentPlayer();
+ if (PlayerManager::getCurrentOnlineState() == PlayerProfile::OS_GUEST ||
+ PlayerManager::getCurrentOnlineState() == PlayerProfile::OS_SIGNED_IN)
+ {
+ m_online->setActive(true);
+ m_online->setLabel(m_online_string);
+ m_user_id->setText(player->getLastOnlineName() + "@stk");
+ }
+ else if (PlayerManager::getCurrentOnlineState() == PlayerProfile::OS_SIGNED_OUT)
+ {
+ m_online->setActive(true);
+ m_online->setLabel(m_login_string);
+ m_user_id->setText(player->getName());
+ }
+ else
+ {
+ // now must be either logging in or logging out
+ m_online->setActive(false);
+ m_user_id->setText(player->getName());
+ }
+
+ m_online->setLabel(PlayerManager::getCurrentOnlineId() ? m_online_string
+ : m_login_string);
+} // onUpdate
+
+// ----------------------------------------------------------------------------
+
+void OnlineScreen::eventCallback(Widget* widget, const std::string& name,
+ const int playerID)
+{
+ if (name == "user-id")
+ {
+ UserScreen::getInstance()->push();
+ return;
+ }
+ else if (name == "back")
+ {
+ StateManager::get()->popMenu();
+ return;
+ }
+
+ RibbonWidget* ribbon = dynamic_cast(widget);
+ if (ribbon == NULL) return; // what's that event??
+
+ // ---- A ribbon icon was clicked
+ std::string selection =
+ ribbon->getSelectionIDString(PLAYER_ID_GAME_MASTER);
+
+ if (selection == "lan")
+ {
+ OnlineLanScreen::getInstance()->push();
+ }
+ else if (selection == "wan")
+ {
+ OnlineProfileServers::getInstance()->push();
+ }
+ else if (selection == "online")
+ {
+ if (UserConfigParams::m_internet_status != RequestManager::IPERM_ALLOWED)
+ {
+ new MessageDialog(_("You can not play online without internet access. "
+ "If you want to play online, go to options, select "
+ " tab 'User Interface', and edit "
+ "\"Connect to the Internet\"."));
+ return;
+ }
+
+ if (PlayerManager::getCurrentOnlineId())
+ {
+ ProfileManager::get()->setVisiting(PlayerManager::getCurrentOnlineId());
+ TabOnlineProfileAchievements::getInstance()->push();
+ }
+ else
+ {
+ UserScreen::getInstance()->push();
+ }
+ }
+} // eventCallback
+
+// ----------------------------------------------------------------------------
+
+void OnlineScreen::tearDown()
+{
+} // tearDown
+
+// ----------------------------------------------------------------------------
+
+void OnlineScreen::onDisabledItemClicked(const std::string& item)
+{
+} // onDisabledItemClicked
diff --git a/src/states_screens/online_screen.hpp b/src/states_screens/online_screen.hpp
new file mode 100644
index 000000000..69f2b371b
--- /dev/null
+++ b/src/states_screens/online_screen.hpp
@@ -0,0 +1,71 @@
+// SuperTuxKart - a fun racing game with go-kart
+// Copyright (C) 2009-2015 Marianne Gagnon
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 3
+// of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+#ifndef HEADER_ONLINE_SCREEN_HPP
+#define HEADER_ONLINE_SCREEN_HPP
+
+#include "guiengine/screen.hpp"
+
+namespace GUIEngine { class Widget; class ListWidget;
+ class ButtonWidget; class IconButtonWidget; }
+
+/**
+ * \brief Handles the networking main menu
+ * \ingroup states_screens
+ */
+class OnlineScreen : public GUIEngine::Screen, public GUIEngine::ScreenSingleton
+{
+private:
+ friend class GUIEngine::ScreenSingleton;
+
+ core::stringw m_online_string;
+
+ core::stringw m_login_string;
+
+ /** Keep the widget to to the user name. */
+ GUIEngine::ButtonWidget *m_user_id;
+
+ /** Keep the widget to avoid looking it up every frame. */
+ GUIEngine::IconButtonWidget* m_online;
+
+ OnlineScreen();
+
+public:
+
+ virtual void onUpdate(float delta) OVERRIDE;
+
+ /** \brief implement callback from parent class GUIEngine::Screen */
+ virtual void loadedFromFile() OVERRIDE;
+
+ /** \brief implement callback from parent class GUIEngine::Screen */
+ virtual void beforeAddingWidget() OVERRIDE;
+
+ /** \brief implement callback from parent class GUIEngine::Screen */
+ virtual void eventCallback(GUIEngine::Widget* widget, const std::string& name,
+ const int playerID) OVERRIDE;
+
+ /** \brief implement callback from parent class GUIEngine::Screen */
+ virtual void init() OVERRIDE;
+
+ /** \brief implement callback from parent class GUIEngine::Screen */
+ virtual void tearDown() OVERRIDE;
+
+ /** \brief implement callback from parent class GUIEngine::Screen */
+ virtual void onDisabledItemClicked(const std::string& item) OVERRIDE;
+};
+
+#endif
diff --git a/src/states_screens/race_gui_base.cpp b/src/states_screens/race_gui_base.cpp
index 8bc208aee..4dd278a89 100644
--- a/src/states_screens/race_gui_base.cpp
+++ b/src/states_screens/race_gui_base.cpp
@@ -225,9 +225,19 @@ void RaceGUIBase::drawAllMessages(const AbstractKart* kart,
if (msg.m_kart && msg.m_kart!=kart) continue;
core::rect pos(x - w/2, y, x + w/2, y + m_max_font_height);
- GUIEngine::getSmallFont()->draw(
+
+ gui::ScalableFont* font = GUIEngine::getSmallFont();
+
+ if (msg.m_outline)
+ font->setBlackBorder(true);
+
+ font->draw(
core::stringw(msg.m_message.c_str()).c_str(),
pos, msg.m_color, true /* hcenter */, true /* vcenter */);
+
+ if (msg.m_outline)
+ font->setBlackBorder(false);
+
y -= m_small_font_max_height;
}
}
@@ -273,9 +283,16 @@ void RaceGUIBase::drawAllMessages(const AbstractKart* kart,
}
else
{
+ if (msg.m_outline)
+ font->setBlackBorder(true);
+
font->draw(core::stringw(msg.m_message.c_str()).c_str(),
pos, msg.m_color, true /* hcenter */,
true /* vcenter */);
+
+ if (msg.m_outline)
+ font->setBlackBorder(false);
+
y += font_height;
}
} // for i in all messages
@@ -460,9 +477,9 @@ void RaceGUIBase::renderPlayerView(const Camera *camera, float dt)
void RaceGUIBase::addMessage(const core::stringw &msg,
const AbstractKart *kart,
float time, const video::SColor &color,
- bool important, bool big_font)
+ bool important, bool big_font, bool outline)
{
- m_messages.push_back(TimedMessage(msg, kart, time, color, important, big_font));
+ m_messages.push_back(TimedMessage(msg, kart, time, color, important, big_font, outline));
} // addMessage
//-----------------------------------------------------------------------------
diff --git a/src/states_screens/race_gui_base.hpp b/src/states_screens/race_gui_base.hpp
index 00b044583..24d4f742a 100644
--- a/src/states_screens/race_gui_base.hpp
+++ b/src/states_screens/race_gui_base.hpp
@@ -88,6 +88,8 @@ private:
bool m_important;
bool m_big_font;
+ bool m_outline;
+
// -----------------------------------------------------
// std::vector needs standard copy-ctor and std-assignment op.
// let compiler create defaults .. they'll do the job, no
@@ -95,7 +97,7 @@ private:
TimedMessage(const irr::core::stringw &message,
const AbstractKart *kart, float time,
const video::SColor &color, const bool important,
- bool big_font)
+ bool big_font, bool outline)
{
m_message = message;
m_kart = kart;
@@ -103,6 +105,7 @@ private:
m_color = color;
m_important = important;
m_big_font = big_font;
+ m_outline = outline;
} // TimedMessage
// -----------------------------------------------------
// in follow leader the clock counts backwards
@@ -229,7 +232,7 @@ public:
const video::SColor &color=
video::SColor(255, 255, 0, 255),
bool important=true,
- bool big_font=false);
+ bool big_font=false, bool outline=false);
virtual void update(float dt);
virtual void preRenderCallback(const Camera *camera);
// ------------------------------------------------------------------------
diff --git a/src/states_screens/race_result_gui.hpp b/src/states_screens/race_result_gui.hpp
index 0c1960ca0..e32a166e9 100644
--- a/src/states_screens/race_result_gui.hpp
+++ b/src/states_screens/race_result_gui.hpp
@@ -237,7 +237,8 @@ public:
const video::SColor &color=
video::SColor(255, 255, 0, 255),
bool important=true,
- bool big_font=false) OVERRIDE { }
+ bool big_font=false,
+ bool outline=false) OVERRIDE { }
void nextPhase();
diff --git a/src/states_screens/user_screen.cpp b/src/states_screens/user_screen.cpp
index 91071c597..c9ef957ee 100644
--- a/src/states_screens/user_screen.cpp
+++ b/src/states_screens/user_screen.cpp
@@ -400,7 +400,7 @@ void BaseUserScreen::eventCallback(Widget* widget,
*/
void BaseUserScreen::closeScreen()
{
- StateManager::get()->resetAndGoToScreen(MainMenuScreen::getInstance());
+ StateManager::get()->popMenu();
} // closeScreen
// ----------------------------------------------------------------------------
diff --git a/src/tracks/track.cpp b/src/tracks/track.cpp
index f29266e26..48818f4bd 100644
--- a/src/tracks/track.cpp
+++ b/src/tracks/track.cpp
@@ -466,6 +466,7 @@ void Track::cleanup()
}
#endif
+ m_meta_library.clear();
Scripting::ScriptEngine::getInstance()->cleanupCache();
m_current_track = NULL;
@@ -1570,6 +1571,39 @@ void Track::createWater(const XMLNode &node)
scene_node->getMaterial(0).setFlag(video::EMF_GOURAUD_SHADING, true);
} // createWater
+// ----------------------------------------------------------------------------
+static void recursiveUpdatePosition(scene::ISceneNode *node)
+{
+ node->updateAbsolutePosition();
+
+ scene::ISceneNodeList::ConstIterator it = node->getChildren().begin();
+ for (; it != node->getChildren().end(); ++it)
+ {
+ recursiveUpdatePosition(*it);
+ }
+} // recursiveUpdatePosition
+
+// ----------------------------------------------------------------------------
+static void recursiveUpdatePhysics(std::vector& tos)
+{
+ for (TrackObject* to : tos)
+ {
+ if (to->getPhysicalObject())
+ {
+ TrackObjectPresentationSceneNode* sn = to
+ ->getPresentation();
+ if (sn)
+ {
+ to->getPhysicalObject()->move(
+ sn->getNode()->getAbsoluteTransformation().getTranslation(),
+ sn->getNode()->getAbsoluteTransformation()
+ .getRotationDegrees());
+ }
+ }
+ recursiveUpdatePhysics(to->getChildren());
+ }
+} // recursiveUpdatePhysics
+
// ----------------------------------------------------------------------------
/** This function load the actual scene, i.e. all parts of the track,
* animations, items, ... It is called from world during initialisation.
@@ -1757,6 +1791,19 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
loadObjects(root, path, model_def_loader, true, NULL, NULL);
+ // Correct the parenting of meta library
+ for (auto& p : m_meta_library)
+ {
+ auto* ln = p.first->getPresentation();
+ assert(ln);
+ TrackObjectPresentationLibraryNode* meta_ln = p.second
+ ->getPresentation();
+ assert(meta_ln);
+ meta_ln->getNode()->setParent(ln->getNode());
+ recursiveUpdatePosition(meta_ln->getNode());
+ recursiveUpdatePhysics(p.second->getChildren());
+ }
+
model_def_loader.cleanLibraryNodesAfterLoad();
Scripting::ScriptEngine::getInstance()->compileLoadedScripts();
diff --git a/src/tracks/track.hpp b/src/tracks/track.hpp
index a0d5a5adb..f050f5959 100644
--- a/src/tracks/track.hpp
+++ b/src/tracks/track.hpp
@@ -374,6 +374,8 @@ private:
/** List of all bezier curves in the track - for e.g. camera, ... */
std::vector m_all_curves;
+ std::vector > m_meta_library;
+
/** The number of laps the track will be raced in a random GP.
* m_actual_number_of_laps is initialised with this value.*/
int m_default_number_of_laps;
@@ -672,6 +674,10 @@ public:
// ------------------------------------------------------------------------
/** Adds mesh to cleanup list */
void addCachedMesh(scene::IMesh* mesh) { m_all_cached_meshes.push_back(mesh); }
+ // ------------------------------------------------------------------------
+ /** Adds the parent of the meta library for correction later */
+ void addMetaLibrary(TrackObject* parent, TrackObject* meta_library)
+ { m_meta_library.emplace_back(parent, meta_library); }
}; // class Track
#endif
diff --git a/src/tracks/track_object.cpp b/src/tracks/track_object.cpp
index 0d441d123..255f00129 100644
--- a/src/tracks/track_object.cpp
+++ b/src/tracks/track_object.cpp
@@ -31,6 +31,7 @@
#include "physics/physical_object.hpp"
#include "race/race_manager.hpp"
#include "scriptengine/script_engine.hpp"
+#include "tracks/track.hpp"
#include "tracks/model_definition_loader.hpp"
#include
@@ -160,6 +161,10 @@ void TrackObject::init(const XMLNode &xml_node, scene::ISceneNode* parent,
{
xml_node.get("name", &m_name);
m_presentation = new TrackObjectPresentationLibraryNode(this, xml_node, model_def_loader);
+ if (parent_library != NULL)
+ {
+ Track::getCurrentTrack()->addMetaLibrary(parent_library, this);
+ }
}
else if (type == "sfx-emitter")
{
diff --git a/src/tracks/track_object_presentation.cpp b/src/tracks/track_object_presentation.cpp
index 414106b1b..5fe1e839c 100644
--- a/src/tracks/track_object_presentation.cpp
+++ b/src/tracks/track_object_presentation.cpp
@@ -180,6 +180,7 @@ TrackObjectPresentationLibraryNode::TrackObjectPresentationLibraryNode(
{
m_parent = NULL;
m_start_executed = false;
+ m_reset_executed = false;
std::string name;
xml_node.get("name", &name);
@@ -289,6 +290,22 @@ void TrackObjectPresentationLibraryNode::update(float dt)
m_start_executed = true;
std::string fn_name = StringUtils::insertValues("void %s::onStart(const string)", m_name.c_str());
+ if (m_parent != NULL)
+ {
+ std::string lib_id = m_parent->getID();
+ std::string* lib_id_ptr = &lib_id;
+
+ Scripting::ScriptEngine::getInstance()->runFunction(false, fn_name,
+ [&](asIScriptContext* ctx) {
+ ctx->SetArgObject(0, lib_id_ptr);
+ });
+ }
+ }
+ if (!m_reset_executed)
+ {
+ m_reset_executed = true;
+ std::string fn_name = StringUtils::insertValues("void %s::onReset(const string)", m_name.c_str());
+
if (m_parent != NULL)
{
std::string lib_id = m_parent->getID();
diff --git a/src/tracks/track_object_presentation.hpp b/src/tracks/track_object_presentation.hpp
index a2eedf32a..4a990b296 100644
--- a/src/tracks/track_object_presentation.hpp
+++ b/src/tracks/track_object_presentation.hpp
@@ -187,13 +187,18 @@ class TrackObjectPresentationLibraryNode : public TrackObjectPresentationSceneNo
TrackObject* m_parent;
using TrackObjectPresentationSceneNode::move;
std::string m_name;
- bool m_start_executed;
+ bool m_start_executed, m_reset_executed;
public:
TrackObjectPresentationLibraryNode(TrackObject* parent,
const XMLNode& xml_node,
ModelDefinitionLoader& model_def_loader);
virtual ~TrackObjectPresentationLibraryNode();
- virtual void update(float dt);
+ virtual void update(float dt) OVERRIDE;
+ virtual void reset() OVERRIDE
+ {
+ m_reset_executed = false;
+ TrackObjectPresentationSceneNode::reset();
+ }
void move(const core::vector3df& xyz, const core::vector3df& hpr,
const core::vector3df& scale, bool isAbsoluteCoord, bool moveChildrenPhysicalBodies);
}; // TrackObjectPresentationLibraryNode
diff --git a/src/utils/log.cpp b/src/utils/log.cpp
index e5d39167e..b349bb9e7 100644
--- a/src/utils/log.cpp
+++ b/src/utils/log.cpp
@@ -35,6 +35,9 @@
Log::LogLevel Log::m_min_log_level = Log::LL_VERBOSE;
bool Log::m_no_colors = false;
FILE* Log::m_file_stdout = NULL;
+std::string Log::m_prefix = "";
+size_t Log::m_buffer_size = 1;
+Synchronised > Log::m_line_buffer;
// ----------------------------------------------------------------------------
/** Selects background/foreground colors for the message depending on
@@ -106,25 +109,22 @@ void Log::setTerminalColor(LogLevel level)
*/
void Log::resetTerminalColor()
{
- if(m_no_colors)
- {
- printf("\n");
- return;
- }
-
+ if(m_no_colors) return;
#ifdef WIN32
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
/*TERM_BLACK*/0 << 4 | /*TERM_LIGHTGRAY*/7);
- printf("\n");
#else
- printf("%c[0;;m\n", 0x1B);
+ printf("%c[0;;m", 0x1B);
#endif
} // resetTerminalColor
// ----------------------------------------------------------------------------
-/** This actually prints the log message. If log messages are not redirected
- * to a file, it tries to select a terminal colour.
+/** This actually creates a log message. If the messages are to be buffered,
+ * it will be appended to the output buffer. If the buffer is full, it will
+ * be flushed. If the message is not to be buffered, it will be immediately
+ * written using writeLine().
+
* \param level Log level of the message to print.
* \param format A printf-like format string.
* \param va_list The values to be printed for the format.
@@ -132,105 +132,119 @@ void Log::resetTerminalColor()
void Log::printMessage(int level, const char *component, const char *format,
VALIST args)
{
- assert(level>=0 && level <=LL_FATAL);
+ assert(level >= 0 && level <= LL_FATAL);
- if(level= LL_WARN ||
+ if (!m_file_stdout || level >= LL_WARN ||
UserConfigParams::m_log_errors_to_console) // log to console & file
{
- VALIST out;
- va_copy(out, args);
-
setTerminalColor((LogLevel)level);
- #ifdef ANDROID
- __android_log_vprint(alp, "SuperTuxKart", format, out);
- #else
- printf("[%s] %s: ", names[level], component);
- vprintf(format, out);
- #endif
+#ifdef ANDROID
+ android_LogPriority alp;
+ switch (level)
+ {
+ // STK is using the levels slightly different from android
+ // (debug lowest, verbose above it; while android reverses
+ // this order. So to get the same behaviour (e.g. filter
+ // out debug message, but still get verbose, we swap
+ // the order here.
+ case LL_VERBOSE: alp = ANDROID_LOG_DEBUG; break;
+ case LL_DEBUG: alp = ANDROID_LOG_VERBOSE; break;
+ case LL_INFO: alp = ANDROID_LOG_INFO; break;
+ case LL_WARN: alp = ANDROID_LOG_WARN; break;
+ case LL_ERROR: alp = ANDROID_LOG_ERROR; break;
+ case LL_FATAL: alp = ANDROID_LOG_FATAL; break;
+ default: alp = ANDROID_LOG_FATAL;
+ }
+ __android_log_print(alp, "SuperTuxKart", "%s", line);
+#else
+ printf("%s", line);
+#endif
resetTerminalColor(); // this prints a \n
-
- va_end(out);
}
#if defined(_MSC_FULL_VER) && defined(_DEBUG)
- static char szBuff[2048];
- vsnprintf(szBuff, sizeof(szBuff), format, copy2);
-
- OutputDebugString("[");
- OutputDebugString(names[level]);
- OutputDebugString("] ");
- OutputDebugString(component);
- OutputDebugString(": ");
- OutputDebugString(szBuff);
- OutputDebugString("\r\n");
+ OutputDebugString(line);
#endif
-
- if(m_file_stdout)
- {
- fprintf (m_file_stdout, "[%s] %s: ", names[level], component);
- vfprintf(m_file_stdout, format, copy);
- fprintf (m_file_stdout, "\n");
- va_end(copy);
- }
+ if (m_file_stdout) fprintf(m_file_stdout, "%s", line);
#ifdef WIN32
if (level >= LL_FATAL)
{
- std::string message;
-
- char tmp[2048];
- sprintf(tmp, "[%s] %s: ", names[level], component);
- message += tmp;
-
- VALIST out;
- va_copy(out, args);
- vsprintf(tmp, format, out);
- message += tmp;
- va_end(out);
-
- MessageBoxA(NULL, message.c_str(), "SuperTuxKart - Fatal error", MB_OK);
+ MessageBoxA(NULL, line, "SuperTuxKart - Fatal error", MB_OK);
}
#endif
-} // printMessage
+} // _fluhBuffers
+// ----------------------------------------------------------------------------
+/** Flushes all stored log messages to the various output devices (thread safe).
+ */
+void Log::flushBuffers()
+{
+ m_line_buffer.lock();
+ for (unsigned int i = 0; i < m_line_buffer.getData().size(); i++)
+ {
+ const LineInfo &li = m_line_buffer.getData()[i];
+ writeLine(li.m_line.c_str(), li.m_level);
+ }
+ m_line_buffer.getData().clear();
+ m_line_buffer.unlock();
+} // flushBuffers
// ----------------------------------------------------------------------------
/** This function opens the files that will contain the output.
diff --git a/src/utils/log.hpp b/src/utils/log.hpp
index 61726cb8b..1d5ceb5bc 100644
--- a/src/utils/log.hpp
+++ b/src/utils/log.hpp
@@ -20,11 +20,15 @@
#ifndef HEADER_LOG_HPP
#define HEADER_LOG_HPP
+#include "utils/synchronised.hpp"
+
#include
#include
#include
#include
#include
+#include
+
#ifdef __GNUC__
# define VALIST __gnuc_va_list
@@ -59,13 +63,30 @@ private:
/** The file where stdout output will be written */
static FILE* m_file_stdout;
+ /** An optional buffer for lines to be output. */
+ struct LineInfo
+ {
+ std::string m_line;
+ int m_level;
+ };
+ static Synchronised > m_line_buffer;
+
+ /** <0 if no buffered logging is to be used, otherwise this is
+ ** the maximum number of lines the buffer should hold. */
+ static size_t m_buffer_size;
+
+ /** An optional prefix to be printed. */
+ static std::string m_prefix;
+
static void setTerminalColor(LogLevel level);
static void resetTerminalColor();
-
-public:
+ static void writeLine(const char *line, int level);
static void printMessage(int level, const char *component,
const char *format, VALIST va_list);
+
+public:
+
// ------------------------------------------------------------------------
/** A simple macro to define the various log functions.
* Note that an assert is added so that a debugger is triggered
@@ -95,7 +116,12 @@ public:
static void openOutputFiles(const std::string &logout);
static void closeOutputFiles();
+ static void flushBuffers();
+ // ------------------------------------------------------------------------
+ /** Sets the number of lines to buffer. Setting the buffer size to a
+ * a value <=1 means no buffering, lines will be immediately printed. */
+ static void setBufferSize(size_t n) { m_buffer_size = n; }
// ------------------------------------------------------------------------
/** Defines the minimum log level to be displayed. */
static void setLogLevel(int n)
@@ -120,5 +146,9 @@ public:
{
m_no_colors = true;
} // disableColor
+ // ------------------------------------------------------------------------
+ /** Sets a prefix to be printed before each line. To disable the prefix,
+ * set it to "". */
+ static void setPrefix(const std::string &prefix) { m_prefix = prefix; }
}; // Log
#endif
diff --git a/src/utils/profiler.cpp b/src/utils/profiler.cpp
index 1c45bc16d..00d6951ba 100644
--- a/src/utils/profiler.cpp
+++ b/src/utils/profiler.cpp
@@ -347,10 +347,11 @@ void Profiler::draw()
double start = 99999.0f;
double end = -1.0f;
- // Use this thread (thread 0) to compute start and end time. All other
+ // Use this thread to compute start and end time. All other
// threads might have 'unfinished' events, or multiple identical events
- // in this frame (i.e. start time would be incorrect(.
- AllEventData &aed = m_all_threads_data[0].m_all_event_data;
+ // in this frame (i.e. start time would be incorrect).
+ int thread_id = getThreadID();
+ AllEventData &aed = m_all_threads_data[thread_id].m_all_event_data;
AllEventData::iterator j;
for (j = aed.begin(); j != aed.end(); ++j)
{
@@ -381,7 +382,7 @@ void Profiler::draw()
{
AllEventData::iterator j = aed.find(td.m_ordered_headings[k]);
const Marker &marker = j->second.getMarker(indx);
- if (i == 0)
+ if (i == thread_id)
start_xpos = factor*marker.getStart();
core::rect pos((s32)(x_offset + start_xpos),
(s32)(y_offset + i*line_height),
diff --git a/tools/windows_installer/supertuxkart-64bit.nsi b/tools/windows_installer/supertuxkart-64bit.nsi
index 5d4f5aaad..c53a1d4ea 100755
--- a/tools/windows_installer/supertuxkart-64bit.nsi
+++ b/tools/windows_installer/supertuxkart-64bit.nsi
@@ -43,7 +43,7 @@
!define DESCRIPTION "3D open-source arcade racer with a variety characters, tracks, and modes to play"
Name "${APPNAMEANDVERSION}"
- OutFile "${APPNAMEANDVERSION} installer.exe"
+ OutFile "${APPNAMEANDVERSION} installer-64bit.exe"
# These will be displayed by the "Click here for support information" link in "Add/Remove Programs"
# It is possible to use "mailto:" links in here to open the email client
@@ -174,12 +174,12 @@ Section "Install" SecMain
; Try to find the binary directory in a list of 'typical' names:
; The first found directory is used
- ${!setIfUndefinedAndExists} EXEC_PATH ..\..\bld\bin\RelWithDebInfo\*.*
- ${!setIfUndefinedAndExists} EXEC_PATH ..\..\bld\bin\Release\*.*
- ${!setIfUndefinedAndExists} EXEC_PATH ..\..\build\bin\RelWithDebInfo\*.*
- ${!setIfUndefinedAndExists} EXEC_PATH ..\..\build\bin\Release\*.*
- ${!setIfUndefinedAndExists} EXEC_PATH ..\..\cmake_build\bin\RelWithDebInfo\*.*
- ${!setIfUndefinedAndExists} EXEC_PATH ..\..\cmake_build\bin\Release\*.*
+ ${!setIfUndefinedAndExists} EXEC_PATH ..\..\bld-64\bin\RelWithDebInfo\*.*
+ ${!setIfUndefinedAndExists} EXEC_PATH ..\..\bld-64\bin\Release\*.*
+ ${!setIfUndefinedAndExists} EXEC_PATH ..\..\build-64\bin\RelWithDebInfo\*.*
+ ${!setIfUndefinedAndExists} EXEC_PATH ..\..\build-64\bin\Release\*.*
+ ${!setIfUndefinedAndExists} EXEC_PATH ..\..\cmake_build-64\bin\RelWithDebInfo\*.*
+ ${!setIfUndefinedAndExists} EXEC_PATH ..\..\cmake_build-64\bin\Release\*.*
File /x *.ilk ${EXEC_PATH}
@@ -206,7 +206,7 @@ Section "Install" SecMain
File *.ico
; prereqs
SetOutPath "$INSTDIR\prerequisites"
- File /r prerequisites\*.*
+ File /r prerequisites\vcredist_x64.exe
; data + assets
SetOutPath "$INSTDIR\data\"
@@ -281,7 +281,6 @@ Section "Uninstall" redist
DELETE /REBOOTOK "$INSTDIR\icon.ico"
DELETE /REBOOTOK "$INSTDIR\libcurl-4.dll"
DELETE /REBOOTOK "$INSTDIR\libeay32.dll"
- DELETE /REBOOTOK "$INSTDIR\libidn-11.dll"
DELETE /REBOOTOK "$INSTDIR\License.txt"
DELETE /REBOOTOK "$INSTDIR\libfreetype.dll"
DELETE /REBOOTOK "$INSTDIR\libfribidi-0.dll"
diff --git a/tools/windows_installer/supertuxkart.nsi b/tools/windows_installer/supertuxkart.nsi
index 4b9aefb22..89e4e498f 100755
--- a/tools/windows_installer/supertuxkart.nsi
+++ b/tools/windows_installer/supertuxkart.nsi
@@ -35,7 +35,7 @@
!define VERSION_MINOR 9
!define VERSION_REVISION 3
; Empty means stable, could be -git, -rc1
- !define VERSION_BUILD "-rc1"
+ !define VERSION_BUILD "-git"
;Name and file
!define APPNAME "SuperTuxKart"
@@ -43,7 +43,7 @@
!define DESCRIPTION "3D open-source arcade racer with a variety characters, tracks, and modes to play"
Name "${APPNAMEANDVERSION}"
- OutFile "${APPNAMEANDVERSION} installer.exe"
+ OutFile "${APPNAMEANDVERSION} installer-32bit.exe"
# These will be displayed by the "Click here for support information" link in "Add/Remove Programs"
# It is possible to use "mailto:" links in here to open the email client
@@ -206,7 +206,7 @@ Section "Install" SecMain
File *.ico
; prereqs
SetOutPath "$INSTDIR\prerequisites"
- File /r prerequisites\*.*
+ File /r prerequisites\vcredist_x86.exe
; data + assets
SetOutPath "$INSTDIR\data\"