archive/guilib/main_riscos.c

/*
 *  main_riscos.c -- portable gui library, RISC OS
 */

#include "gui.h"

wimp_t gui_wimp_task;                          /* wimp task handle */
os_error *gui_error;                           /* last error block pointer */
const char *gui_error_message;                 /* last error message */
int gui_error_line;                            /* last error line */
jmp_buf gui_error_jump;                        /* longjmp buffer for error handling */
bool quit = 0;

char **gui_message;

struct gui_window_data *gui_window_list;       /* array of window details */
unsigned int gui_window_list_items;            /* length of windows list */
signed int gui_window_origin_x, gui_window_origin_y;

static void redraw_window_request(wimp_draw *redraw);
static void open_window_request(wimp_open *open);
static void close_window_request(wimp_close *close);
static void mouse_click(wimp_pointer *pointer);
static void key_pressed(wimp_key *key);
static void menu_selection(wimp_selection *selection);
static void user_message(wimp_message *message);
static void help_request(wimp_message *message, help_message_request *request);


/****************************************************************************************/
/*  main()                                                                              */
/****************************************************************************************/

int main(int argc, char *argv[])
{
  gui_initialise();
  task_initialise();

  gui_event_loop();

  task_finalise();

  return 0;
}


/****************************************************************************************/
/*  Initialisation                                                                      */
/****************************************************************************************/

/*
 *  gui_initialise -- initialise the program with the os or window manager
 *
 *  => name -- program name to pass to the os if applicable
 *
 *  <= nothing
 */

void gui_initialise()
{
  char file_name[30];
  wimp_MESSAGE_LIST(2) messages;

  gui_log("gui_initialise: task_name = '%s'\n", task_name);

  if (setjmp(gui_error_jump))
  {
    gui_log("gui_initialise: *** error %i: %s ***\n", gui_error_line, gui_error_message);

    printf("%s (%i)\n", gui_error_message, gui_error_line);
    fflush(stdout);
    exit(1);
  }

  messages.messages[0] = message_HELP_REQUEST;
  messages.messages[1] = message_QUIT;

  gui_error = xwimp_initialise(wimp_VERSION_RO3, task_name,
        (wimp_message_list const *) &messages,
        NULL, &gui_wimp_task);
  gui_check_error();

  gui_window_list = NULL;
  gui_window_list_items = 0;

  sprintf(file_name, "<%s$Messages>", task_name);
  gui_message = gui_messages_read(file_name);

  gui_log("gui_initialise: gui_wimp_task = 0x%x\n", (unsigned int) gui_wimp_task);
}


/****************************************************************************************/
/*  Event handling                                                                      */
/****************************************************************************************/

/*
 *  gui_event_loop -- receive and handle os or window manager events
 *
 *  => nothing
 *
 *  <= does not return directly, except on exit
 */

#define MASK (wimp_MASK_NULL | wimp_MASK_LEAVING | wimp_MASK_ENTERING | wimp_MASK_LOSE | wimp_MASK_GAIN | wimp_MASK_POLLWORD)

static gui_window_id menu_window_id;

void gui_event_loop(void)
{
  wimp_block block;
  wimp_event_no event;
  os_error err;

  if (setjmp(gui_error_jump))
  {
    gui_log("gui_event_loop: *** error %i: %s ***\n", gui_error_line, gui_error_message);

    err.errnum = 1;
    sprintf(err.errmess, "%s (%i)\n", gui_error_message, gui_error_line);
    xwimp_report_error(&err, wimp_ERROR_BOX_OK_ICON, task_name, NULL);
  }

  while (!quit)
  {
    gui_error = xwimp_poll(MASK, &block, NULL, &event);
    gui_check_error();

    gui_log("gui_event_loop: event = %i\n", event);
    switch (event)
    {
      case wimp_REDRAW_WINDOW_REQUEST: redraw_window_request(&block.redraw); break;
      case wimp_OPEN_WINDOW_REQUEST:   open_window_request(&block.open);     break;
      case wimp_CLOSE_WINDOW_REQUEST:  close_window_request(&block.close);   break;
      case wimp_MOUSE_CLICK:           mouse_click(&block.pointer);          break;
      case wimp_KEY_PRESSED:           key_pressed(&block.key);              break;
      case wimp_MENU_SELECTION:        menu_selection(&block.selection);     break;
      case wimp_USER_MESSAGE:
      case wimp_USER_MESSAGE_RECORDED: user_message(&block.message);         break;
    }
  }
}


