1 /* Hey EMACS -*- linux-c -*- */
2 /* $Id: dbg_all.c 2707 2007-12-13 13:18:45Z roms $ */
3
4 /* TiEmu - Tiemu Is an EMUlator
5 *
6 * Copyright (c) 2000-2001, Thomas Corvazier, Romain Lievin
7 * Copyright (c) 2001-2003, Romain Lievin
8 * Copyright (c) 2003, Julien Blache
9 * Copyright (c) 2004, Romain Li�vin
10 * Copyright (c) 2005-2008, Romain Li�vin, Kevin Kofler
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
25 */
26
27 #ifdef HAVE_CONFIG_H
28 # include <config.h>
29 #endif
30
31 #include <glib.h>
32 #include <gtk/gtk.h>
33 #ifdef __WIN32__
34 #include <gdk/gdk.h>
35 #include <gdk/gdkwin32.h>
36 #endif
37 #ifdef __MINGW32__
38 #include <windows.h>
39 #endif
40
41 #include "intl.h"
42 #include "ti68k_int.h"
43 #include "struct.h"
44 #include "dbg_wnds.h"
45 #include "dbg_all.h"
46 #include "dbg_wnds.h"
47 #include "support.h"
48 #include "paths.h"
49 #include "engine.h"
50 #include "dboxes.h"
51 #include "rcfile.h"
52
53 DbgOptions options3;
54 DbgWidgets dbgw = { 0 };
55
56 // make windows (un-)modifiable
dbgwnds_set_sensitivity(int state)57 void dbgwnds_set_sensitivity(int state)
58 {
59 if(options3.dbg_dock)
60 return;
61
62 gtk_widget_set_sensitive(dbgw.regs, state);
63 gtk_widget_set_sensitive(dbgw.bkpts, state);
64 gtk_widget_set_sensitive(dbgw.mem, state);
65 gtk_widget_set_sensitive(dbgw.pclog, state);
66 gtk_widget_set_sensitive(dbgw.stack, state);
67 gtk_widget_set_sensitive(dbgw.heap, state);
68 gtk_widget_set_sensitive(dbgw.iop, state);
69 }
70
71 // minimize all windows
dbgwnds_minimize_all(int all)72 void dbgwnds_minimize_all(int all)
73 {
74 if(options3.dbg_dock)
75 return;
76
77 if(GTK_WIDGET_VISIBLE(dbgw.regs))
78 gtk_window_iconify(GTK_WINDOW(dbgw.regs));
79 if(GTK_WIDGET_VISIBLE(dbgw.bkpts))
80 gtk_window_iconify(GTK_WINDOW(dbgw.bkpts));
81 if(GTK_WIDGET_VISIBLE(dbgw.mem))
82 gtk_window_iconify(GTK_WINDOW(dbgw.mem));
83 if(GTK_WIDGET_VISIBLE(dbgw.pclog))
84 gtk_window_iconify(GTK_WINDOW(dbgw.pclog));
85 if(GTK_WIDGET_VISIBLE(dbgw.code) & all)
86 gtk_window_iconify(GTK_WINDOW(dbgw.code));
87 if(GTK_WIDGET_VISIBLE(dbgw.stack))
88 gtk_window_iconify(GTK_WINDOW(dbgw.stack));
89 if(GTK_WIDGET_VISIBLE(dbgw.heap))
90 gtk_window_iconify(GTK_WINDOW(dbgw.heap));
91 if(GTK_WIDGET_VISIBLE(dbgw.iop))
92 gtk_window_iconify(GTK_WINDOW(dbgw.iop));
93 }
94
95 // unminimize all windows
dbgwnds_unminimize_all(int all)96 void dbgwnds_unminimize_all(int all)
97 {
98 if(options3.dbg_dock)
99 return;
100
101 if(GTK_WIDGET_VISIBLE(dbgw.regs))
102 gtk_window_deiconify(GTK_WINDOW(dbgw.regs));
103 if(GTK_WIDGET_VISIBLE(dbgw.bkpts))
104 gtk_window_deiconify(GTK_WINDOW(dbgw.bkpts));
105 if(GTK_WIDGET_VISIBLE(dbgw.mem))
106 gtk_window_deiconify(GTK_WINDOW(dbgw.mem));
107 if(GTK_WIDGET_VISIBLE(dbgw.pclog))
108 gtk_window_deiconify(GTK_WINDOW(dbgw.pclog));
109 if(GTK_WIDGET_VISIBLE(dbgw.code) & all)
110 gtk_window_deiconify(GTK_WINDOW(dbgw.code));
111 if(GTK_WIDGET_VISIBLE(dbgw.stack))
112 gtk_window_deiconify(GTK_WINDOW(dbgw.stack));
113 if(GTK_WIDGET_VISIBLE(dbgw.heap))
114 gtk_window_deiconify(GTK_WINDOW(dbgw.heap));
115 if(GTK_WIDGET_VISIBLE(dbgw.iop))
116 gtk_window_deiconify(GTK_WINDOW(dbgw.iop));
117 }
118
119 // show all windows
dbgwnds_show_all(int all)120 void dbgwnds_show_all(int all)
121 {
122 if(options3.dbg_dock)
123 return;
124
125 if(!GTK_WIDGET_VISIBLE(dbgw.regs))
126 gtk_widget_show(dbgw.regs);
127 if(!GTK_WIDGET_VISIBLE(dbgw.bkpts))
128 gtk_widget_show(dbgw.bkpts);
129 if(!GTK_WIDGET_VISIBLE(dbgw.mem))
130 gtk_widget_show(dbgw.mem);
131 if(!GTK_WIDGET_VISIBLE(dbgw.pclog))
132 gtk_widget_show(dbgw.pclog);
133 if(!GTK_WIDGET_VISIBLE(dbgw.code) && all)
134 gtk_widget_show(dbgw.code);
135 if(!GTK_WIDGET_VISIBLE(dbgw.stack))
136 gtk_widget_show(dbgw.stack);
137 if(!GTK_WIDGET_VISIBLE(dbgw.heap))
138 gtk_widget_show(dbgw.heap);
139 if(!GTK_WIDGET_VISIBLE(dbgw.iop))
140 gtk_widget_show(dbgw.iop);
141 }
142
143 // or hide them
dbgwnds_hide_all(int all)144 void dbgwnds_hide_all(int all)
145 {
146 if(options3.dbg_dock)
147 return;
148
149 if(GTK_WIDGET_VISIBLE(dbgw.regs))
150 gtk_widget_hide(dbgw.regs);
151 if(GTK_WIDGET_VISIBLE(dbgw.bkpts))
152 gtk_widget_hide(dbgw.bkpts);
153 if(GTK_WIDGET_VISIBLE(dbgw.mem))
154 gtk_widget_hide(dbgw.mem);
155 if(GTK_WIDGET_VISIBLE(dbgw.pclog))
156 gtk_widget_hide(dbgw.pclog);
157 if(GTK_WIDGET_VISIBLE(dbgw.code) && all)
158 gtk_widget_hide(dbgw.code);
159 if(GTK_WIDGET_VISIBLE(dbgw.stack))
160 gtk_widget_hide(dbgw.stack);
161 if(GTK_WIDGET_VISIBLE(dbgw.heap))
162 gtk_widget_hide(dbgw.heap);
163 if(GTK_WIDGET_VISIBLE(dbgw.iop))
164 gtk_widget_hide(dbgw.iop);
165 }
166
167 /* Callbacks */
168
169 // callbacks from dbg_code.c (window menu)
170 // used to show/hide or minimize/un-minimize windows
171
172 GLADE_CB void
on_registers1_activate(GtkMenuItem * menuitem,gpointer user_data)173 on_registers1_activate (GtkMenuItem *menuitem,
174 gpointer user_data)
175 {
176 if(GTK_CHECK_MENU_ITEM(menuitem)->active != TRUE)
177 gtk_widget_hide(dbgw.regs);
178 else
179 gtk_widget_show(dbgw.regs);
180 }
181
182
183 GLADE_CB void
on_breakpoints1_activate(GtkMenuItem * menuitem,gpointer user_data)184 on_breakpoints1_activate (GtkMenuItem *menuitem,
185 gpointer user_data)
186 {
187 if(GTK_CHECK_MENU_ITEM(menuitem)->active != TRUE)
188 gtk_widget_hide(dbgw.bkpts);
189 else
190 gtk_widget_show(dbgw.bkpts);
191 }
192
193
194 GLADE_CB void
on_memory1_activate(GtkMenuItem * menuitem,gpointer user_data)195 on_memory1_activate (GtkMenuItem *menuitem,
196 gpointer user_data)
197 {
198 if(GTK_CHECK_MENU_ITEM(menuitem)->active != TRUE)
199 gtk_widget_hide(dbgw.mem);
200 else
201 gtk_widget_show(dbgw.mem);
202 }
203
204 GLADE_CB void
on_pc_log1_activate(GtkMenuItem * menuitem,gpointer user_data)205 on_pc_log1_activate (GtkMenuItem *menuitem,
206 gpointer user_data)
207 {
208 if(GTK_CHECK_MENU_ITEM(menuitem)->active != TRUE)
209 gtk_widget_hide(dbgw.pclog);
210 else
211 gtk_widget_show(dbgw.pclog);
212 }
213
214 GLADE_CB void
on_stack_frame1_activate(GtkMenuItem * menuitem,gpointer user_data)215 on_stack_frame1_activate (GtkMenuItem *menuitem,
216 gpointer user_data)
217 {
218 if(GTK_CHECK_MENU_ITEM(menuitem)->active != TRUE)
219 gtk_widget_hide(dbgw.stack);
220 else
221 gtk_widget_show(dbgw.stack);
222 }
223
224 GLADE_CB void
on_heap_frame1_activate(GtkMenuItem * menuitem,gpointer user_data)225 on_heap_frame1_activate (GtkMenuItem *menuitem,
226 gpointer user_data)
227 {
228 if(GTK_CHECK_MENU_ITEM(menuitem)->active != TRUE)
229 gtk_widget_hide(dbgw.heap);
230 else
231 gtk_widget_show(dbgw.heap);
232 }
233
234 GLADE_CB void
on_ioports_frame1_activate(GtkMenuItem * menuitem,gpointer user_data)235 on_ioports_frame1_activate (GtkMenuItem *menuitem,
236 gpointer user_data)
237 {
238 if(GTK_CHECK_MENU_ITEM(menuitem)->active != TRUE)
239 gtk_widget_hide(dbgw.iop);
240 else
241 gtk_widget_show(dbgw.iop);
242 }
243
244 GLADE_CB void
on_transient1_activate(GtkMenuItem * menu_item,gpointer user_data)245 on_transient1_activate (GtkMenuItem *menu_item,
246 gpointer user_data)
247 {
248 // This make dbg wnd's as children of the main window.
249 // Thus, the taskbar is not filled-up with a lot of windows.
250 options3.transient = GTK_CHECK_MENU_ITEM(menu_item)->active;
251
252 msg_box1(_("Warning"), _("You will have to save configuration and restart TiEmu for changes to take effect!"));
253 }
254
255 GLADE_CB void
on_dockmode1_activate(GtkMenuItem * menu_item,gpointer user_data)256 on_dockmode1_activate (GtkMenuItem *menu_item,
257 gpointer user_data)
258 {
259 msg_box1(_("Warning"), _("TiEmu is about to restart..."));
260
261 #ifndef NO_GDB
262 // In GDB mode, we have to restart the engine here, otherwise
263 // gtk_debugger_close will call gdbcall_continue to do so and never
264 // return.
265 engine_start();
266 #endif
267 gtk_debugger_close();
268 // Stop the engine before calling gtk_main_quit.
269 // Otherwise, it will keep running even when it is supposed to have
270 // been stopped by the debugger.
271 engine_stop();
272 if(options3.dbg_dock)
273 gtk_widget_destroy(dbgw.dock);
274
275 options3.dbg_dock = GTK_CHECK_MENU_ITEM(menu_item)->active;
276
277 gtk_main_quit();
278 }
279
280 GLADE_CB void
on_quit1_activate(GtkMenuItem * menuitem,gpointer user_data)281 on_quit1_activate (GtkMenuItem *menuitem,
282 gpointer user_data)
283 {
284 gtk_debugger_close();
285 }
286
287 GLADE_CB void
on_show_all1_activate(GtkMenuItem * menuitem,gpointer user_data)288 on_show_all1_activate (GtkMenuItem *menuitem,
289 gpointer user_data)
290 {
291 dbgwnds_show_all(0);
292 }
293
294
295 GLADE_CB void
on_hide_all1_activate(GtkMenuItem * menuitem,gpointer user_data)296 on_hide_all1_activate (GtkMenuItem *menuitem,
297 gpointer user_data)
298 {
299 dbgwnds_hide_all(0);
300 }
301
302 GLADE_CB void
on_minimize_all1_activate(GtkMenuItem * menuitem,gpointer user_data)303 on_minimize_all1_activate (GtkMenuItem *menuitem,
304 gpointer user_data)
305 {
306 dbgwnds_minimize_all(0);
307 }
308
309
310 GLADE_CB void
on_maximize_all1_activate(GtkMenuItem * menuitem,gpointer user_data)311 on_maximize_all1_activate (GtkMenuItem *menuitem,
312 gpointer user_data)
313 {
314 dbgwnds_unminimize_all(0);
315 }
316
317 extern void options3_set_default(void);
318
319 GLADE_CB void
on_restore_all1_activate(GtkMenuItem * menuitem,gpointer user_data)320 on_restore_all1_activate (GtkMenuItem *menuitem,
321 gpointer user_data)
322 {
323 // restore windows with default settings
324 options3_set_default();
325 }
326
327 // reflects window state in menu
update_submenu(GtkWidget * widget,gpointer user_data)328 void update_submenu(GtkWidget *widget, gpointer user_data)
329 {
330 GtkMenuShell *shell = GTK_MENU_SHELL(widget);
331 GList *list = shell->children;
332 GList *elt;
333 GtkCheckMenuItem *item;
334
335 // regs
336 elt = g_list_nth(list, 0);
337 item = GTK_CHECK_MENU_ITEM(elt->data);
338 if(!options3.dbg_dock)
339 {
340 g_signal_handlers_block_by_func(GTK_OBJECT(item), on_registers1_activate, NULL);
341 gtk_check_menu_item_set_active(item, GTK_WIDGET_VISIBLE(dbgw.regs));
342 g_signal_handlers_unblock_by_func(GTK_OBJECT(item), on_registers1_activate, NULL);
343 }
344 else
345 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
346
347 // bkpts
348 elt = g_list_nth(list, 1);
349 item = GTK_CHECK_MENU_ITEM(elt->data);
350 if(!options3.dbg_dock)
351 {
352 g_signal_handlers_block_by_func(GTK_OBJECT(item), on_breakpoints1_activate, NULL);
353 gtk_check_menu_item_set_active(item, GTK_WIDGET_VISIBLE(dbgw.bkpts));
354 g_signal_handlers_unblock_by_func(GTK_OBJECT(item), on_breakpoints1_activate, NULL);
355 }
356 else
357 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
358
359 // mem
360 elt = g_list_nth(list, 2);
361 item = GTK_CHECK_MENU_ITEM(elt->data);
362 if(!options3.dbg_dock)
363 {
364 g_signal_handlers_block_by_func(GTK_OBJECT(item), on_memory1_activate, NULL);
365 gtk_check_menu_item_set_active(item, GTK_WIDGET_VISIBLE(dbgw.mem));
366 g_signal_handlers_unblock_by_func(GTK_OBJECT(item), on_memory1_activate, NULL);
367 }
368 else
369 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
370
371 // pclog
372 elt = g_list_nth(list, 3);
373 item = GTK_CHECK_MENU_ITEM(elt->data);
374 g_signal_handlers_block_by_func(GTK_OBJECT(item), on_pc_log1_activate, NULL);
375 gtk_check_menu_item_set_active(item, GTK_WIDGET_VISIBLE(dbgw.pclog));
376 g_signal_handlers_unblock_by_func(GTK_OBJECT(item), on_pc_log1_activate, NULL);
377
378 // stack
379 elt = g_list_nth(list, 4);
380 item = GTK_CHECK_MENU_ITEM(elt->data);
381 if(!options3.dbg_dock)
382 {
383 g_signal_handlers_block_by_func(GTK_OBJECT(item), on_stack_frame1_activate, NULL);
384 gtk_check_menu_item_set_active(item, GTK_WIDGET_VISIBLE(dbgw.stack));
385 g_signal_handlers_unblock_by_func(GTK_OBJECT(item), on_stack_frame1_activate, NULL);
386 }
387 else
388 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
389
390 // heap
391 elt = g_list_nth(list, 5);
392 item = GTK_CHECK_MENU_ITEM(elt->data);
393 if(!options3.dbg_dock)
394 {
395 g_signal_handlers_block_by_func(GTK_OBJECT(item), on_heap_frame1_activate, NULL);
396 gtk_check_menu_item_set_active(item, GTK_WIDGET_VISIBLE(dbgw.heap));
397 g_signal_handlers_unblock_by_func(GTK_OBJECT(item), on_heap_frame1_activate, NULL);
398 }
399 else
400 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
401
402 // ioports
403 elt = g_list_nth(list, 6);
404 item = GTK_CHECK_MENU_ITEM(elt->data);
405 g_signal_handlers_block_by_func(GTK_OBJECT(item), on_ioports_frame1_activate, NULL);
406 gtk_check_menu_item_set_active(item, GTK_WIDGET_VISIBLE(dbgw.iop));
407 g_signal_handlers_unblock_by_func(GTK_OBJECT(item), on_ioports_frame1_activate, NULL);
408
409 // dock/multi mode
410 elt = g_list_nth(list, 8);
411 item = GTK_CHECK_MENU_ITEM(elt->data);
412 g_signal_handlers_block_by_func(GTK_OBJECT(item), on_dockmode1_activate, NULL);
413 gtk_check_menu_item_set_active(item, options3.dbg_dock);
414 g_signal_handlers_unblock_by_func(GTK_OBJECT(item), on_dockmode1_activate, NULL);
415
416 // transient mode
417 elt = g_list_nth(list, 9);
418 item = GTK_CHECK_MENU_ITEM(elt->data);
419 g_signal_handlers_block_by_func(GTK_OBJECT(item), on_transient1_activate, NULL);
420 gtk_check_menu_item_set_active(item, options3.transient);
421 g_signal_handlers_unblock_by_func(GTK_OBJECT(item), on_transient1_activate, NULL);
422
423 if(options3.dbg_dock)
424 {
425 int i;
426
427 for(i = 11; i <= 15; i++)
428 {
429 elt = g_list_nth(list, i);
430 gtk_widget_set_sensitive(GTK_WIDGET(elt->data), FALSE);
431 }
432 }
433 }
434
435 // callbacks from dbg_regs.c
436
437 /*
438 This function exists because GDK retrieves client coordinates, not window ones.
439 (Kevin: GDK uses GetClientRect and ClientToScreen).
440 We need that to save and restore windows position.
441 */
window_get_rect(GtkWidget * widget,GdkRect * rect)442 void window_get_rect(GtkWidget *widget, GdkRect *rect)
443 {
444 gtk_window_get_size(GTK_WINDOW(widget), &rect->w, &rect->h);
445
446 #ifdef __WIN32__
447 {
448 BOOL bResult;
449 HWND hWnd = GDK_WINDOW_HWND(widget->window);
450 RECT lpRect;
451 GdkRectangle gdkRect;
452
453 bResult = GetWindowRect(hWnd, &lpRect);
454
455 rect->x = lpRect.left;
456 rect->y = lpRect.top;
457
458 // Now obtain and add the offset between GDK and Win32 coordinates
459 // (in the multi-screen case).
460 gdk_screen_get_monitor_geometry(gdk_screen_get_default(), 0, &gdkRect);
461 rect->x += gdkRect.x;
462 rect->y += gdkRect.y;
463 }
464 #else
465 gdk_window_get_position(widget->window, &rect->x, &rect->y);
466 #endif
467 }
468
469 GLADE_CB gboolean
on_dbgregs_window_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)470 on_dbgregs_window_delete_event (GtkWidget *widget,
471 GdkEvent *event,
472 gpointer user_data)
473 {
474 gtk_widget_hide(widget);
475 return TRUE;
476 }
477
478 GLADE_CB void
on_dbgregs_window_state_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)479 on_dbgregs_window_state_event (GtkWidget *widget,
480 GdkEvent *event,
481 gpointer user_data)
482 {
483 GdkEventWindowState *wstate = (GdkEventWindowState *)event;
484 GdkWindowState state = wstate->new_window_state;
485 GdkWindowState mask = wstate->changed_mask;
486
487 if(mask & GDK_WINDOW_STATE_WITHDRAWN && dbg_on)
488 options3.regs.closed = (state & GDK_WINDOW_STATE_WITHDRAWN);
489
490 window_get_rect(widget, &options3.regs.rect);
491
492 if(mask & GDK_WINDOW_STATE_ICONIFIED)
493 options3.regs.minimized = state & GDK_WINDOW_STATE_ICONIFIED;
494 }
495
496 // callbacks from dbg_pclog.c
497 GLADE_CB gboolean
on_dbgpclog_window_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)498 on_dbgpclog_window_delete_event (GtkWidget *widget,
499 GdkEvent *event,
500 gpointer user_data)
501 {
502 gtk_widget_hide(widget);
503 return TRUE;
504 }
505
506 GLADE_CB void
on_dbgpclog_window_state_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)507 on_dbgpclog_window_state_event (GtkWidget *widget,
508 GdkEvent *event,
509 gpointer user_data)
510 {
511 GdkEventWindowState *wstate = (GdkEventWindowState *)event;
512 GdkWindowState state = wstate->new_window_state;
513 GdkWindowState mask = wstate->changed_mask;
514
515 if(mask & GDK_WINDOW_STATE_WITHDRAWN && dbg_on)
516 options3.pclog.closed = (state & GDK_WINDOW_STATE_WITHDRAWN);
517
518 window_get_rect(widget, &options3.pclog.rect);
519
520 if(mask & GDK_WINDOW_STATE_ICONIFIED)
521 options3.pclog.minimized = state & GDK_WINDOW_STATE_ICONIFIED;
522 }
523
524 // callbacks from dbg_mem.c
525
526 GLADE_CB gboolean
on_dbgmem_window_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)527 on_dbgmem_window_delete_event (GtkWidget *widget,
528 GdkEvent *event,
529 gpointer user_data)
530 {
531 gtk_widget_hide(widget);
532 return TRUE;
533 }
534
535 GLADE_CB void
on_dbgmem_window_state_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)536 on_dbgmem_window_state_event (GtkWidget *widget,
537 GdkEvent *event,
538 gpointer user_data)
539 {
540 GdkEventWindowState *wstate = (GdkEventWindowState *)event;
541 GdkWindowState state = wstate->new_window_state;
542 GdkWindowState mask = wstate->changed_mask;
543
544 if(mask & GDK_WINDOW_STATE_WITHDRAWN && dbg_on)
545 options3.mem.closed = (state & GDK_WINDOW_STATE_WITHDRAWN);
546
547 window_get_rect(widget, &options3.mem.rect);
548
549 if(mask & GDK_WINDOW_STATE_ICONIFIED)
550 options3.mem.minimized = state & GDK_WINDOW_STATE_ICONIFIED;
551 }
552
553 // callbacks from dbg_code.c
554
555 GLADE_CB gboolean
on_dbgcode_window_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)556 on_dbgcode_window_delete_event (GtkWidget *widget,
557 GdkEvent *event,
558 gpointer user_data)
559 {
560 if (dbgcode_quit_enabled())
561 {
562 gtk_widget_hide(widget);
563 on_quit1_activate(NULL, NULL);
564 }
565 return TRUE;
566 }
567
568 GLADE_CB void
on_dbgcode_window_state_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)569 on_dbgcode_window_state_event (GtkWidget *widget,
570 GdkEvent *event,
571 gpointer user_data)
572 {
573 GdkEventWindowState *wstate = (GdkEventWindowState *)event;
574 GdkWindowState state = wstate->new_window_state;
575 GdkWindowState mask = wstate->changed_mask;
576
577 if(mask & GDK_WINDOW_STATE_WITHDRAWN && dbg_on)
578 options3.code.closed = (state & GDK_WINDOW_STATE_WITHDRAWN);
579
580 window_get_rect(widget, &options3.code.rect);
581
582 if(mask & GDK_WINDOW_STATE_ICONIFIED)
583 options3.code.minimized = state & GDK_WINDOW_STATE_ICONIFIED;
584 }
585
586 // callbacks from dbg_bkpts.c
587
588 GLADE_CB gboolean
on_dbgbkpts_window_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)589 on_dbgbkpts_window_delete_event (GtkWidget *widget,
590 GdkEvent *event,
591 gpointer user_data)
592 {
593 gtk_widget_hide(widget);
594 return TRUE;
595 }
596
597 GLADE_CB void
on_dbgbkpts_window_state_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)598 on_dbgbkpts_window_state_event (GtkWidget *widget,
599 GdkEvent *event,
600 gpointer user_data)
601 {
602 GdkEventWindowState *wstate = (GdkEventWindowState *)event;
603 GdkWindowState state = wstate->new_window_state;
604 GdkWindowState mask = wstate->changed_mask;
605
606 if(mask & GDK_WINDOW_STATE_WITHDRAWN && dbg_on)
607 options3.bkpts.closed = (state & GDK_WINDOW_STATE_WITHDRAWN);
608
609 window_get_rect(widget, &options3.bkpts.rect);
610
611 if(mask & GDK_WINDOW_STATE_ICONIFIED)
612 options3.bkpts.minimized = state & GDK_WINDOW_STATE_ICONIFIED;
613 }
614
615 // callbacks from dbg_stack.c
616 GLADE_CB gboolean
on_dbgstack_window_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)617 on_dbgstack_window_delete_event (GtkWidget *widget,
618 GdkEvent *event,
619 gpointer user_data)
620 {
621 gtk_widget_hide(widget);
622 return TRUE;
623 }
624
625 GLADE_CB void
on_dbgstack_window_state_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)626 on_dbgstack_window_state_event (GtkWidget *widget,
627 GdkEvent *event,
628 gpointer user_data)
629 {
630 GdkEventWindowState *wstate = (GdkEventWindowState *)event;
631 GdkWindowState state = wstate->new_window_state;
632 GdkWindowState mask = wstate->changed_mask;
633
634 if(mask & GDK_WINDOW_STATE_WITHDRAWN && dbg_on)
635 options3.stack.closed = (state & GDK_WINDOW_STATE_WITHDRAWN);
636
637 window_get_rect(widget, &options3.stack.rect);
638
639 if(mask & GDK_WINDOW_STATE_ICONIFIED)
640 options3.stack.minimized = state & GDK_WINDOW_STATE_ICONIFIED;
641 }
642
643 // callbacks from dbg_heap.c
644 GLADE_CB gboolean
on_dbgheap_window_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)645 on_dbgheap_window_delete_event (GtkWidget *widget,
646 GdkEvent *event,
647 gpointer user_data)
648 {
649 gtk_widget_hide(widget);
650 return TRUE;
651 }
652
653 GLADE_CB void
on_dbgheap_window_state_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)654 on_dbgheap_window_state_event (GtkWidget *widget,
655 GdkEvent *event,
656 gpointer user_data)
657 {
658 GdkEventWindowState *wstate = (GdkEventWindowState *)event;
659 GdkWindowState state = wstate->new_window_state;
660 GdkWindowState mask = wstate->changed_mask;
661
662 if(mask & GDK_WINDOW_STATE_WITHDRAWN && dbg_on)
663 options3.heap.closed = (state & GDK_WINDOW_STATE_WITHDRAWN);
664
665 window_get_rect(widget, &options3.heap.rect);
666
667 if(mask & GDK_WINDOW_STATE_ICONIFIED)
668 options3.heap.minimized = state & GDK_WINDOW_STATE_ICONIFIED;
669 }
670
671 // callbacks from dbg_iop.c
672 GLADE_CB gboolean
on_dbgioports_window_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)673 on_dbgioports_window_delete_event (GtkWidget *widget,
674 GdkEvent *event,
675 gpointer user_data)
676 {
677 gtk_widget_hide(widget);
678 return TRUE;
679 }
680
681 GLADE_CB void
on_dbgioports_window_state_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)682 on_dbgioports_window_state_event (GtkWidget *widget,
683 GdkEvent *event,
684 gpointer user_data)
685 {
686 GdkEventWindowState *wstate = (GdkEventWindowState *)event;
687 GdkWindowState state = wstate->new_window_state;
688 GdkWindowState mask = wstate->changed_mask;
689
690 if(mask & GDK_WINDOW_STATE_WITHDRAWN && dbg_on)
691 options3.iop.closed = (state & GDK_WINDOW_STATE_WITHDRAWN);
692
693 window_get_rect(widget, &options3.iop.rect);
694
695 if(mask & GDK_WINDOW_STATE_ICONIFIED)
696 options3.iop.minimized = state & GDK_WINDOW_STATE_ICONIFIED;
697 }
698
699 // misc
700
701 // Common remplacement for gtk_window_(de)iconify)
gtk_window_minimize(GtkWindow * window,gboolean action)702 void gtk_window_minimize(GtkWindow *window, gboolean action)
703 {
704 if(action)
705 gtk_window_iconify(window);
706 else
707 gtk_window_deiconify(window);
708 }
709
710
711 /*
712 tiTIME profile;
713 void profile_start(void)
714 {
715 TO_START(profile);
716 }
717 void profile_stop(const char *str)
718 {
719 printf("Duration (%s): %i ms\n", str, TO_CURRENT(profile));
720 }
721 */
722