detroit-0.2.3/engine/gui.c

#if ! defined(PROG_DISABLE_GUI)

#include "declarations.h"
#include "gui.h"


/**
 * @brief Draw single pixel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Pixel coordinates in pixels and pixel color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_pixel(unsigned int h, struct point_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_PIXEL;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct point_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw single pixel with alpha channel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Pixel coordinates in pixels, pixel color and alpha value
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_pixel_alpha(unsigned int h, struct point_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_PIXEL_ALPHA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct point_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw array of pixels.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Pixel count, each pixel coordinates in pixels and pixel color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_pixels(unsigned int h, struct points_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_PIXELS;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct points_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw array of pixels with alpha channel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Pixel count, each pixel coordinates in pixels, pixel color and alpha value
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_pixels_alpha(unsigned int h, struct points_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_PIXELS_ALPHA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct points_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw single subpixel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Subpixel coordinates in subpixels and subpixel color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_subpixel(unsigned int h, struct subpoint_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_SUBPIXEL;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct subpoint_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw single subpixel with alpha channel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Subpixel coordinates in subpixels, subpixel color and alpha value
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_subpixel_alpha(unsigned int h, struct subpoint_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_SUBPIXEL_ALPHA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct subpoint_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw array of subpixels.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Subpixel count, each subpixel coordinates in subpixels and subpixel color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_subpixels(unsigned int h, struct subpoints_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_SUBPIXELS;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct subpoints_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw array of subpixels with alpha channel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Subpixel count, each subpixel coordinates in subpixels, subpixel color and alpha value
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_subpixels_alpha(unsigned int h, struct subpoints_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_SUBPIXELS_ALPHA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct subpoints_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw single line.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Line coordinates in pixels and line color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_line(unsigned int h, struct point_4 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_LINE;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct point_4);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw single line with anti-aliasing.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Line coordinates in pixels and line color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_line_aa(unsigned int h, struct point_4 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_LINE_AA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct point_4);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw single line with alpha channel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Line coordinates in pixels and line color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_line_alpha(unsigned int h, struct point_4 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_LINE_ALPHA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct point_4);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw array of lines.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Line count, each line coordinates in pixels and line color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_lines(unsigned int h, struct points_4 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_LINES;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct points_4);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw array of lines with anti-aliasing.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Line count, each line coordinates in pixels and line color
 *
 */

void gui_draw_lines_aa(unsigned int h, struct points_4 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_LINES_AA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct points_4);

	(void) window_cmd_push(&c);
}

/**
 * @brief Draw array of lines with alpha channel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Line count, each line coordinates in pixels and line color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_lines_alpha(unsigned int h, struct points_4 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_LINES_ALPHA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct points_4);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw single circle.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Circle coordinates in pixels and circle color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_circle(unsigned int h, struct circle_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_CIRCLE;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct circle_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw single circle with anti-aliasing.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Circle coordinates in pixels and circle color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_circle_aa(unsigned int h, struct circle_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_CIRCLE_AA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct circle_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw single circle with alpha channel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Circle coordinates in pixels and circle color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_circle_alpha(unsigned int h, struct circle_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_CIRCLE_ALPHA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct circle_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw array of circles.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Circle count, each circle coordinates in pixels and circle color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_circles(unsigned int h, struct circles_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_CIRCLES;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct circles_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw array of circles with anti-aliasing.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Circle count, each circle coordinates in pixels and circle color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_circles_aa(unsigned int h, struct circles_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_CIRCLES_AA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct circles_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw array of circles with alpha channel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Circle count, each circle coordinates in pixels and circle color
 *
 */

#if ! defined(PROG_DISABLE_DRAW)
void gui_draw_circles_alpha(unsigned int h, struct circles_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_CIRCLES_ALPHA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct circles_2);

	(void) window_cmd_push(&c);
}
#endif

/**
 * @brief Draw text.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Text coordinates in pixels and font handle returned by fonts_open()
 *
 */

