archive/guilib/window_gtk.c

/*
 *  window_gtk.c -- window handling, GTK
 */

#include "gui.h"

signed int gui_window_origin_x, gui_window_origin_y;
GtkWidget *gui_redraw_widget;
gui_window_id menu_window_id;


gboolean gui_window_press(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
  gui_window_id window_id;

  printf("gui_window_press: widget 0x%x, type %i, win 0x%x, %f %f, %i, data 0x%x\n",
        (unsigned int) widget, event->type, (unsigned int) event->window, event->x, event->y, event->button, (unsigned int) data);

  window_id = gui_handle_to_window_id(data);

  if (window_id != gui_WINDOW_UNKNOWN)
  {
    assert(window_id < gui_window_list_items && gui_window_list[window_id].used);
    if (gui_window_list[window_id].menu && event->button == 2)
    {
      gtk_menu_popup(gui_window_list[window_id].menu->menu, NULL, NULL, NULL,
                     NULL, event->button, event->time);
      menu_window_id = window_id;
    }
    else if (gui_window_list[window_id].click_fn)
    {
      unsigned int z;

      z = (event->button == 1 ? gui_CLICK :
          (event->button == 3 ? gui_CLICK_RIGHT : 0));
      gui_window_list[window_id].click_fn(window_id, event->x * 2, event->y * 2, z);
    }
  }

}


gboolean gui_expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
  gui_window_id window_id;
  signed int invalid[4];

  window_id = gui_handle_to_window_id(data);

  gui_window_origin_x = 0;
  gui_window_origin_y = 0;
  gui_redraw_widget = widget;
  invalid[0] = event->area.x * 2;
  invalid[1] = event->area.y * 2;
  invalid[2] = (event->area.x + event->area.width) * 2;
  invalid[3] = (event->area.y + event->area.height) * 2;

  gdk_window_clear_area(widget->window, event->area.x, event->area.y, event->area.width, event->area.height);
  gdk_gc_set_clip_rectangle(widget->style->white_gc, &event->area);

  printf("gui_expose_event: id %i, rect %i %i %i %i\n", window_id,
        invalid[0], invalid[1], invalid[2], invalid[3]);

  gui_window_list[window_id].redraw_fn(window_id, invalid);

  gdk_gc_set_clip_rectangle(widget->style->white_gc, NULL);

  return TRUE;
}


void gui_size_allocate(GtkWidget *widget, GtkAllocation *allocation, gpointer data)
{
  gui_window_id window_id;

  window_id = gui_handle_to_window_id(data);
  printf("gui_size_allocate: id %i, %i %i %u %u\n", window_id, allocation->x, allocation->y, allocation->width, allocation->height);
  gui_window_list[window_id].resize_fn(window_id, allocation->width * 2, allocation->height * 2);
}


/*
 *  gui_create_window -- create and display a window
 *
 *  => flags -- window details
 *     title -- window title
 *     width -- width of window
 *     height -- height of window
 *     close_fn -- function called when an attempt is made to close the window,
 *                 NULL for default of closing and destroying window
 *     redraw_fn -- function called when the window needs redrawing
 *     click_fn -- function called when the mouse is clicked in the window or equivalent,
 *                 NULL for default of no action
 *
 *  <= window id
 */

