archive/guilib/main_gtk.c

/*
 *  main_gtk.c -- portable gui library, GTK
 */

#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[])
{
  gtk_set_locale();
  gtk_init(&argc, &argv);

  gui_initialise();
  task_initialise();

  gui_event_loop();

  task_finalise();

  gtk_exit(0);

  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];

  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);
  }

  gui_window_list = NULL;
  gui_window_list_items = 0;

  sprintf(file_name, "%s_Messages", task_name);
  gui_message = gui_messages_read(getenv(file_name));

  gui_log("gui_initialise: finished\n");
}


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

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

static gui_window_id menu_window_id;

void gui_event_loop(void)
{
/*   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);
 *   }
 */

  gtk_main();
}


/*
 *  redraw window request
 */

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