/*
 *  redraw window request
 */

void redraw_window_request(wimp_draw *redraw)
{
  bool more;
  unsigned int invalid[4];     /* why was this signed ?? */
  gui_window_id window_id = gui_handle_to_window_id(redraw->w);

  assert(window_id == gui_WINDOW_UNKNOWN ||
         (window_id < gui_window_list_items && gui_window_list[window_id].used));

  gui_error = xwimp_redraw_window(redraw, &more);
  gui_check_error();

  gui_window_origin_x = redraw->box.x0 - redraw->xscroll;
  gui_window_origin_y = redraw->box.y1 - redraw->yscroll;

  gui_log("gui_event_loop: redraw origin %i %i\n", gui_window_origin_x, gui_window_origin_y);

  while (more)
  {
    if (window_id != gui_WINDOW_UNKNOWN && gui_window_list[window_id].redraw_fn)
    {
      invalid[0] = redraw->clip.x0 - gui_window_origin_x;
      invalid[1] = gui_window_origin_y - redraw->clip.y1;
      invalid[2] = redraw->clip.x1 - gui_window_origin_x;
      invalid[3] = gui_window_origin_y - redraw->clip.y0;

      gui_log("gui_event_loop: redraw invalid %i %i %i %i\n",
          invalid[0], invalid[1], invalid[2], invalid[3]);

      gui_window_list[window_id].redraw_fn(window_id, invalid);
    }
    gui_error = xwimp_get_rectangle(redraw, &more);
    gui_check_error();
  }
}


/*
 *  open window request
 */

void open_window_request(wimp_open *open)
{
  gui_window_id window_id = gui_handle_to_window_id(open->w);

  gui_error = xwimp_open_window(open);
  gui_check_error();

  if (window_id != gui_WINDOW_UNKNOWN)
  {
    assert(window_id < gui_window_list_items && gui_window_list[window_id].used);
    if ((unsigned int) (open->visible.x1 - open->visible.x0) != gui_window_list[window_id].width ||
        (unsigned int) (open->visible.y1 - open->visible.y0) != gui_window_list[window_id].height)
    {
      gui_window_list[window_id].width = open->visible.x1 - open->visible.x0;
      gui_window_list[window_id].height = open->visible.y1 - open->visible.y0;
      gui_log("open_window_request: resized to %i %i\n",
            gui_window_list[window_id].width, gui_window_list[window_id].height);
      if (gui_window_list[window_id].resize_fn)
        gui_window_list[window_id].resize_fn(window_id,
              gui_window_list[window_id].width, gui_window_list[window_id].height);
    }
  }
}


/*
 *  close window request
 */

void close_window_request(wimp_close *close)
{
  gui_window_id window_id = gui_handle_to_window_id(close->w);

  gui_log("gui_event_loop: window_id = 0x%x\n", window_id);

  if (window_id != gui_WINDOW_UNKNOWN)
  {
    assert(window_id < gui_window_list_items && gui_window_list[window_id].used);
    gui_window_list[window_id].close_fn(window_id);
  }
}


/*
 *  mouse click
 */