gui_window_id gui_create_window(const unsigned int flags,
      char *title,
      const unsigned int width, const unsigned int height,
      void (*close_fn)(gui_window_id window_id),
      void (*redraw_fn)(gui_window_id window_id, unsigned int invalid[]),
      void (*click_fn)(gui_window_id window_id, unsigned int x, unsigned int y,
            unsigned int z),
      void (*resize_fn)(gui_window_id window_id, unsigned int width, unsigned int height),
      bool (*key_fn)(gui_window_id window_id, unsigned int key),
      void (*input_fn)(gui_window_id window_id, wchar_t key),
      void (*menu_fn)(gui_window_id window_id, unsigned int items[]),
      struct gui_menu_data *menu,
      const char *bbar,
      const char *help)
{
  GtkWidget *window;
  GtkWidget *scrolled_window;
  GtkWidget *event_box;
  GtkWidget *drawing_area;
  gui_window_id id;

  #ifdef DEBUG
  printf("gui_create_window: title = '%s'\n", title);
  fflush(stdout);
  #endif

  assert(redraw_fn != NULL);

  id = gui_get_free_window_id();

  drawing_area = gtk_drawing_area_new();
  event_box = gtk_event_box_new();
  scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

  gtk_drawing_area_size(drawing_area, flags & gui_H_SCROLL_BAR ? width / 2 : 0, flags & gui_V_SCROLL_BAR ? height / 2 : 0);

  gtk_container_set_border_width(GTK_CONTAINER (scrolled_window), 0);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

  gtk_window_set_title(GTK_WINDOW (window), title);
  gtk_container_set_border_width(GTK_CONTAINER (window), 0);

  gtk_container_add(GTK_CONTAINER (event_box), drawing_area);
  gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW (scrolled_window), event_box);
  gtk_container_add(GTK_CONTAINER (window), scrolled_window);

  gtk_widget_show(drawing_area);
  gtk_widget_show(event_box);
  gtk_widget_show(scrolled_window);
  gtk_widget_show(window);

  gui_window_list[id].used = 1;
  gui_window_list[id].handle = window;
  gui_window_list[id].close_fn = (close_fn == NULL ? gui_remove_window : close_fn);
  gui_window_list[id].redraw_fn = redraw_fn;
  gui_window_list[id].click_fn = click_fn;
  gui_window_list[id].resize_fn = resize_fn;
  gui_window_list[id].key_fn = key_fn;
  gui_window_list[id].input_fn = input_fn;
  gui_window_list[id].menu_fn = menu_fn;
  gui_window_list[id].width = width;
  gui_window_list[id].height = height;
  gui_window_list[id].menu = menu;
  gui_window_list[id].help = help;
  gui_window_list[id].drawing_area = drawing_area;

  gtk_signal_connect(event_box, "button-press-event", gui_window_press, window);
  gtk_signal_connect(drawing_area, "expose-event", gui_expose_event, window);
  gtk_signal_connect(drawing_area, "size-allocate", gui_size_allocate, window);

  #ifdef DEBUG
  printf("gui_create_window: id = 0x%x, handle = 0x%x\n", id, (unsigned int) window);
  fflush(stdout);
  #endif

  return id;
}


/*
 *  gui_get_free_window_id -- allocate space and return a window id
 *
 *  => nothing
 *
 *  <= window id (gui_window_list index)
 */

gui_window_id gui_get_free_window_id()
{
  static struct gui_window_data *new_gui_window_list;
  int i;

  #ifdef DEBUG
  printf("gui_get_free_window_id: gui_window_list_items = %i\n", gui_window_list_items);
  fflush(stdout);
  #endif

  for (i = 0; i < gui_window_list_items; i++)
  {
    if (!gui_window_list[i].used)
    {
      assert(i >= 0 && i < gui_window_list_items);
      return i;
    }
  }

  new_gui_window_list = realloc(gui_window_list,
                            sizeof(struct gui_window_data) * (gui_window_list_items + WINDOW_LIST_CHUNK));
  if (!new_gui_window_list) gui_raise_error("memory");

  gui_window_list = new_gui_window_list;
  for (i = gui_window_list_items; i < gui_window_list_items + WINDOW_LIST_CHUNK; i++)
    gui_window_list[i].used = 0;

  i = gui_window_list_items;
  gui_window_list_items += WINDOW_LIST_CHUNK;

  #ifdef DEBUG
  printf("gui_get_free_window_id: increased gui_window_list_items = %i\n", gui_window_list_items);
  fflush(stdout);
  #endif

  assert(i >= 0 && i < gui_window_list_items);
  return i;
}