void gui_draw_text(unsigned int h, struct text_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_TEXT;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct text_2);

	(void) window_cmd_push(&c);
}

/**
 * @brief Draw array of texts.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Text count, each text coordinates in pixels and font handle returned by fonts_open()
 *
 */

void gui_draw_texts(unsigned int h, struct texts_2 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_TEXTS;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct texts_2);

	(void) window_cmd_push(&c);
}

/**
 * @brief Set (fill) content of region.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to set, returned by gui_window_open()
 * @param[in] p Fill region coordinates in pixels and region color
 *
 */

void gui_draw_set(unsigned int h, struct point_4 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_SET;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct point_4);

	(void) window_cmd_push(&c);
}

/**
 * @brief Set (fill) content of region with alpha channel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to set, returned by gui_window_open()
 * @param[in] p Fill region coordinates in pixels, region color and alpha value
 *
 */

void gui_draw_set_alpha(unsigned int h, struct point_4 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_SET_ALPHA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct point_4);

	(void) window_cmd_push(&c);
}

/**
 * @brief Draw rectangular border.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Border coordinates in pixels, border color and border thickness in pixels
 *
 */

void gui_draw_border(unsigned int h, struct border_4 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_BORDER;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct border_4);

	(void) window_cmd_push(&c);
}

/**
 * @brief Draw rectangular border with alpha channel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to draw, returned by gui_window_open()
 * @param[in] p Border coordinates in pixels, border color, alpha value and border thickness in pixels
 *
 */

void gui_draw_border_alpha(unsigned int h, struct border_4 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_BORDER_ALPHA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct border_4);

	(void) window_cmd_push(&c);
}

/**
 * @brief Copy region.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle where to copy, returned by gui_window_open()
 * @param[in] p Region source buffer, coordinates and region size in pixels
 *
 */

void gui_draw_copy(unsigned int h, struct region_copy_8 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_COPY;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct region_copy_8);

	(void) window_cmd_push(&c);
}

/**
 * @brief Copy region with alpha channel.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle where to copy, returned by gui_window_open()
 * @param[in] p Region source buffer, coordinates and region size in pixels and region alpha value
 *
 */

void gui_draw_copy_alpha(unsigned int h, struct region_copy_8 *p) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_COPY_ALPHA;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) p;
	c.t = sizeof(struct region_copy_8);

	(void) window_cmd_push(&c);
}

/**
 * @brief Wipe (set to zero) active window area.
 *
 * Unlike draw_*() functions, this function returns immediately and drawing operation actually takes
 * place when drawing request pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to wipe, returned by gui_window_open()
 *
 */

void gui_draw_wipe(unsigned int h) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_DRAW_WIPE;
	c.e = IS_NO;
	c.h = h;
	c.p = NULL;
	c.t = 0;

	(void) window_cmd_push(&c);
}

/**
 * @brief Open new window.
 *
 * cb_open_notify() is called when window is opened. New window handle is passed as a parameter to this
 * callback function, and callback should store it for later use. If opening the window fails, callback
 * function gets zero as a parameter, values other than zero indicates succesfully opened window.
 * gui_window_close() should be called when window is no longer needed. Call gui_window_map() to map the
 * window on screen.
 *
 * This function returns immediately and window opening actually takes place when drawing request
 * pipeline is flushed somewhere in near future.
 *
 * @param[in] w Window info structure
 *
 */

