void on_reverse_activate(GtkWidget *win)
{
win_i *info = get_win_i(win, WIN_TYPE_MEMORY);
DView *memory = get_view(info, DVT_MEMORY);
downcast<debug_view_memory *>(memory->view)->set_reverse(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "reverse"))));
}
static void
banlist_crop (GtkWidget * wid, banlist_info *banl)
{
session *sess = banl->sess;
GtkTreeSelection *select;
GSList *list = NULL, *node;
int num_sel;
/* remember which bans are selected */
select = gtk_tree_view_get_selection (get_view (sess));
/* gtk_tree_selected_get_selected_rows() isn't present in gtk 2.0.x */
gtk_tree_selection_selected_foreach (select, banlist_add_selected_cb,
&list);
num_sel = g_slist_length (list);
/* select all, then unselect those that we remembered */
if (num_sel)
{
gtk_tree_selection_select_all (select);
for (node = list; node; node = node->next)
gtk_tree_selection_unselect_iter (select, node->data);
g_slist_foreach (list, (GFunc)g_free, NULL);
g_slist_free (list);
banlist_unban (NULL, banl);
} else
fe_message (_("You must select some bans."), FE_MSG_ERROR);
}
void
on_set_breakpoint_at_cursor_activate(GtkWidget *win)
{
win_i *info = get_win_i(win, WIN_TYPE_ALL);
DView *disasm = get_view(info, DVT_DISASSEMBLY);
astring command;
if (disasm->view->cursor_visible())
{
if (debug_cpu_get_visible_cpu(*info->machine) == disasm->view->source()->device())
{
offs_t address = downcast<debug_view_disasm *>(disasm->view)->selected_address();
device_debug *cpuinfo = disasm->view->source()->device()->debug();
device_debug::breakpoint *bp;
INT32 bpindex = -1;
/* first find an existing breakpoint at this address */
for (bp = cpuinfo->breakpoint_first(); bp != NULL; bp = bp->next())
if (address == bp->address())
{
bpindex = bp->index();
break;
}
/* if it doesn't exist, add a new one */
if (bpindex == -1)
command.printf("bpset 0x%X", address);
else
command.printf("bpclear 0x%X", bpindex);
debug_console_execute_command(*info->machine, command, 1);
}
}
}
void ivis_start( ITunesVis* plugin )
{
/* make sure we have a plugin and a visual handler */
if ( !plugin || !plugin->imports.visual_handler )
return;
/* if we don't have an offscreen buffer, create one */
if ( ! plugin->screen )
plugin->screen = get_view( plugin->rect.right, plugin->rect.bottom );
/* customize the show window message */
memset( &plugin->visual_message.u.showWindowMessage, 0,
sizeof(plugin->visual_message.u.showWindowMessage) );
plugin->visual_message.u.showWindowMessage.GRAPHICS_DEVICE_NAME = plugin->screen;
plugin->visual_message.u.showWindowMessage.drawRect = plugin->rect;
plugin->visual_message.u.showWindowMessage.options = 0;
plugin->visual_message.u.showWindowMessage.totalVisualizerRect = plugin->rect;
/* set our start time */
plugin->start_time = ivis_current_time();
/* send the show window message */
CGLContextObj currentContext = CGLGetCurrentContext();
plugin->imports.visual_handler( kVisualPluginEnableMessage, &( plugin->visual_message ),
plugin->vis_ref );
plugin->imports.visual_handler( kVisualPluginShowWindowMessage, &( plugin->visual_message ),
plugin->vis_ref );
plugin->imports.visual_handler( kVisualPluginUpdateMessage, &( plugin->visual_message ),
plugin->vis_ref );
plugin->gl_context = (void*)aglGetCurrentContext();
CGLSetCurrentContext( currentContext );
}
void DiagramWindow::new_scale(int percent) {
double np = ((double) percent)/100.0;
if (canvas->zoom() != np) {
get_view()->set_zoom(np);
sb_zoom->setValue(percent);
}
}
void on_dbpl_activate(GtkWidget *win)
{
win_i *info = get_win_i(win, WIN_TYPE_MEMORY);
DView *memory = get_view(info, DVT_MEMORY);
debug_view_memory *memview = downcast<debug_view_memory *>(memory->view);
memview->set_chunks_per_row(memview->chunks_per_row() - 1);
}
QString DiagramWindow::copy_selected() const {
QString warning;
double zm = canvas->zoom();
if (zm != 1)
get_view()->set_zoom(1);
QString diagram_def;
QTextOStream st(&diagram_def);
indent0();
get_view()->save(st, warning, TRUE);
if (zm != 1)
get_view()->set_zoom(zm);
return diagram_def;
}
void on_comments_activate(GtkWidget *win)
{
win_i *info = get_win_i(win, WIN_TYPE_MAIN | WIN_TYPE_DISASM);
DView *disasm = get_view(info, DVT_DISASSEMBLY);
if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "comments")))) {
downcast<debug_view_disasm *>(disasm->view)->set_right_column(DASM_RIGHTCOL_COMMENTS);
}
}
static void disasmwin_process_string(win_i *win, const char *str)
{
win_i *dis = (win_i *) win;
DView *disasm = get_view(dis, DVT_DISASSEMBLY);
assert(dis->type == WIN_TYPE_DISASM);
downcast<debug_view_disasm *>(disasm->view)->set_expression(str);
}
void on_physical_addresses_group_changed(GtkWidget *win)
{
win_i *info = get_win_i(win, WIN_TYPE_MEMORY);
DView *memory = get_view(info, DVT_MEMORY);
if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "physical_addresses")))) {
downcast<debug_view_memory *>(memory->view)->set_physical(true);
}
}
static void memorywin_process_string(win_i *win, const char *str)
{
win_i *mem = (win_i *) win;
DView *memory = get_view(mem, DVT_MEMORY);
assert(mem->type == WIN_TYPE_MEMORY);
downcast<debug_view_memory *>(memory->view)->set_expression(str);
}
void on_chunks_4_activate(GtkWidget *win)
{
win_i *info = get_win_i(win, WIN_TYPE_MEMORY);
DView *memory = get_view(info, DVT_MEMORY);
if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "chunks_4")))) {
downcast<debug_view_memory *>(memory->view)->set_bytes_per_chunk(4);
}
}
void DiagramWindow::save_session(QTextStream & st) {
// can't access to the window position, even through geometry
QString warning;
st << " ";
((BrowserNode *) browser_node)->save(st, TRUE, warning);
st << "\n " << width() << ' ' << height() << ' ';
get_view()->save_session(st);
}
void DiagramWindow::save(const char * ext, QString & warning,
BooL & is_new) const {
double zm = canvas->zoom();
if (zm != 1)
get_view()->set_zoom(1);
QString diagram_def;
QTextOStream st(&diagram_def);
int current_indent = indent();
indent0();
get_view()->save(st, warning, FALSE);
save_definition(browser_node->get_ident(), ext, diagram_def, is_new);
indent(current_indent);
if (zm != 1)
get_view()->set_zoom(zm);
}
void
warlock_view_append (const char *name, const WString *w_string)
{
WarlockView *view;
view = get_view (name);
if (view == NULL || view->shown == FALSE) {
view = main_view;
}
view->buffer = w_string_append (view->buffer, w_string);
}
void DiagramWindow::duplicate(int dest_id, const char * ext) const {
QString warning;
double zm = canvas->zoom();
if (zm != 1)
get_view()->set_zoom(1);
QString diagram_def;
QTextOStream st(&diagram_def);
int current_indent = indent();
BooL is_new = TRUE;
indent0();
get_view()->save(st, warning, FALSE);
save_definition(dest_id, ext, diagram_def, is_new);
indent(current_indent);
if (zm != 1)
get_view()->set_zoom(zm);
}
static void apply_delta(detector_t* d, view_t* view)
{
deltamap_t* map = view->delta;
if(map == NULL)
return;
// update refs with delta
size_t i = HASHMAP_BEGIN;
delta_t* delta;
while((delta = ponyint_deltamap_next(map, &i)) != NULL)
{
// If rc is 0, we skip creating a view for the actor.
pony_actor_t* actor = ponyint_delta_actor(delta);
size_t rc = ponyint_delta_rc(delta);
// If the referenced actor has never blocked, we will insert a view_t
// that has blocked set to false.
view_t* find = get_view(d, actor, rc > 0);
if(find == NULL)
continue;
viewref_t key;
key.view = find;
if(rc > 0)
{
viewref_t* ref = ponyint_viewrefmap_get(&view->map, &key);
if(ref == NULL)
{
ref = (viewref_t*)POOL_ALLOC(viewref_t);
ref->view = find;
ponyint_viewrefmap_put(&view->map, ref);
find->view_rc++;
}
ref->rc = rc;
} else {
viewref_t* ref = ponyint_viewrefmap_remove(&view->map, &key);
if(ref != NULL)
{
viewref_free(ref);
view_free(find);
}
}
}
ponyint_deltamap_free(map);
view->delta = NULL;
}
GtkWidget *
warlock_view_get_scrolled_window (const char *name)
{
WarlockView *view;
view = get_view (name);
if (view == NULL)
return NULL;
return view->scrolled_window;
}
static void disasmwin_cpu_changed(GtkComboBox *cpu_w, win_i *dis)
{
astring title;
DView *disasm = get_view(dis, DVT_DISASSEMBLY);
disasm->view->set_source(*disasm->view->source_list().by_index(gtk_combo_box_get_active(cpu_w)));
disasmview_update_checks(dis);
const debug_view_source *source = disasm->view->source();
title.printf("Disassembly: %s", source->name());
gtk_window_set_title(GTK_WINDOW(dis->win), title);
}
static void disasmview_update_checks(win_i *info)
{
DView *disasm;
assert(info != NULL);
// assert(info->type == WIN_TYPE_MAIN);
disasm = get_view(info, DVT_DISASSEMBLY);
int rc = downcast<debug_view_disasm *>(disasm->view)->right_column();
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "raw_opcodes")), rc == DASM_RIGHTCOL_RAW);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "enc_opcodes")), rc == DASM_RIGHTCOL_ENCRYPTED);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "comments")), rc == DASM_RIGHTCOL_COMMENTS);
}
char *
warlock_view_get_text (const char *name)
{
GtkTextIter start, end;
WarlockView *view;
view = get_view (name);
gtk_text_buffer_get_start_iter (view->text_buffer, &start);
gtk_text_buffer_get_end_iter (view->text_buffer, &end);
return gtk_text_buffer_get_text (view->text_buffer, &start, &end,
FALSE);
}
static int
banlist_unban_inner (gpointer none, banlist_info *banl, int mode_num)
{
session *sess = banl->sess;
GtkTreeModel *model;
GtkTreeSelection *sel;
GtkTreeIter iter;
char tbuf[2048];
char **masks, *mask, *type;
int num_sel, i;
/* grab the list of selected items */
model = GTK_TREE_MODEL (get_store (sess));
sel = gtk_tree_view_get_selection (get_view (sess));
if (!gtk_tree_model_get_iter_first (model, &iter))
return 0;
masks = g_malloc (sizeof (char *) * banl->line_ct);
num_sel = 0;
do
{
if (gtk_tree_selection_iter_is_selected (sel, &iter))
{
/* Get the mask part of this selected line */
gtk_tree_model_get (model, &iter, TYPE_COLUMN, &type, MASK_COLUMN, &mask, -1);
/* If it's the wrong type of mask, just continue */
if (strcmp (_(modes[mode_num].type), type) != 0)
continue;
/* Otherwise add it to our array of mask pointers */
masks[num_sel++] = g_strdup (mask);
g_free (mask);
g_free (type);
}
}
while (gtk_tree_model_iter_next (model, &iter));
/* and send to server */
if (num_sel)
send_channel_modes (sess, tbuf, masks, 0, num_sel, '-', modes[mode_num].letter, 0);
/* now free everything */
for (i=0; i < num_sel; i++)
g_free (masks[i]);
g_free (masks);
return num_sel;
}
static void
banlist_clear_cb (GtkDialog *dialog, gint response, gpointer sess)
{
GtkTreeSelection *sel;
gtk_widget_destroy (GTK_WIDGET (dialog));
if (response == GTK_RESPONSE_OK)
{
sel = gtk_tree_view_get_selection (get_view (sess));
gtk_tree_selection_select_all (sel);
banlist_unban (NULL, sess);
}
}
void DiagramWindow::read_session(char * & st) {
unsigned w = read_unsigned(st);
resize(w, read_unsigned(st));
new_scale(read_unsigned(st));
get_view()->read_session(st);
}
static void memorywin_update_checks(win_i *info)
{
DView *memory = get_view(info, DVT_MEMORY);
debug_view_memory *memview = downcast<debug_view_memory *>(memory->view);
int bpc = memview->bytes_per_chunk();
bool rev = memview->reverse();
bool pa = memview->physical();
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "chunks_1")), bpc == 1);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "chunks_2")), bpc == 2);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "chunks_4")), bpc == 4);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "physical_addresses")), pa);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "logical_addresses")), !pa);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(info->win, "reverse")), rev);
}
static void debugmain_set_cpu(device_t *device)
{
win_i *dmain = get_first_win_i(WIN_TYPE_MAIN);
DView *dv;
if (device != dmain->cpu)
{
astring title;
dmain->cpu = device;
// first set all the views to the new cpu
// FIXME: Iterate over all views !
dv = get_view(dmain, DVT_DISASSEMBLY);
dv->view->set_source(*dv->view->source_list().match_device(device));
dv = get_view(dmain, DVT_STATE);
dv->view->set_source(*dv->view->source_list().match_device(device));
// then update the caption
title.printf("Debug: %s - %s '%s'", device->machine().system().name, device->name(), device->tag());
gtk_window_set_title(GTK_WINDOW(dmain->win), title);
disasmview_update_checks(dmain);
}
}
void on_run_to_cursor_activate(GtkWidget *win)
{
win_i *info = get_win_i(win, WIN_TYPE_ALL);
DView *disasm = get_view(info, DVT_DISASSEMBLY);
astring command;
if (disasm->view->cursor_visible())
{
if (debug_cpu_get_visible_cpu(*info->machine) == disasm->view->source()->device())
{
offs_t address = downcast<debug_view_disasm *>(disasm->view)->selected_address();
command.printf("go 0x%X", address);
debug_console_execute_command(*info->machine, command, 1);
}
}
}
void
warlock_view_end_line (const char *name)
{
WarlockView *view;
view = get_view (name);
if (view == NULL || view->shown == FALSE) {
view = main_view;
}
view->buffer = w_string_append_c (view->buffer, '\n');
// new line to insert after the prompt
if (prompting) {
view->buffer = w_string_prepend_c (view->buffer, '\n');
}
view_append (view, view->buffer);
w_string_free (view->buffer, TRUE);
view->buffer = NULL;
}
static void memorywin_zone_changed(GtkComboBox *zone_w, win_i *mem)
{
int sel = gtk_combo_box_get_active(zone_w);
astring title;
DView *memory = get_view(mem, DVT_MEMORY);
assert(mem->type == WIN_TYPE_MEMORY);
// update the source
memory->view->set_source(*memory->view->source_list().by_index(sel));
// change the checkmarks in the menu
memorywin_update_checks(mem);
// update the window title
const debug_view_source *source = memory->view->source();
title.printf("Memory: %s", source->name());
gtk_window_set_title(GTK_WINDOW(mem->win), title);
}
static GtkListStore *
get_store (struct session *sess)
{
return GTK_LIST_STORE (gtk_tree_view_get_model (get_view (sess)));
}