/*
 *  gui_handle_to_window_id -- convert a window handle to a window id
 *
 *  => handle -- wimp window handle
 *
 *  <= window id
 */

gui_window_id gui_handle_to_window_id(GtkWidget *handle)
{
  int i;

  for (i = 0; i < gui_window_list_items; i++)
  {
    if ((gui_window_list[i].used) && (gui_window_list[i].handle == handle))
    {

      #ifdef DEBUG
      printf("gui_handle_to_window_id: handle = 0x%x, id = 0x%x\n", (unsigned int) handle, i);
      fflush(stdout);
      #endif
      return i;
    }
  }

  return gui_WINDOW_UNKNOWN;
}


/*
 *  gui_remove_window -- close and destroy a window
 *
 *  => window_id -- window id from gui_create_window
 *
 *  <= nothing
 */

void gui_remove_window(const gui_window_id window_id)
{
  assert(window_id >= 0 && window_id < gui_window_list_items && gui_window_list[window_id].used);

  #ifdef DEBUG
  printf("gui_remove_window: window_id = 0x%x\n", window_id);
  fflush(stdout);
  #endif

/*   gui_error = xwimp_delete_window(gui_window_list[window_id].handle);
 *   gui_check_error();
 *   gui_window_list[window_id].used = 0;
 */
}


/*
 *  gui_refresh_window -- update a window's contents
 *
 *  => window_id -- window id from gui_create_window
 *
 *  <= nothing
 */

void gui_refresh_window(const gui_window_id window_id)
{
  assert(window_id >= 0 && window_id < gui_window_list_items && gui_window_list[window_id].used);

  #ifdef DEBUG
  printf("gui_refresh_window: window_id = 0x%x\n", window_id);
  fflush(stdout);
  #endif

/*   gui_refresh_box(window_id, 0, 0, gui_window_list[window_id].width, gui_window_list[window_id].height);  */
}


/*
 *  gui_refresh_box -- update part of a window's contents
 *
 *  => window_id -- window id from gui_create_window
 *     x0, y0, x1, y1 -- area to update
 *
 *  <= nothing
 */

void gui_refresh_box(const gui_window_id window_id, unsigned int x0, unsigned int y0,
                     unsigned int x1, unsigned int y1)
{
  signed int invalid[4];
  bool more;
/*   wimp_window_state state;
 *   wimp_draw update;
 */

  assert(window_id >= 0 && window_id < gui_window_list_items && gui_window_list[window_id].used);

  #ifdef DEBUG
  printf("gui_refresh_box: window_id = 0x%x, box %i %i %i %i\n", window_id, x0, y0, x1, y1);
  fflush(stdout);
  #endif

/*   state.w = gui_window_list[window_id].handle;
 *
 *   gui_error = xwimp_get_window_state(&state);
 *   gui_check_error();
 *
 *   gui_window_origin_x = state.visible.x0 - state.xscroll;
 *   gui_window_origin_y = state.visible.y1 - state.yscroll;
 *
 *   #ifdef DEBUG
 *   printf("gui_refresh_box: redraw origin %i %i\n", gui_window_origin_x, gui_window_origin_y);
 *   fflush(stdout);
 *   #endif
 *
 *   update.w = state.w;
 *   update.box.x0 = x0;
 *   update.box.y0 = -y1;
 *   update.box.x1 = x1;
 *   update.box.y1 = -y0;
 *   gui_error = xwimp_update_window(&update, &more);
 *   gui_check_error();
 *
 *   while (more)
 *   {
 *     invalid[0] = update.clip.x0 - gui_window_origin_x;
 *     invalid[1] = gui_window_origin_y - update.clip.y1;
 *     invalid[2] = update.clip.x1 - gui_window_origin_x;
 *     invalid[3] = gui_window_origin_y - update.clip.y0;
 *
 *     #ifdef DEBUG
 *     printf("gui_refresh_box: redraw invalid %i %i %i %i\n",
 *             invalid[0], invalid[1], invalid[2], invalid[3]);
 *     fflush(stdout);
 *     #endif
 *
 *     gui_window_list[window_id].redraw_fn(window_id, invalid);
 *
 *     gui_error = xwimp_get_rectangle(&update, &more);
 *     gui_check_error();
 *   }
 */
}