void mouse_click(wimp_pointer *pointer)
{
  gui_window_id window_id = gui_handle_to_window_id(pointer->w);

  gui_log("gui_event_loop: window_id = 0x%x\n", window_id);

  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 && (pointer->buttons & wimp_CLICK_MENU))
    {
      gui_error = xwimp_create_menu(gui_window_list[window_id].menu,
                       pointer->pos.x - 64, pointer->pos.y);
      gui_check_error();
      menu_window_id = window_id;
    }
    else if (gui_window_list[window_id].click_fn)
    {
      unsigned int x, y, z;
      wimp_window_state state;

      state.w = pointer->w;
      gui_error = xwimp_get_window_state(&state);
      gui_check_error();

      x = pointer->pos.x - (state.visible.x0 - state.xscroll);
      y = (state.visible.y1 - state.yscroll) - pointer->pos.y;
      z = (pointer->buttons & wimp_CLICK_SELECT ? gui_CLICK :
          (pointer->buttons & wimp_CLICK_ADJUST ? gui_CLICK_RIGHT :
          (pointer->buttons & wimp_DRAG_SELECT  ? gui_DRAG :
          (pointer->buttons & wimp_DRAG_ADJUST  ? gui_DRAG_RIGHT : 0))));
      gui_window_list[window_id].click_fn(window_id, x, y, z);
    }
  }
}


/*
 *  key pressed
 */

void key_pressed(wimp_key *key)
{
  gui_window_id window_id = gui_handle_to_window_id(key->w);

  gui_log("gui_event_loop: window_id = 0x%x\n", window_id);

  if (window_id != gui_WINDOW_UNKNOWN)
  {
    assert(window_id < gui_window_list_items && gui_window_list[window_id].used);

    if ((key->c & (1<<31)) || (key->c < 256))
    {
      if (gui_window_list[window_id].input_fn)
        gui_window_list[window_id].input_fn(window_id, (wchar_t) (key->c & 0xffff));
    }
    else
    {
      if (gui_window_list[window_id].key_fn)
        gui_window_list[window_id].key_fn(window_id, (unsigned int) key->c);
    }
  }
}


/*
 *  menu selection
 */

void menu_selection(wimp_selection *selection)
{
  wimp_pointer pointer;

  gui_error = xwimp_get_pointer_info(&pointer);
  gui_check_error();

  gui_window_list[menu_window_id].menu_fn(menu_window_id, (unsigned int *) selection->items);

  if (pointer.buttons == wimp_CLICK_ADJUST)
  {
    gui_error = xwimp_create_menu(gui_window_list[menu_window_id].menu, 0, 0);
    gui_check_error();
  }
}


/*
 *  user message, user message recorded
 */

void user_message(wimp_message *message)
{
  gui_log("gui_event_loop: block.message.action = 0x%x\n", message->action);

  switch (message->action)
  {
    case message_QUIT:
      quit = 1;
      break;
    case message_HELP_REQUEST:
      help_request(message, (help_message_request *) &message->data);
      break;
  }
}

/*
 *  interactive help request
 */