void gui_window_open(struct w_ctx *w) {
	struct w_cmd c;
	struct w_ctx *p;

	APP_MALLOC_RET_VOID(p, sizeof(struct w_ctx));

	/* Set window title and title charset */
	if(w->s == NULL) p->s = NULL;
	else {
		if((p->s = gui_window_open_op(w->s)) == NULL) {
			(void) free(p);

			return;
		}
	}

	if(w->c == NULL) p->c = NULL;
	else {
		if((p->c = gui_window_open_op(w->c)) == NULL) {
			(void) free(p->s);
			(void) free(p);

			return;
		}
	}

	/* Set window variables */
	p->r = w->r;
	p->p = w->p;
	p->e = w->e;
	p->m = w->m;

	p->x = w->x;
	p->y = w->y;

	p->w = w->w;
	p->h = w->h;

	/* Set window callback functions and their parameters */
	p->cb_main_loop = w->cb_main_loop;

	p->cb_expose = w->cb_expose;

	p->cb_key_press = w->cb_key_press;
	p->cb_key_release = w->cb_key_release;
	p->cb_button_press = w->cb_button_press;
	p->cb_button_release = w->cb_button_release;

	p->cb_client_message = w->cb_client_message;

	p->cb_configure_notify = w->cb_configure_notify;
	p->cb_destroy_notify = w->cb_destroy_notify;
	p->cb_motion_notify = w->cb_motion_notify;
	p->cb_map_notify = w->cb_map_notify;
	p->cb_unmap_notify = w->cb_unmap_notify;

	p->cb_open_notify = w->cb_open_notify;

	/* window_close() frees allocated stuff */
	p->par_main_loop.s = gui_window_open_op(w->par_main_loop.s);
	p->par_main_loop.n = w->par_main_loop.n;

	p->par_expose.s = gui_window_open_op(w->par_expose.s);
	p->par_expose.n = w->par_expose.n;

	p->par_key_press.s = gui_window_open_op(w->par_key_press.s);
	p->par_key_press.n = w->par_key_press.n;
	p->par_key_release.s = gui_window_open_op(w->par_key_release.s);
	p->par_key_release.n = w->par_key_release.n;
	p->par_button_press.s = gui_window_open_op(w->par_button_press.s);
	p->par_button_press.n = w->par_button_press.n;
	p->par_button_release.s = gui_window_open_op(w->par_button_release.s);
	p->par_button_release.n = w->par_button_release.n;

	p->par_client_message.s = gui_window_open_op(w->par_client_message.s);
	p->par_client_message.n = w->par_client_message.n;

	p->par_configure_notify.s = gui_window_open_op(w->par_configure_notify.s);
	p->par_configure_notify.n = w->par_configure_notify.n;
	p->par_destroy_notify.s = gui_window_open_op(w->par_destroy_notify.s);
	p->par_destroy_notify.n = w->par_destroy_notify.n;
	p->par_motion_notify.s = gui_window_open_op(w->par_motion_notify.s);
	p->par_motion_notify.n = w->par_motion_notify.n;
	p->par_map_notify.s = gui_window_open_op(w->par_map_notify.s);
	p->par_map_notify.n = w->par_map_notify.n;
	p->par_unmap_notify.s = gui_window_open_op(w->par_unmap_notify.s);
	p->par_unmap_notify.n = w->par_unmap_notify.n;

	p->par_open_notify.s = gui_window_open_op(w->par_open_notify.s);
	p->par_open_notify.n = w->par_open_notify.n;

	c.c = WINDOW_COMMAND_WINDOW_OPEN;
	c.e = IS_NO;
	c.h = 0;
	c.p = (void *) p;
	c.t = sizeof(struct w_ctx);

	if(window_cmd_push(&c) != 0) {
		if(p->s != NULL) (void) free(p->s);
		if(p->c != NULL) (void) free(p->c);

		if(p->par_main_loop.s != NULL) (void) free(p->par_main_loop.s);

		if(p->par_expose.s != NULL) (void) free(p->par_expose.s);

		if(p->par_key_press.s != NULL) (void) free(p->par_key_press.s);
		if(p->par_key_release.s != NULL) (void) free(p->par_key_release.s);
		if(p->par_button_press.s != NULL) (void) free(p->par_button_press.s);
		if(p->par_button_release.s != NULL) (void) free(p->par_button_release.s);

		if(p->par_client_message.s != NULL) (void) free(p->par_client_message.s);

		if(p->par_configure_notify.s != NULL) (void) free(p->par_configure_notify.s);
		if(p->par_destroy_notify.s != NULL) (void) free(p->par_destroy_notify.s);
		if(p->par_motion_notify.s != NULL) (void) free(p->par_motion_notify.s);
		if(p->par_map_notify.s != NULL) (void) free(p->par_map_notify.s);
		if(p->par_unmap_notify.s != NULL) (void) free(p->par_unmap_notify.s);

		if(p->par_open_notify.s != NULL) (void) free(p->par_open_notify.s);
	}

	(void) free(p);
}