/*
 *  gui_window_extent -- set window size
 *
 *  => window_id -- window id from gui_create_window
 *     width, height -- new dimensions of window
 *
 *  <= nothing
 */

void gui_window_extent(const gui_window_id window_id, unsigned int width, unsigned int height)
{
  assert(window_id >= 0 && window_id < gui_window_list_items && gui_window_list[window_id].used);

  #ifdef DEBUG
  printf("gui_window_extent: window_id = 0x%x, extent = %i x %i\n", window_id, width, height);
  fflush(stdout);
  #endif

  gtk_drawing_area_size(gui_window_list[window_id].drawing_area, width / 2, height / 2);

  gui_window_list[window_id].width = width;
  gui_window_list[window_id].height = height;
}


/*
 *  gui_fill -- fill a rectangular area during window redraw
 *
 *  => colour -- 0xbbggrr format colour
 *     x0, y0, x1, y1 -- coordinates of rectangle
 */

void gui_fill(unsigned int colour, unsigned int x0, unsigned int y0, unsigned int x1, unsigned int y1)
{
  GdkColor gdk_colour;

  printf("gui_fill: box %i %i %i %i\n", x0, y0, x1, y1);

  BGR_TO_GDK(colour, gdk_colour);
  gdk_colormap_alloc_color(gdk_window_get_colormap(gui_redraw_widget->window), &gdk_colour, FALSE, TRUE);
  gdk_gc_set_foreground(gui_redraw_widget->style->fg_gc[gui_redraw_widget->state], &gdk_colour);

  gdk_draw_rectangle(gui_redraw_widget->window, gui_redraw_widget->style->fg_gc[gui_redraw_widget->state],
        TRUE, x0 / 2, y0 / 2, (x1-x0) / 2, (y1-y0) / 2);
}


/*
 *  gui_move_box -- copy a rectangular area within a window
 *
 *  => window_id -- window id from gui_create_window
 *     x0, y0, x1, y1 -- source area
 *     x2, y2 -- destination
 */