void help_request(wimp_message *message, help_message_request *request)
{
  const char *help;
  wimp_message reply;
  gui_window_id window_id = gui_handle_to_window_id(request->w);

  if (window_id != gui_WINDOW_UNKNOWN)
  {
    if (gui_window_list[window_id].used == DIALOG && request->i >= 0)
      help = gui_window_list[window_id].icon[request->i].help;
    else
      help = gui_window_list[window_id].help;

    gui_log(help);
    reply.size = (20 + strlen(help) + 3) & ~3u;
    reply.your_ref = message->my_ref;
    reply.action = message_HELP_REPLY;
    strcpy((char *) &reply.data.reserved, help);
    gui_error = xwimp_send_message(wimp_USER_MESSAGE, &reply, message->sender);
    gui_check_error();
  }
}
1	/*
2	* main_riscos.c -- portable gui library, RISC OS
3	*/
4
5	#include "gui.h"
6
7	wimp_t gui_wimp_task; /* wimp task handle */
8	os_error gui_error; / last error block pointer */
9	const char gui_error_message; / last error message */
10	int gui_error_line; /* last error line */
11	jmp_buf gui_error_jump; /* longjmp buffer for error handling */
12	bool quit = 0;
13
14	char **gui_message;
15
16	struct gui_window_data gui_window_list; / array of window details */
17	unsigned int gui_window_list_items; /* length of windows list */
18	signed int gui_window_origin_x, gui_window_origin_y;
19
20	static void redraw_window_request(wimp_draw *redraw);
21	static void open_window_request(wimp_open *open);
22	static void close_window_request(wimp_close *close);
23	static void mouse_click(wimp_pointer *pointer);
24	static void key_pressed(wimp_key *key);
25	static void menu_selection(wimp_selection *selection);
26	static void user_message(wimp_message *message);
27	static void help_request(wimp_message message, help_message_request request);
28
29
30	/****************************************************************************************/
31	/* main() */
32	/****************************************************************************************/
33
34	int main(int argc, char *argv[])
35	{
36	gui_initialise();
37	task_initialise();
38
39	gui_event_loop();
40
41	task_finalise();
42
43	return 0;
44	}
45
46
47	/****************************************************************************************/
48	/* Initialisation */
49	/****************************************************************************************/
50
51	/*
52	* gui_initialise -- initialise the program with the os or window manager
53	*
54	* => name -- program name to pass to the os if applicable
55	*
56	* <= nothing
57	*/
58
59	void gui_initialise()
60	{
61	char file_name[30];
62	wimp_MESSAGE_LIST(2) messages;
63
64	gui_log("gui_initialise: task_name = '%s'\n", task_name);
65
66	if (setjmp(gui_error_jump))
67	{
68	gui_log("gui_initialise: * error %i: %s *\n", gui_error_line, gui_error_message);
69
70	printf("%s (%i)\n", gui_error_message, gui_error_line);
71	fflush(stdout);
72	exit(1);
73	}
74
75	messages.messages[0] = message_HELP_REQUEST;
76	messages.messages[1] = message_QUIT;
77
78	gui_error = xwimp_initialise(wimp_VERSION_RO3, task_name,
79	(wimp_message_list const *) &messages,
80	NULL, &gui_wimp_task);
81	gui_check_error();
82
83	gui_window_list = NULL;
84	gui_window_list_items = 0;
85
86	sprintf(file_name, "<%s$Messages>", task_name);
87	gui_message = gui_messages_read(file_name);
88
89	gui_log("gui_initialise: gui_wimp_task = 0x%x\n", (unsigned int) gui_wimp_task);
90	}
91
92
93	/****************************************************************************************/
94	/* Event handling */
95	/****************************************************************************************/
96
97	/*
98	* gui_event_loop -- receive and handle os or window manager events
99	*
100	* => nothing
101	*
102	* <= does not return directly, except on exit
103	*/
104
105	#define MASK (wimp_MASK_NULL \| wimp_MASK_LEAVING \| wimp_MASK_ENTERING \| wimp_MASK_LOSE \| wimp_MASK_GAIN \| wimp_MASK_POLLWORD)
106
107	static gui_window_id menu_window_id;
108
109	void gui_event_loop(void)
110	{
111	wimp_block block;
112	wimp_event_no event;
113	os_error err;
114
115	if (setjmp(gui_error_jump))
116	{
117	gui_log("gui_event_loop: * error %i: %s *\n", gui_error_line, gui_error_message);
118
119	err.errnum = 1;
120	sprintf(err.errmess, "%s (%i)\n", gui_error_message, gui_error_line);
121	xwimp_report_error(&err, wimp_ERROR_BOX_OK_ICON, task_name, NULL);
122	}
123
124	while (!quit)
125	{
126	gui_error = xwimp_poll(MASK, &block, NULL, &event);
127	gui_check_error();
128
129	gui_log("gui_event_loop: event = %i\n", event);
130	switch (event)
131	{
132	case wimp_REDRAW_WINDOW_REQUEST: redraw_window_request(&block.redraw); break;
133	case wimp_OPEN_WINDOW_REQUEST: open_window_request(&block.open); break;
134	case wimp_CLOSE_WINDOW_REQUEST: close_window_request(&block.close); break;
135	case wimp_MOUSE_CLICK: mouse_click(&block.pointer); break;
136	case wimp_KEY_PRESSED: key_pressed(&block.key); break;
137	case wimp_MENU_SELECTION: menu_selection(&block.selection); break;
138	case wimp_USER_MESSAGE:
139	case wimp_USER_MESSAGE_RECORDED: user_message(&block.message); break;
140	}
141	}
142	}
143
144
145	/*
146	* redraw window request
147	*/
148
149	void redraw_window_request(wimp_draw *redraw)
150	{
151	bool more;
152	unsigned int invalid[4]; /* why was this signed ?? */
153	gui_window_id window_id = gui_handle_to_window_id(redraw->w);
154
155	assert(window_id == gui_WINDOW_UNKNOWN \|\|
156	(window_id < gui_window_list_items && gui_window_list[window_id].used));
157
158	gui_error = xwimp_redraw_window(redraw, &more);
159	gui_check_error();
160
161	gui_window_origin_x = redraw->box.x0 - redraw->xscroll;
162	gui_window_origin_y = redraw->box.y1 - redraw->yscroll;
163
164	gui_log("gui_event_loop: redraw origin %i %i\n", gui_window_origin_x, gui_window_origin_y);
165
166	while (more)
167	{
168	if (window_id != gui_WINDOW_UNKNOWN && gui_window_list[window_id].redraw_fn)
169	{
170	invalid[0] = redraw->clip.x0 - gui_window_origin_x;
171	invalid[1] = gui_window_origin_y - redraw->clip.y1;
172	invalid[2] = redraw->clip.x1 - gui_window_origin_x;
173	invalid[3] = gui_window_origin_y - redraw->clip.y0;
174
175	gui_log("gui_event_loop: redraw invalid %i %i %i %i\n",
176	invalid[0], invalid[1], invalid[2], invalid[3]);
177
178	gui_window_list[window_id].redraw_fn(window_id, invalid);
179	}
180	gui_error = xwimp_get_rectangle(redraw, &more);
181	gui_check_error();
182	}
183	}
184
185
186	/*
187	* open window request
188	*/
189
190	void open_window_request(wimp_open *open)
191	{
192	gui_window_id window_id = gui_handle_to_window_id(open->w);
193
194	gui_error = xwimp_open_window(open);
195	gui_check_error();
196
197	if (window_id != gui_WINDOW_UNKNOWN)
198	{
199	assert(window_id < gui_window_list_items && gui_window_list[window_id].used);
200	if ((unsigned int) (open->visible.x1 - open->visible.x0) != gui_window_list[window_id].width \|\|
201	(unsigned int) (open->visible.y1 - open->visible.y0) != gui_window_list[window_id].height)
202	{
203	gui_window_list[window_id].width = open->visible.x1 - open->visible.x0;
204	gui_window_list[window_id].height = open->visible.y1 - open->visible.y0;
205	gui_log("open_window_request: resized to %i %i\n",
206	gui_window_list[window_id].width, gui_window_list[window_id].height);
207	if (gui_window_list[window_id].resize_fn)
208	gui_window_list[window_id].resize_fn(window_id,
209	gui_window_list[window_id].width, gui_window_list[window_id].height);
210	}
211	}
212	}
213
214
215	/*
216	* close window request
217	*/
218
219	void close_window_request(wimp_close *close)
220	{
221	gui_window_id window_id = gui_handle_to_window_id(close->w);
222
223	gui_log("gui_event_loop: window_id = 0x%x\n", window_id);
224
225	if (window_id != gui_WINDOW_UNKNOWN)
226	{
227	assert(window_id < gui_window_list_items && gui_window_list[window_id].used);
228	gui_window_list[window_id].close_fn(window_id);
229	}
230	}
231
232
233	/*
234	* mouse click
235	*/
236
237	void mouse_click(wimp_pointer *pointer)
238	{
239	gui_window_id window_id = gui_handle_to_window_id(pointer->w);
240
241	gui_log("gui_event_loop: window_id = 0x%x\n", window_id);
242
243	if (window_id != gui_WINDOW_UNKNOWN)
244	{
245	assert(window_id < gui_window_list_items && gui_window_list[window_id].used);
246	if (gui_window_list[window_id].menu && (pointer->buttons & wimp_CLICK_MENU))
247	{
248	gui_error = xwimp_create_menu(gui_window_list[window_id].menu,
249	pointer->pos.x - 64, pointer->pos.y);
250	gui_check_error();
251	menu_window_id = window_id;
252	}
253	else if (gui_window_list[window_id].click_fn)
254	{
255	unsigned int x, y, z;
256	wimp_window_state state;
257
258	state.w = pointer->w;
259	gui_error = xwimp_get_window_state(&state);
260	gui_check_error();
261
262	x = pointer->pos.x - (state.visible.x0 - state.xscroll);
263	y = (state.visible.y1 - state.yscroll) - pointer->pos.y;
264	z = (pointer->buttons & wimp_CLICK_SELECT ? gui_CLICK :
265	(pointer->buttons & wimp_CLICK_ADJUST ? gui_CLICK_RIGHT :
266	(pointer->buttons & wimp_DRAG_SELECT ? gui_DRAG :
267	(pointer->buttons & wimp_DRAG_ADJUST ? gui_DRAG_RIGHT : 0))));
268	gui_window_list[window_id].click_fn(window_id, x, y, z);
269	}
270	}
271	}
272
273
274	/*
275	* key pressed
276	*/
277
278	void key_pressed(wimp_key *key)
279	{
280	gui_window_id window_id = gui_handle_to_window_id(key->w);
281
282	gui_log("gui_event_loop: window_id = 0x%x\n", window_id);
283
284	if (window_id != gui_WINDOW_UNKNOWN)
285	{
286	assert(window_id < gui_window_list_items && gui_window_list[window_id].used);
287
288	if ((key->c & (1<<31)) \|\| (key->c < 256))
289	{
290	if (gui_window_list[window_id].input_fn)
291	gui_window_list[window_id].input_fn(window_id, (wchar_t) (key->c & 0xffff));
292	}
293	else
294	{
295	if (gui_window_list[window_id].key_fn)
296	gui_window_list[window_id].key_fn(window_id, (unsigned int) key->c);
297	}
298	}
299	}
300
301
302	/*
303	* menu selection
304	*/
305
306	void menu_selection(wimp_selection *selection)
307	{
308	wimp_pointer pointer;
309
310	gui_error = xwimp_get_pointer_info(&pointer);
311	gui_check_error();
312
313	gui_window_list[menu_window_id].menu_fn(menu_window_id, (unsigned int *) selection->items);
314
315	if (pointer.buttons == wimp_CLICK_ADJUST)
316	{
317	gui_error = xwimp_create_menu(gui_window_list[menu_window_id].menu, 0, 0);
318	gui_check_error();
319	}
320	}
321
322
323	/*
324	* user message, user message recorded
325	*/
326
327	void user_message(wimp_message *message)
328	{
329	gui_log("gui_event_loop: block.message.action = 0x%x\n", message->action);
330
331	switch (message->action)
332	{
333	case message_QUIT:
334	quit = 1;
335	break;
336	case message_HELP_REQUEST:
337	help_request(message, (help_message_request *) &message->data);
338	break;
339	}
340	}
341
342	/*
343	* interactive help request
344	*/
345
346	void help_request(wimp_message message, help_message_request request)
347	{
348	const char *help;
349	wimp_message reply;
350	gui_window_id window_id = gui_handle_to_window_id(request->w);
351
352	if (window_id != gui_WINDOW_UNKNOWN)
353	{
354	if (gui_window_list[window_id].used == DIALOG && request->i >= 0)
355	help = gui_window_list[window_id].icon[request->i].help;
356	else
357	help = gui_window_list[window_id].help;
358
359	gui_log(help);
360	reply.size = (20 + strlen(help) + 3) & ~3u;
361	reply.your_ref = message->my_ref;
362	reply.action = message_HELP_REPLY;
363	strcpy((char *) &reply.data.reserved, help);
364	gui_error = xwimp_send_message(wimp_USER_MESSAGE, &reply, message->sender);
365	gui_check_error();
366	}
367	}