static char *gui_window_open_op(char *s) {
	char *p;

	size_t t;

	if(s == NULL) return(NULL);

	t = str_len(s, STRING_ASCII);

	APP_MALLOC_RET_VALUE(p, t + sizeof(char), NULL);

	(void) memcpy((void *) p, (const void *) s, t);

	p[t] = 0;

	return(p);
}

/**
 * @brief Set window icon.
 *
 * Set icon image for window to be displayed on desktop when window is iconified.
 *
 * This function returns immediately and icon creation actually takes place when drawing request
 * pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to set icon, returned by gui_window_open()
 * @param[in] s Icon file name
 *
 */

void gui_window_icon(unsigned int h, char *s) {
	struct w_cmd c;

	/* Add one extra char to string length for terminating null byte */
	c.c = WINDOW_COMMAND_WINDOW_ICON;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) s;
	c.t = str_len(s, STRING_ASCII) + sizeof(char);

	(void) window_cmd_push(&c);
}

/**
 * @brief Close window.
 *
 * Close previously opended window and free all its internal resources. After command completes,
 * window is gone for good and handle should not be used anymore.
 *
 * This function returns immediately and window closing actually takes place when drawing request
 * pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to close, returned by gui_window_open()
 *
 */

void gui_window_close(unsigned int h) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_WINDOW_CLOSE;
	c.e = IS_NO;
	c.h = h;
	c.p = NULL;
	c.t = 0;

	(void) window_cmd_push(&c);
}

/**
 * @brief Map (show) window.
 *
 * Display opened window.
 *
 * This function returns immediately and window mapping actually takes place when drawing request
 * pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to map, returned by gui_window_open()
 *
 */

void gui_window_map(unsigned int h) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_WINDOW_MAP;
	c.e = IS_NO;
	c.h = h;
	c.p = NULL;
	c.t = 0;

	(void) window_cmd_push(&c);
}

/**
 * @brief Unmap (hide) window.
 *
 * Hide already mapped window.
 *
 * This function returns immediately and window unmapping actually takes place when drawing request
 * pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to unmap, returned by gui_window_open()
 *
 */

void gui_window_unmap(unsigned int h) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_WINDOW_UNMAP;
	c.e = IS_NO;
	c.h = h;
	c.p = NULL;
	c.t = 0;

	(void) window_cmd_push(&c);
}

/**
 * @brief Set window attributes.
 *
 * Set window internal attributes.
 *
 * This function returns immediately and setting attributes actually takes place when drawing request
 * pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to set, returned by gui_window_open()
 * @param[in] w Window attribute structure
 *
 */

void gui_window_set_attrs(unsigned int h, struct w_att *w) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_WINDOW_SET_ATTRS;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) w;
	c.t = sizeof(struct w_att);

	(void) window_cmd_push(&c);
}

/**
 * @brief Refresh window.
 *
 * Refresh (redraw) previously opened window.
 *
 * This function returns immediately and window closing actually takes place when drawing request
 * pipeline is flushed somewhere in near future.
 *
 * @param[in] h Window handle to refresh, returned by gui_window_open()
 * @param[in] w Window area to be refreshed
 *
 */

void gui_window_refresh(unsigned int h, struct clip_2 *w) {
	struct w_cmd c;

	c.c = WINDOW_COMMAND_WINDOW_REFRESH;
	c.e = IS_NO;
	c.h = h;
	c.p = (void *) w;
	c.t = sizeof(struct clip_2);

	(void) window_cmd_push(&c);
}
#endif