void gui_move_box(const gui_window_id window_id, unsigned int x0, unsigned int y0,
                  unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2)
{

  assert(window_id >= 0 && window_id < gui_window_list_items && gui_window_list[window_id].used);

  #ifdef DEBUG
  printf("gui_move_box: window_id = 0x%x, box = %i %i %i %i, dest = %i %i\n",
         window_id, x0, y0, x1, y1, x2, y2);
  fflush(stdout);
  #endif

/*   gui_error = xwimp_block_copy(gui_window_list[window_id].handle, x0, -y1, x1, -y0, x2, -(y1 + (y2 - y0)));
 *   gui_check_error();
 */
}
1	/*
2	* window_gtk.c -- window handling, GTK
3	*/
4
5	#include "gui.h"
6
7	signed int gui_window_origin_x, gui_window_origin_y;
8	GtkWidget *gui_redraw_widget;
9	gui_window_id menu_window_id;
10
11
12	gboolean gui_window_press(GtkWidget widget, GdkEventButton event, gpointer data)
13	{
14	gui_window_id window_id;
15
16	printf("gui_window_press: widget 0x%x, type %i, win 0x%x, %f %f, %i, data 0x%x\n",
17	(unsigned int) widget, event->type, (unsigned int) event->window, event->x, event->y, event->button, (unsigned int) data);
18
19	window_id = gui_handle_to_window_id(data);
20
21	if (window_id != gui_WINDOW_UNKNOWN)
22	{
23	assert(window_id < gui_window_list_items && gui_window_list[window_id].used);
24	if (gui_window_list[window_id].menu && event->button == 2)
25	{
26	gtk_menu_popup(gui_window_list[window_id].menu->menu, NULL, NULL, NULL,
27	NULL, event->button, event->time);
28	menu_window_id = window_id;
29	}
30	else if (gui_window_list[window_id].click_fn)
31	{
32	unsigned int z;
33
34	z = (event->button == 1 ? gui_CLICK :
35	(event->button == 3 ? gui_CLICK_RIGHT : 0));
36	gui_window_list[window_id].click_fn(window_id, event->x * 2, event->y * 2, z);
37	}
38	}
39
40	}
41
42
43
44	gboolean gui_expose_event(GtkWidget widget, GdkEventExpose event, gpointer data)
45	{
46	gui_window_id window_id;
47	signed int invalid[4];
48
49	window_id = gui_handle_to_window_id(data);
50
51	gui_window_origin_x = 0;
52	gui_window_origin_y = 0;
53	gui_redraw_widget = widget;
54	invalid[0] = event->area.x * 2;
55	invalid[1] = event->area.y * 2;
56	invalid[2] = (event->area.x + event->area.width) * 2;
57	invalid[3] = (event->area.y + event->area.height) * 2;
58
59	gdk_window_clear_area(widget->window, event->area.x, event->area.y, event->area.width, event->area.height);
60	gdk_gc_set_clip_rectangle(widget->style->white_gc, &event->area);
61
62	printf("gui_expose_event: id %i, rect %i %i %i %i\n", window_id,
63	invalid[0], invalid[1], invalid[2], invalid[3]);
64
65	gui_window_list[window_id].redraw_fn(window_id, invalid);
66
67	gdk_gc_set_clip_rectangle(widget->style->white_gc, NULL);
68
69	return TRUE;
70	}
71
72
73	void gui_size_allocate(GtkWidget widget, GtkAllocation allocation, gpointer data)
74	{
75	gui_window_id window_id;
76
77	window_id = gui_handle_to_window_id(data);
78	printf("gui_size_allocate: id %i, %i %i %u %u\n", window_id, allocation->x, allocation->y, allocation->width, allocation->height);
79	gui_window_list[window_id].resize_fn(window_id, allocation->width * 2, allocation->height * 2);
80	}
81
82
83
84	/*
85	* gui_create_window -- create and display a window
86	*
87	* => flags -- window details
88	* title -- window title
89	* width -- width of window
90	* height -- height of window
91	* close_fn -- function called when an attempt is made to close the window,
92	* NULL for default of closing and destroying window
93	* redraw_fn -- function called when the window needs redrawing
94	* click_fn -- function called when the mouse is clicked in the window or equivalent,
95	* NULL for default of no action
96	*
97	* <= window id
98	*/
99
100	gui_window_id gui_create_window(const unsigned int flags,
101	char *title,
102	const unsigned int width, const unsigned int height,
103	void (*close_fn)(gui_window_id window_id),
104	void (*redraw_fn)(gui_window_id window_id, unsigned int invalid[]),
105	void (*click_fn)(gui_window_id window_id, unsigned int x, unsigned int y,
106	unsigned int z),
107	void (*resize_fn)(gui_window_id window_id, unsigned int width, unsigned int height),
108	bool (*key_fn)(gui_window_id window_id, unsigned int key),
109	void (*input_fn)(gui_window_id window_id, wchar_t key),
110	void (*menu_fn)(gui_window_id window_id, unsigned int items[]),
111	struct gui_menu_data *menu,
112	const char *bbar,
113	const char *help)
114	{
115	GtkWidget *window;
116	GtkWidget *scrolled_window;
117	GtkWidget *event_box;
118	GtkWidget *drawing_area;
119	gui_window_id id;
120
121	#ifdef DEBUG
122	printf("gui_create_window: title = '%s'\n", title);
123	fflush(stdout);
124	#endif
125
126	assert(redraw_fn != NULL);
127
128	id = gui_get_free_window_id();
129
130	drawing_area = gtk_drawing_area_new();
131	event_box = gtk_event_box_new();
132	scrolled_window = gtk_scrolled_window_new(NULL, NULL);
133	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
134
135	gtk_drawing_area_size(drawing_area, flags & gui_H_SCROLL_BAR ? width / 2 : 0, flags & gui_V_SCROLL_BAR ? height / 2 : 0);
136
137	gtk_container_set_border_width(GTK_CONTAINER (scrolled_window), 0);
138	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
139
140	gtk_window_set_title(GTK_WINDOW (window), title);
141	gtk_container_set_border_width(GTK_CONTAINER (window), 0);
142
143	gtk_container_add(GTK_CONTAINER (event_box), drawing_area);
144	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW (scrolled_window), event_box);
145	gtk_container_add(GTK_CONTAINER (window), scrolled_window);
146
147	gtk_widget_show(drawing_area);
148	gtk_widget_show(event_box);
149	gtk_widget_show(scrolled_window);
150	gtk_widget_show(window);
151
152	gui_window_list[id].used = 1;
153	gui_window_list[id].handle = window;
154	gui_window_list[id].close_fn = (close_fn == NULL ? gui_remove_window : close_fn);
155	gui_window_list[id].redraw_fn = redraw_fn;
156	gui_window_list[id].click_fn = click_fn;
157	gui_window_list[id].resize_fn = resize_fn;
158	gui_window_list[id].key_fn = key_fn;
159	gui_window_list[id].input_fn = input_fn;
160	gui_window_list[id].menu_fn = menu_fn;
161	gui_window_list[id].width = width;
162	gui_window_list[id].height = height;
163	gui_window_list[id].menu = menu;
164	gui_window_list[id].help = help;
165	gui_window_list[id].drawing_area = drawing_area;
166
167	gtk_signal_connect(event_box, "button-press-event", gui_window_press, window);
168	gtk_signal_connect(drawing_area, "expose-event", gui_expose_event, window);
169	gtk_signal_connect(drawing_area, "size-allocate", gui_size_allocate, window);
170
171	#ifdef DEBUG
172	printf("gui_create_window: id = 0x%x, handle = 0x%x\n", id, (unsigned int) window);
173	fflush(stdout);
174	#endif
175
176	return id;
177	}
178
179
180	/*
181	* gui_get_free_window_id -- allocate space and return a window id
182	*
183	* => nothing
184	*
185	* <= window id (gui_window_list index)
186	*/
187
188	gui_window_id gui_get_free_window_id()
189	{
190	static struct gui_window_data *new_gui_window_list;
191	int i;
192
193	#ifdef DEBUG
194	printf("gui_get_free_window_id: gui_window_list_items = %i\n", gui_window_list_items);
195	fflush(stdout);
196	#endif
197
198	for (i = 0; i < gui_window_list_items; i++)
199	{
200	if (!gui_window_list[i].used)
201	{
202	assert(i >= 0 && i < gui_window_list_items);
203	return i;
204	}
205	}
206
207	new_gui_window_list = realloc(gui_window_list,
208	sizeof(struct gui_window_data) * (gui_window_list_items + WINDOW_LIST_CHUNK));
209	if (!new_gui_window_list) gui_raise_error("memory");
210
211	gui_window_list = new_gui_window_list;
212	for (i = gui_window_list_items; i < gui_window_list_items + WINDOW_LIST_CHUNK; i++)
213	gui_window_list[i].used = 0;
214
215	i = gui_window_list_items;
216	gui_window_list_items += WINDOW_LIST_CHUNK;
217
218	#ifdef DEBUG
219	printf("gui_get_free_window_id: increased gui_window_list_items = %i\n", gui_window_list_items);
220	fflush(stdout);
221	#endif
222
223	assert(i >= 0 && i < gui_window_list_items);
224	return i;
225	}
226
227
228	/*
229	* gui_handle_to_window_id -- convert a window handle to a window id
230	*
231	* => handle -- wimp window handle
232	*
233	* <= window id
234	*/
235
236	gui_window_id gui_handle_to_window_id(GtkWidget *handle)
237	{
238	int i;
239
240	for (i = 0; i < gui_window_list_items; i++)
241	{
242	if ((gui_window_list[i].used) && (gui_window_list[i].handle == handle))
243	{
244
245	#ifdef DEBUG
246	printf("gui_handle_to_window_id: handle = 0x%x, id = 0x%x\n", (unsigned int) handle, i);
247	fflush(stdout);
248	#endif
249	return i;
250	}
251	}
252
253	return gui_WINDOW_UNKNOWN;
254	}
255
256
257	/*
258	* gui_remove_window -- close and destroy a window
259	*
260	* => window_id -- window id from gui_create_window
261	*
262	* <= nothing
263	*/
264
265	void gui_remove_window(const gui_window_id window_id)
266	{
267	assert(window_id >= 0 && window_id < gui_window_list_items && gui_window_list[window_id].used);
268
269	#ifdef DEBUG
270	printf("gui_remove_window: window_id = 0x%x\n", window_id);
271	fflush(stdout);
272	#endif
273
274	/* gui_error = xwimp_delete_window(gui_window_list[window_id].handle);
275	* gui_check_error();
276	* gui_window_list[window_id].used = 0;
277	*/
278	}
279
280
281	/*
282	* gui_refresh_window -- update a window's contents
283	*
284	* => window_id -- window id from gui_create_window
285	*
286	* <= nothing
287	*/
288
289	void gui_refresh_window(const gui_window_id window_id)
290	{
291	assert(window_id >= 0 && window_id < gui_window_list_items && gui_window_list[window_id].used);
292
293	#ifdef DEBUG
294	printf("gui_refresh_window: window_id = 0x%x\n", window_id);
295	fflush(stdout);
296	#endif
297
298	/* gui_refresh_box(window_id, 0, 0, gui_window_list[window_id].width, gui_window_list[window_id].height); */
299	}
300
301
302	/*
303	* gui_refresh_box -- update part of a window's contents
304	*
305	* => window_id -- window id from gui_create_window
306	* x0, y0, x1, y1 -- area to update
307	*
308	* <= nothing
309	*/
310
311	void gui_refresh_box(const gui_window_id window_id, unsigned int x0, unsigned int y0,
312	unsigned int x1, unsigned int y1)
313	{
314	signed int invalid[4];
315	bool more;
316	/* wimp_window_state state;
317	* wimp_draw update;
318	*/
319
320	assert(window_id >= 0 && window_id < gui_window_list_items && gui_window_list[window_id].used);
321
322	#ifdef DEBUG
323	printf("gui_refresh_box: window_id = 0x%x, box %i %i %i %i\n", window_id, x0, y0, x1, y1);
324	fflush(stdout);
325	#endif
326
327	/* state.w = gui_window_list[window_id].handle;
328	*
329	* gui_error = xwimp_get_window_state(&state);
330	* gui_check_error();
331	*
332	* gui_window_origin_x = state.visible.x0 - state.xscroll;
333	* gui_window_origin_y = state.visible.y1 - state.yscroll;
334	*
335	* #ifdef DEBUG
336	* printf("gui_refresh_box: redraw origin %i %i\n", gui_window_origin_x, gui_window_origin_y);
337	* fflush(stdout);
338	* #endif
339	*
340	* update.w = state.w;
341	* update.box.x0 = x0;
342	* update.box.y0 = -y1;
343	* update.box.x1 = x1;
344	* update.box.y1 = -y0;
345	* gui_error = xwimp_update_window(&update, &more);
346	* gui_check_error();
347	*
348	* while (more)
349	* {
350	* invalid[0] = update.clip.x0 - gui_window_origin_x;
351	* invalid[1] = gui_window_origin_y - update.clip.y1;
352	* invalid[2] = update.clip.x1 - gui_window_origin_x;
353	* invalid[3] = gui_window_origin_y - update.clip.y0;
354	*
355	* #ifdef DEBUG
356	* printf("gui_refresh_box: redraw invalid %i %i %i %i\n",
357	* invalid[0], invalid[1], invalid[2], invalid[3]);
358	* fflush(stdout);
359	* #endif
360	*
361	* gui_window_list[window_id].redraw_fn(window_id, invalid);
362	*
363	* gui_error = xwimp_get_rectangle(&update, &more);
364	* gui_check_error();
365	* }
366	*/
367	}
368
369
370	/*
371	* gui_window_extent -- set window size
372	*
373	* => window_id -- window id from gui_create_window
374	* width, height -- new dimensions of window
375	*
376	* <= nothing
377	*/
378
379	void gui_window_extent(const gui_window_id window_id, unsigned int width, unsigned int height)
380	{
381	assert(window_id >= 0 && window_id < gui_window_list_items && gui_window_list[window_id].used);
382
383	#ifdef DEBUG
384	printf("gui_window_extent: window_id = 0x%x, extent = %i x %i\n", window_id, width, height);
385	fflush(stdout);
386	#endif
387
388	gtk_drawing_area_size(gui_window_list[window_id].drawing_area, width / 2, height / 2);
389
390	gui_window_list[window_id].width = width;
391	gui_window_list[window_id].height = height;
392	}
393
394
395	/*
396	* gui_fill -- fill a rectangular area during window redraw
397	*
398	* => colour -- 0xbbggrr format colour
399	* x0, y0, x1, y1 -- coordinates of rectangle
400	*/
401
402	void gui_fill(unsigned int colour, unsigned int x0, unsigned int y0, unsigned int x1, unsigned int y1)
403	{
404	GdkColor gdk_colour;
405
406	printf("gui_fill: box %i %i %i %i\n", x0, y0, x1, y1);
407
408	BGR_TO_GDK(colour, gdk_colour);
409	gdk_colormap_alloc_color(gdk_window_get_colormap(gui_redraw_widget->window), &gdk_colour, FALSE, TRUE);
410	gdk_gc_set_foreground(gui_redraw_widget->style->fg_gc[gui_redraw_widget->state], &gdk_colour);
411
412	gdk_draw_rectangle(gui_redraw_widget->window, gui_redraw_widget->style->fg_gc[gui_redraw_widget->state],
413	TRUE, x0 / 2, y0 / 2, (x1-x0) / 2, (y1-y0) / 2);
414	}
415
416
417	/*
418	* gui_move_box -- copy a rectangular area within a window
419	*
420	* => window_id -- window id from gui_create_window
421	* x0, y0, x1, y1 -- source area
422	* x2, y2 -- destination
423	*/
424
425	void gui_move_box(const gui_window_id window_id, unsigned int x0, unsigned int y0,
426	unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2)
427	{
428
429	assert(window_id >= 0 && window_id < gui_window_list_items && gui_window_list[window_id].used);
430
431	#ifdef DEBUG
432	printf("gui_move_box: window_id = 0x%x, box = %i %i %i %i, dest = %i %i\n",
433	window_id, x0, y0, x1, y1, x2, y2);
434	fflush(stdout);
435	#endif
436
437	/* gui_error = xwimp_block_copy(gui_window_list[window_id].handle, x0, -y1, x1, -y0, x2, -(y1 + (y2 - y0)));
438	* gui_check_error();
439	*/
440	}