gboolean setcolors(GdkColor **color)
{
gboolean *success;
gint i, ncolors;
gushort xcolor[19][4] = {{40000,20000,48000}, /* x axis marker color */
{40000,48000,20000}, /* y axis marker color */
{65535,00000,00000}, /* outer square color */
{65535,65535,65535}}; /* inner square color */
ncolors=4; /* Number of colors to be initialized */
*color = (GdkColor *) calloc (ncolors, sizeof(GdkColor)); /* Allocate memory for the colors */
success = (gboolean *) calloc (ncolors, sizeof(gboolean));
for(i=0;i<ncolors;i++) { /* Transfer colorindexes into colors array */
(*color)[i].red = xcolor[i][0];
(*color)[i].green = xcolor[i][1];
(*color)[i].blue = xcolor[i][2];
}
/* Allocate the colors */
gdk_colormap_alloc_colors(gdk_colormap_get_system(),*color, ncolors, FALSE, FALSE, success);
free(success);
return TRUE;
}
/* Set the node content with a row of strings */
static void set_node(GtkTreeIter * node, struct menu *menu, gchar ** row)
{
GdkColor color;
gboolean success;
GdkPixbuf *pix;
pix = gdk_pixbuf_new_from_xpm_data((const char **)
row[COL_PIXBUF]);
gdk_color_parse(row[COL_COLOR], &color);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &color, 1,
FALSE, FALSE, &success);
gtk_tree_store_set(tree, node,
COL_OPTION, row[COL_OPTION],
COL_NAME, row[COL_NAME],
COL_NO, row[COL_NO],
COL_MOD, row[COL_MOD],
COL_YES, row[COL_YES],
COL_VALUE, row[COL_VALUE],
COL_MENU, (gpointer) menu,
COL_COLOR, &color,
COL_EDIT, GPOINTER_TO_INT(row[COL_EDIT]),
COL_PIXBUF, pix,
COL_PIXVIS, GPOINTER_TO_INT(row[COL_PIXVIS]),
COL_BTNVIS, GPOINTER_TO_INT(row[COL_BTNVIS]),
COL_BTNACT, GPOINTER_TO_INT(row[COL_BTNACT]),
COL_BTNINC, GPOINTER_TO_INT(row[COL_BTNINC]),
COL_BTNRAD, GPOINTER_TO_INT(row[COL_BTNRAD]),
-1);
g_object_unref(pix);
}
extern "C" void svm_toy_initialize()
{
gboolean success[7];
gdk_colormap_alloc_colors(
gdk_colormap_get_system(),
colors,
7,
FALSE,
TRUE,
success);
gc = gdk_gc_new(draw_main->window);
pixmap = gdk_pixmap_new(draw_main->window,XLEN,YLEN,-1);
gdk_gc_set_foreground(gc,&colors[0]);
gdk_draw_rectangle(pixmap,gc,TRUE,0,0,XLEN,YLEN);
gtk_entry_set_text(GTK_ENTRY(entry_option),DEFAULT_PARAM);
}
static void ctree_refresh(GtkTreeStore *store)
{
GtkTreeModel *model = GTK_TREE_MODEL(store);
int i;
gchar *spath;
GtkTreePath *path;
GtkTreeIter iter;
uint32_t data;
gchar *sdata;
int changed;
GdkColor red, blue;
gboolean success;
GdkColor *color;
gdk_color_parse("Blue", &blue);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &blue, 1,
FALSE, FALSE, &success);
gdk_color_parse("Red", &red);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &red, 1,
FALSE, FALSE, &success);
// refresh Ax nodes
for(i = 0; i < 8; i++)
{
spath = g_strdup_printf("1:%i", i);
path = gtk_tree_path_new_from_string(spath);
if(!gtk_tree_model_get_iter(model, &iter, path))
continue;
changed = ti68k_register_get_addr(i, &data);
sdata = g_strdup_printf("%08x", data);
color = changed ? &red : &blue;
gtk_tree_store_set(store, &iter, COL_VALUE, sdata, -1);
gtk_tree_store_set(store, &iter, COL_COLOR, color, -1);
g_free(sdata);
g_free(spath);
gtk_tree_path_free(path);
}
// refresh Dx nodes
for(i = 0; i < 8; i++)
{
spath = g_strdup_printf("0:%i", i);
path = gtk_tree_path_new_from_string(spath);
if(!gtk_tree_model_get_iter(model, &iter, path))
continue;
changed = ti68k_register_get_data(i, &data);
sdata = g_strdup_printf("%08x", data);
color = changed ? &red : &blue;
gtk_tree_store_set(store, &iter, COL_VALUE, sdata, -1);
gtk_tree_store_set(store, &iter, COL_COLOR, color, -1);
g_free(sdata);
g_free(spath);
gtk_tree_path_free(path);
}
// refresh Others node (PC)
{
spath = g_strdup_printf("2:%i", 0);
path = gtk_tree_path_new_from_string(spath);
if(!gtk_tree_model_get_iter(model, &iter, path))
return;
changed = ti68k_register_get_pc(&data);
sdata = g_strdup_printf("%06x", data);
color = changed ? &red : &blue;
gtk_tree_store_set(store, &iter, COL_VALUE, sdata, -1);
gtk_tree_store_set(store, &iter, COL_COLOR, color, -1);
g_free(sdata);
g_free(spath);
gtk_tree_path_free(path);
}
// refresh Others node (USP)
{
spath = g_strdup_printf("2:%i", 1);
path = gtk_tree_path_new_from_string(spath);
if(!gtk_tree_model_get_iter(model, &iter, path))
return;
changed = ti68k_register_get_usp(&data);
sdata = g_strdup_printf("%06x", data);
color = changed ? &red : &blue;
gtk_tree_store_set(store, &iter, COL_VALUE, sdata, -1);
gtk_tree_store_set(store, &iter, COL_COLOR, color, -1);
g_free(sdata);
g_free(spath);
gtk_tree_path_free(path);
}
// refresh Others node (SSP)
{
spath = g_strdup_printf("2:%i", 2);
path = gtk_tree_path_new_from_string(spath);
if(!gtk_tree_model_get_iter(model, &iter, path))
return;
changed = ti68k_register_get_ssp(&data);
sdata = g_strdup_printf("%06x", data);
color = changed ? &red : &blue;
gtk_tree_store_set(store, &iter, COL_VALUE, sdata, -1);
gtk_tree_store_set(store, &iter, COL_COLOR, color, -1);
g_free(sdata);
g_free(spath);
gtk_tree_path_free(path);
}
// refresh Others node (SR)
{
spath = g_strdup_printf("2:%i", 3);
path = gtk_tree_path_new_from_string(spath);
if(!gtk_tree_model_get_iter(model, &iter, path))
return;
changed = ti68k_register_get_sr(&data);
sdata = g_strdup_printf("%04x", data);
color = changed ? &red : &blue;
gtk_tree_store_set(store, &iter, COL_VALUE, sdata, -1);
gtk_tree_store_set(store, &iter, COL_COLOR, color, -1);
g_free(sdata);
g_free(spath);
gtk_tree_path_free(path);
}
// refresh Others node (S & U flags)
{
char s_flags[32], u_flags[32];
changed = ti68k_register_get_flags(s_flags, u_flags);
color = changed ? &red : &blue;
spath = g_strdup_printf("2:%i", 4);
path = gtk_tree_path_new_from_string(spath);
if(!gtk_tree_model_get_iter(model, &iter, path))
return;
gtk_tree_store_set(store, &iter, COL_VALUE, s_flags, -1);
gtk_tree_store_set(store, &iter, COL_COLOR, color, -1);
g_free(spath);
gtk_tree_path_free(path);
spath = g_strdup_printf("2:%i", 5);
path = gtk_tree_path_new_from_string(spath);
if(!gtk_tree_model_get_iter(model, &iter, path))
return;
gtk_tree_store_set(store, &iter, COL_VALUE, u_flags, -1);
gtk_tree_store_set(store, &iter, COL_COLOR, color, -1);
g_free(spath);
gtk_tree_path_free(path);
}
}
static void ctree_populate(GtkTreeStore *store)
{
GtkTreeIter node1, node2, node3;
GtkTreeIter iter;
int i;
const char *others[] = { "PC", "USP", "SSP", "SR" , "sf", "uf"};
GdkColor color;
gboolean success;
gdk_color_parse("Blue", &color);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &color, 1,
FALSE, FALSE, &success);
// set the 3 main nodes
gtk_tree_store_append(store, &node1, NULL);
gtk_tree_store_set(store, &node1,
COL_NAME, "Data",
COL_VALUE, "",
COL_EDITABLE, FALSE,
COL_FONT, FONT_NAME,
-1);
gtk_tree_store_append(store, &node2, NULL);
gtk_tree_store_set(store, &node2,
COL_NAME, "Addr",
COL_VALUE, "",
COL_EDITABLE, FALSE,
COL_FONT, FONT_NAME,
-1);
gtk_tree_store_append(store, &node3, NULL);
gtk_tree_store_set(store, &node3,
COL_NAME, "Other",
COL_VALUE, "",
COL_EDITABLE, FALSE,
COL_FONT, FONT_NAME,
-1);
// populate Dx node
for(i = 0; i < 8; i++)
{
gchar *str = g_strdup_printf("D%i", i);
gtk_tree_store_append(store, &iter, &node1);
gtk_tree_store_set(store, &iter,
COL_NAME, str,
COL_VALUE, "000000",
COL_EDITABLE, TRUE,
COL_FONT, FONT_NAME,
COL_COLOR, &color,
-1);
g_free(str);
}
// populate Ax node
for(i = 0; i < 8; i++)
{
gchar *str = g_strdup_printf("A%i", i);
gtk_tree_store_append(store, &iter, &node2);
gtk_tree_store_set(store, &iter,
COL_NAME, str,
COL_VALUE, "000000",
COL_EDITABLE, TRUE,
COL_FONT, FONT_NAME,
COL_COLOR, &color,
-1);
g_free(str);
}
// populate Others node
for(i = 0; i < 6; i++)
{
gtk_tree_store_append(store, &iter, &node3);
gtk_tree_store_set(store, &iter,
COL_NAME, others[i],
COL_VALUE, "000000",
COL_EDITABLE, TRUE,
COL_FONT, FONT_NAME,
-1);
}
}
static GtkWidget *
create_window (int confirm_mode)
{
GtkWidget *w;
GtkWidget *win, *box, *ebox;
GtkWidget *sbox, *bbox;
GtkAccelGroup *acc;
/* fixme: check the grabbing code against the one we used with the
old gpg-agent */
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
acc = gtk_accel_group_new ();
gtk_signal_connect (GTK_OBJECT (win), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL);
#if 0
gtk_signal_connect (GTK_OBJECT(win), "destroy", gtk_main_quit, NULL);
#endif
gtk_signal_connect (GTK_OBJECT(win), "size-request", constrain_size, NULL);
if (!confirm_mode)
{
gtk_signal_connect (GTK_OBJECT(win),
pinentry->grab ? "map-event" : "focus-in-event",
grab_keyboard, NULL);
gtk_signal_connect (GTK_OBJECT(win),
pinentry->grab ? "unmap-event" : "focus-out-event",
ungrab_keyboard, NULL);
}
gtk_accel_group_attach(acc, GTK_OBJECT(win));
box = gtk_vbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER(win), box);
gtk_container_set_border_width (GTK_CONTAINER (box), 5);
if (pinentry->description)
{
w = create_utf8_label (pinentry->description);
gtk_box_pack_start (GTK_BOX(box), w, TRUE, FALSE, 0);
}
if (pinentry->error && !confirm_mode)
{
GtkStyle *style;
GdkColormap *cmap;
GdkColor color[1] = {{0, 0xffff, 0, 0}};
gboolean success[1];
w = create_utf8_label (pinentry->error);
gtk_box_pack_start (GTK_BOX(box), w, TRUE, FALSE, 5);
/* fixme: Do we need to release something, or is there a more
easy way to set a text color? */
gtk_widget_realize (win);
cmap = gdk_window_get_colormap (win->window);
assert (cmap);
gdk_colormap_alloc_colors (cmap, color, 1, FALSE, TRUE, success);
if (success[0])
{
gtk_widget_ensure_style(w);
style = gtk_style_copy(gtk_widget_get_style(w));
style->fg[GTK_STATE_NORMAL] = color[0];
gtk_widget_set_style(w, style);
}
}
ebox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX(box), ebox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (ebox), 5);
if (!confirm_mode)
{
if (pinentry->prompt)
{
w = create_utf8_label (pinentry->prompt);
gtk_box_pack_start (GTK_BOX(ebox), w, FALSE, FALSE, 0);
}
entry = gtk_secure_entry_new ();
gtk_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (enter_callback), entry);
gtk_box_pack_start (GTK_BOX(ebox), entry, TRUE, TRUE, 0);
gtk_secure_entry_set_visibility (GTK_SECURE_ENTRY(entry), FALSE);
gtk_signal_connect_after (GTK_OBJECT(entry), "button_press_event",
unselect, NULL);
gtk_widget_grab_focus (entry);
gtk_widget_show (entry);
if (pinentry->enhanced)
{
sbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(box), sbox, FALSE, FALSE, 0);
w = gtk_label_new ("Forget secret after");
gtk_box_pack_start(GTK_BOX(sbox), w, FALSE, FALSE, 0);
gtk_widget_show(w);
time_out = gtk_spin_button_new
(GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, HUGE_VAL,
1, 60, 60)),2,0);
gtk_box_pack_start (GTK_BOX(sbox), time_out, FALSE, FALSE, 0);
gtk_widget_show (time_out);
w = gtk_label_new ("seconds");
gtk_box_pack_start (GTK_BOX(sbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
gtk_widget_show (sbox);
insure = gtk_check_button_new_with_label
("ask before giving out secret");
gtk_box_pack_start (GTK_BOX(box), insure, FALSE, FALSE, 0);
gtk_widget_show (insure);
}
}
bbox = gtk_hbutton_box_new();
gtk_box_pack_start (GTK_BOX(box), bbox, TRUE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
w = gtk_button_new_with_label (pinentry->ok ? pinentry->ok : "OK");
gtk_container_add (GTK_CONTAINER(bbox), w);
if (!confirm_mode)
{
gtk_signal_connect (GTK_OBJECT(w), "clicked", button_clicked, "ok");
GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
gtk_widget_grab_default (w);
gtk_signal_connect_object (GTK_OBJECT (entry), "focus_in_event",
GTK_SIGNAL_FUNC (gtk_widget_grab_default),
GTK_OBJECT (w));
}
else
{
gtk_signal_connect (GTK_OBJECT(w), "clicked",
confirm_button_clicked, "ok");
GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
}
gtk_widget_show (w);
if (!pinentry->one_button)
{
w = gtk_button_new_with_label (pinentry->cancel
? pinentry->cancel : "Cancel");
gtk_container_add (GTK_CONTAINER(bbox), w);
gtk_accel_group_add (acc, GDK_Escape, 0, 0, GTK_OBJECT(w), "clicked");
gtk_signal_connect (GTK_OBJECT(w), "clicked",
confirm_mode? confirm_button_clicked: button_clicked,
NULL);
GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
}
gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
gtk_widget_show_all (win);
return win;
}
histoDrawing_t *histo_drawing_construct(HistoControlFlowData *histo_control_flow_data)
{
histoDrawing_t *drawing = g_new(histoDrawing_t, 1);
drawing->histo_control_flow_data = histo_control_flow_data;
drawing->vbox = gtk_vbox_new(FALSE, 1);
drawing->ruler_hbox = gtk_hbox_new(FALSE, 1);
drawing->ruler = gtk_drawing_area_new ();
//gtk_widget_set_size_request(drawing->ruler, -1, 27);
drawing->padding = gtk_drawing_area_new ();
//gtk_widget_set_size_request(drawing->padding, -1, 27);
gtk_box_pack_start(GTK_BOX(drawing->ruler_hbox), drawing->padding,FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(drawing->ruler_hbox), drawing->ruler,
TRUE, TRUE, 0);
drawing->drawing_area = gtk_drawing_area_new ();
drawing->gc = NULL;
/*
///at this time not necessary for histogram
drawing->hbox = gtk_hbox_new(FALSE, 1);
drawing->viewport = gtk_viewport_new(NULL, histo_control_flow_data->v_adjust);
drawing->scrollbar = gtk_vscrollbar_new(histo_control_flow_data->v_adjust);
gtk_box_pack_start(GTK_BOX(drawing->hbox), drawing->viewport,
TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(drawing->hbox), drawing->scrollbar,
FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(drawing->viewport),
drawing->drawing_area);*/
//add vertical ruler:
drawing->vruler_drawing_hbox = gtk_hbox_new(FALSE, 1);
drawing-> vertical_ruler =gtk_drawing_area_new ();
gtk_box_pack_start(GTK_BOX(drawing->vruler_drawing_hbox), drawing->vertical_ruler,
FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(drawing->vruler_drawing_hbox), drawing->drawing_area,
TRUE, TRUE, 1);
gtk_widget_set_size_request(drawing->vertical_ruler, padding_width, -1);
gtk_box_pack_start(GTK_BOX(drawing->vbox), drawing->ruler_hbox,
FALSE, FALSE, 1);
gtk_box_pack_end(GTK_BOX(drawing->vbox), drawing->vruler_drawing_hbox/*drawing_area*/,
TRUE, TRUE, 1);
drawing->pango_layout =
gtk_widget_create_pango_layout(drawing->drawing_area, NULL);
drawing->height = 1;
drawing->width = 1;
drawing->depth = 0;
drawing->alloc_height = 1;
drawing->alloc_width = 1;
drawing->damage_begin = 0;
drawing->damage_end = 0;
drawing->horizontal_sel = -1;
//gtk_widget_set_size_request(drawing->drawing_area->window, 50, 50);
g_object_set_data_full(
G_OBJECT(drawing->drawing_area),
"histo_Link_drawing_Data",
drawing,
(GDestroyNotify)histo_drawing_destroy);
g_object_set_data(
G_OBJECT(drawing->ruler),
"histo_drawing",
drawing);
g_object_set_data(
G_OBJECT(drawing->vertical_ruler),
"histo_drawing",
drawing);
//gtk_widget_modify_bg( drawing->drawing_area,
// GTK_STATE_NORMAL,
// &CF_Colors[BLACK]);
//gdk_window_get_geometry(drawing->drawing_area->window,
// NULL, NULL,
// &(drawing->width),
// &(drawing->height),
// -1);
//drawing->pixmap = gdk_pixmap_new(
// drawing->drawing_area->window,
// drawing->width,
// drawing->height,
// drawing->depth);
drawing->pixmap = NULL;
// drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
// drawing->drawing_area->allocation.width,
// drawing->drawing_area->allocation.height,
// -1);
g_signal_connect (G_OBJECT(drawing->drawing_area),
"configure_event",
G_CALLBACK (histo_configure_event),
(gpointer)drawing);
g_signal_connect (G_OBJECT(drawing->ruler),
"expose_event",
G_CALLBACK(histo_expose_ruler),
(gpointer)drawing);
gtk_widget_add_events(drawing->ruler, GDK_POINTER_MOTION_MASK);
gtk_widget_add_events(drawing->vertical_ruler, GDK_POINTER_MOTION_MASK);
g_signal_connect (G_OBJECT(drawing->ruler),
"motion-notify-event",
G_CALLBACK(histo_motion_notify_ruler),
(gpointer)drawing);
g_signal_connect (G_OBJECT(drawing->vertical_ruler),
"expose_event",
G_CALLBACK(histo_expose_vertical_ruler),
(gpointer)drawing);
g_signal_connect (G_OBJECT(drawing->vertical_ruler),
"motion-notify-event",
G_CALLBACK(histo_motion_notify_vertical_ruler),
(gpointer)drawing);
/*//not necessary for historam.
g_signal_connect (G_OBJECT(drawing->drawing_area),
"size-allocate",
G_CALLBACK(scrollbar_size_allocate),
(gpointer)drawing); */
gtk_widget_set_size_request(drawing->padding, padding_width, -1);//use it for vertical ruler
g_signal_connect (G_OBJECT(drawing->drawing_area),
"expose_event",
G_CALLBACK (histo_expose_event),
(gpointer)drawing);
g_signal_connect_after (G_OBJECT(drawing->drawing_area),
"expose_event",
G_CALLBACK (histo_after_expose_event),
(gpointer)drawing);
g_signal_connect (G_OBJECT(drawing->drawing_area),
"button-press-event",
G_CALLBACK (histo_button_press_event),
(gpointer)drawing);
gtk_widget_show(drawing->ruler);
gtk_widget_show(drawing->padding);
gtk_widget_show(drawing->ruler_hbox);
gtk_widget_show(drawing->vertical_ruler);
gtk_widget_show(drawing->vruler_drawing_hbox);
gtk_widget_show(drawing->drawing_area);
/// gtk_widget_show(drawing->viewport);
/// gtk_widget_show(drawing->scrollbar);
/// gtk_widget_show(drawing->hbox);
/* Allocate the colors */
GdkColormap* colormap = gdk_colormap_get_system();
gboolean success[NUM_COLORS];
gdk_colormap_alloc_colors(colormap, histo_drawing_colors, NUM_COLORS, FALSE,
TRUE, success);
drawing->gc =
gdk_gc_new(GDK_DRAWABLE(main_window_get_widget(histo_control_flow_data->tab)->window));
drawing->dotted_gc =
gdk_gc_new(GDK_DRAWABLE(main_window_get_widget(histo_control_flow_data->tab)->window));
gdk_gc_copy(drawing->gc,
main_window_get_widget(histo_control_flow_data->tab)->style->black_gc);
gdk_gc_copy(drawing->dotted_gc,
main_window_get_widget(histo_control_flow_data->tab)->style->white_gc);
gint8 dash_list[] = { 1, 2 };
gdk_gc_set_line_attributes(drawing->dotted_gc,
1,
GDK_LINE_ON_OFF_DASH,
GDK_CAP_BUTT,
GDK_JOIN_MITER);
gdk_gc_set_dashes(drawing->dotted_gc,
0,
dash_list,
2);
drawing->ruler_gc_butt =
gdk_gc_new(GDK_DRAWABLE(main_window_get_widget(histo_control_flow_data->tab)->window));
gdk_gc_copy(drawing->ruler_gc_butt,
main_window_get_widget(histo_control_flow_data->tab)->style->black_gc);
drawing->ruler_gc_round =
gdk_gc_new(GDK_DRAWABLE(main_window_get_widget(histo_control_flow_data->tab)->window));
gdk_gc_copy(drawing->ruler_gc_round,
main_window_get_widget(histo_control_flow_data->tab)->style->black_gc);
gdk_gc_set_line_attributes(drawing->ruler_gc_butt,
2,
GDK_LINE_SOLID,
GDK_CAP_BUTT,
GDK_JOIN_MITER);
gdk_gc_set_line_attributes(drawing->ruler_gc_round,
2,
GDK_LINE_SOLID,
GDK_CAP_ROUND,
GDK_JOIN_ROUND);
return drawing;
}
void log_window_init(LogWindow *logwin)
{
GtkTextBuffer *buffer;
#if !GTK_CHECK_VERSION(3, 0, 0)
GdkColormap *colormap;
gboolean success[LOG_COLORS];
#endif
GdkColor color[LOG_COLORS];
gint i;
gtkut_convert_int_to_gdk_color(prefs_common.log_msg_color, &color[0]);
gtkut_convert_int_to_gdk_color(prefs_common.log_warn_color, &color[1]);
gtkut_convert_int_to_gdk_color(prefs_common.log_error_color, &color[2]);
gtkut_convert_int_to_gdk_color(prefs_common.log_in_color, &color[3]);
gtkut_convert_int_to_gdk_color(prefs_common.log_out_color, &color[4]);
gtkut_convert_int_to_gdk_color(prefs_common.log_status_ok_color, &color[5]);
gtkut_convert_int_to_gdk_color(prefs_common.log_status_nok_color, &color[6]);
gtkut_convert_int_to_gdk_color(prefs_common.log_status_skip_color, &color[7]);
logwin->msg_color = color[0];
logwin->warn_color = color[1];
logwin->error_color = color[2];
logwin->in_color = color[3];
logwin->out_color = color[4];
logwin->status_ok_color = color[5];
logwin->status_nok_color = color[6];
logwin->status_skip_color = color[7];
#if !GTK_CHECK_VERSION(3, 0, 0)
colormap = gdk_drawable_get_colormap(gtk_widget_get_window(logwin->window));
gdk_colormap_alloc_colors(colormap, color, LOG_COLORS, FALSE, TRUE, success);
for (i = 0; i < LOG_COLORS; i++) {
if (success[i] == FALSE) {
GtkStyle *style;
g_warning("LogWindow: color allocation failed");
style = gtk_widget_get_style(logwin->window);
logwin->msg_color = logwin->warn_color =
logwin->error_color = logwin->in_color =
logwin->out_color = logwin->status_ok_color =
logwin->status_nok_color = logwin->status_skip_color =
style->black;
break;
}
}
#endif
buffer = logwin->buffer;
gtk_text_buffer_create_tag(buffer, "message",
"foreground-gdk", &logwin->msg_color,
NULL);
gtk_text_buffer_create_tag(buffer, "warn",
"foreground-gdk", &logwin->warn_color,
NULL);
logwin->error_tag = gtk_text_buffer_create_tag(buffer, "error",
"foreground-gdk", &logwin->error_color,
NULL);
gtk_text_buffer_create_tag(buffer, "input",
"foreground-gdk", &logwin->in_color,
NULL);
gtk_text_buffer_create_tag(buffer, "output",
"foreground-gdk", &logwin->out_color,
NULL);
gtk_text_buffer_create_tag(buffer, "status_ok",
"foreground-gdk", &logwin->status_ok_color,
NULL);
gtk_text_buffer_create_tag(buffer, "status_nok",
"foreground-gdk", &logwin->status_nok_color,
NULL);
gtk_text_buffer_create_tag(buffer, "status_skip",
"foreground-gdk", &logwin->status_skip_color,
NULL);
}
static void clist_populate(GtkListStore *store, uint32_t start, int length)
{
GtkTreeIter iter;
int i;
gchar *str;
char ascii[17];
uint32_t a;
GdkColor gray, black, red, white;
gboolean success;
GdkColor *color = &black;
//static uint8_t old[DUMP_SIZE] = { 0 };
//static uint8_t *old_ptr;
gdk_color_parse("DarkGray", &gray);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &gray, 1,
FALSE, FALSE, &success);
gdk_color_parse("Black", &black);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &black, 1,
FALSE, FALSE, &success);
gdk_color_parse("Red", &red);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &red, 1,
FALSE, FALSE, &success);
gdk_color_parse("White", &white);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &white, 1,
FALSE, FALSE, &success);
//old_ptr = old;
for(a = start; a < start+length; a += 0x10)
{
uint32_t addr = a & 0xffffff;
uint8_t mem;
char *utf;
gsize bw;
gtk_list_store_append(store, &iter);
str = g_strdup_printf("%06x", addr);
gtk_list_store_set(store, &iter,
COL_ADDR, str,
COL_GRAY, &gray,
-1);
g_free(str);
if(options3.dbg_font_type)
gtk_list_store_set(store, &iter, COL_FONT, options3.dbg_font_name, -1);
else
gtk_list_store_set(store, &iter, COL_FONT, "courier", -1);
for(i = COL_0; i <= COL_F; i++)
{
if(addr + (i-COL_0) != 0x60000f)
mem = mem_rd_byte(addr + (i-COL_0));
else
mem = 0xff;
str = g_strdup_printf("%02x", mem);
ascii[i-COL_0] = (isprint(mem) && !iscntrl(mem) ? mem : '.');
/*
if(*old_ptr != *mem_ptr)
{
*old_ptr++ = *mem_ptr;
color = &red;
printf("$");
}
else
{
old_ptr++;
color = &black;
printf(".");
}
*/
gtk_list_store_set(store, &iter,
i, str,
COL_EDITABLE, TRUE,
COL_COLOR, color,
i + CLIST_NVCOLS - COL_0, &white,
-1);
g_free(str);
}
ascii[16] = '\0';
utf = g_locale_to_utf8(ascii, -1, NULL, &bw, NULL);
gtk_list_store_set(store, &iter, COL_ASCII, utf, -1);
}
}
static gint search_highlight(uint32_t blk_beg, uint32_t blk_end, int state)
{
GtkNotebook *nb = GTK_NOTEBOOK(notebook);
gint page = gtk_notebook_get_current_page(nb);
GtkWidget *tab;
GtkWidget *label;
G_CONST_RETURN gchar *text;
uint32_t tab_adr, addr, offset;
gint i;
gint start, stop;
GList *l, *elt;
GtkWidget *list;
GtkTreeView *view;
GtkTreeModel *model;
GtkListStore *store;
GtkTreeIter iter;
gboolean valid;
GdkColor white, green;
gboolean success;
gdk_color_parse("White", &white);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &white, 1,
FALSE, FALSE, &success);
gdk_color_parse("Green", &green);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &green, 1,
FALSE, FALSE, &success);
// retrieve addr by tab name
tab = gtk_notebook_get_nth_page(nb, page);
label = gtk_notebook_get_tab_label(nb, tab);
text = gtk_label_get_text(GTK_LABEL(label));
sscanf(text, "%06x", &tab_adr);
// get list pointer (we have 1 child)
l = gtk_container_get_children(GTK_CONTAINER(nb));
elt = g_list_nth(l, page);
list = GTK_WIDGET(elt->data);
view = GTK_TREE_VIEW(list);
model = gtk_tree_view_get_model(view);
store = GTK_LIST_STORE(model);
// scroll mem
if(!IS_BOUNDED(tab_adr, blk_beg, tab_adr + DUMP_SIZE))
{
nb = GTK_NOTEBOOK(notebook);
page = gtk_notebook_get_current_page(nb);
offset = (blk_beg - tab_adr) & 0xfffff0;
refresh_page(page, offset);
while(gtk_events_pending()) gtk_main_iteration();
tab_adr += offset;
tab_adr &= 0xffffff;
}
// change background color
for(valid = gtk_tree_model_get_iter_first(model, &iter), addr = tab_adr;
valid && (addr - tab_adr < DUMP_SIZE);
valid = gtk_tree_model_iter_next(model, &iter), addr += 0x10)
{
// clear selection
for(i = 0; i < 16; i++)
gtk_list_store_set(store, &iter, i + COL_S0, &white, -1);
if(addr + 16 <= blk_beg)
continue;
if(addr > blk_end)
continue;
start = !addr ? blk_beg : blk_beg % addr;
if(start > 15) start = 0;
stop = !addr ? blk_end : blk_end % addr;
if(stop > 15) stop = 16;
// set selection
for(i = start; (i < 16) && (i < stop); i++)
gtk_list_store_set(store, &iter, i + COL_S0, &green, -1);
}
return 0;
}
/* this is called for a mode change: */
int
_tme_gtk_screen_mode_change(struct tme_fb_connection *conn_fb)
{
struct tme_gtk_display *display;
struct tme_gtk_screen *screen;
struct tme_fb_connection *conn_fb_other;
struct tme_fb_xlat fb_xlat_q;
const struct tme_fb_xlat *fb_xlat_a;
int scale;
unsigned long fb_area, avail_area, percentage;
gint width, height;
gint height_extra;
const void *map_g_old;
const void *map_r_old;
const void *map_b_old;
const tme_uint32_t *map_pixel_old;
tme_uint32_t map_pixel_count_old;
tme_uint32_t colorset;
GdkImage *gdkimage;
GdkVisual *visual;
tme_uint32_t color_count, color_i;
tme_uint32_t color_count_distinct;
tme_uint32_t color_j;
struct tme_fb_color *colors_tme;
GdkColor *colors_gdk;
gboolean *success;
gboolean warned_color_alloc;
/* recover our data structures: */
display = conn_fb->tme_fb_connection.tme_connection_element->tme_element_private;
conn_fb_other = (struct tme_fb_connection *) conn_fb->tme_fb_connection.tme_connection_other;
/* lock our mutex: */
tme_mutex_lock(&display->tme_gtk_display_mutex);
/* find the screen that this framebuffer connection references: */
for (screen = display->tme_gtk_display_screens;
(screen != NULL
&& screen->tme_gtk_screen_fb != conn_fb);
screen = screen->tme_gtk_screen_next);
assert (screen != NULL);
/* if the user hasn't specified a scaling, pick one: */
scale = screen->tme_gtk_screen_fb_scale;
if (scale < 0) {
/* calulate the areas, in square pixels, of the emulated
framebuffer and the host's screen: */
fb_area = (conn_fb_other->tme_fb_connection_width
* conn_fb_other->tme_fb_connection_height);
avail_area = (gdk_screen_width()
* gdk_screen_height());
/* see what percentage of the host's screen would be taken up by
an unscaled emulated framebuffer: */
percentage = (fb_area * 100) / avail_area;
/* if this is at least 70%, halve the emulated framebuffer, else
if this is 30% or less, double the emulated framebuffer: */
if (percentage >= 70) {
scale = TME_FB_XLAT_SCALE_HALF;
}
else if (percentage <= 30) {
scale = TME_FB_XLAT_SCALE_DOUBLE;
}
else {
scale = TME_FB_XLAT_SCALE_NONE;
}
screen->tme_gtk_screen_fb_scale = -scale;
}
/* get the system's default visual: */
visual = gdk_visual_get_system();
/* get the required dimensions for the GdkImage: */
width = ((conn_fb_other->tme_fb_connection_width
* scale)
/ TME_FB_XLAT_SCALE_NONE);
height = ((conn_fb_other->tme_fb_connection_height
* scale)
/ TME_FB_XLAT_SCALE_NONE);
/* NB: we need to allocate an extra scanline's worth (or, if we're
doubling, an extra two scanlines' worth) of image, because the
framebuffer translation functions can sometimes overtranslate
(see the explanation of TME_FB_XLAT_RUN in fb-xlat-auto.sh): */
height_extra
= (scale == TME_FB_XLAT_SCALE_DOUBLE
? 2
: 1);
/* if the previous gdkimage isn't the right size: */
gdkimage = screen->tme_gtk_screen_gdkimage;
if (gdkimage->width != width
|| gdkimage->height != (height + height_extra)) {
/* allocate a new gdkimage: */
gdkimage = gdk_image_new(GDK_IMAGE_FASTEST,
visual,
width,
height
+ height_extra);
/* set the new image on the image widget: */
gtk_image_set(GTK_IMAGE(screen->tme_gtk_screen_gtkimage),
gdkimage,
NULL);
/* destroy the previous gdkimage and remember the new one: */
gdk_image_destroy(screen->tme_gtk_screen_gdkimage);
screen->tme_gtk_screen_gdkimage = gdkimage;
}
/* remember all previously allocated maps and colors, but otherwise
remove them from our framebuffer structure: */
map_g_old = conn_fb->tme_fb_connection_map_g;
map_r_old = conn_fb->tme_fb_connection_map_r;
map_b_old = conn_fb->tme_fb_connection_map_b;
map_pixel_old = conn_fb->tme_fb_connection_map_pixel;
map_pixel_count_old = conn_fb->tme_fb_connection_map_pixel_count;
conn_fb->tme_fb_connection_map_g = NULL;
conn_fb->tme_fb_connection_map_r = NULL;
conn_fb->tme_fb_connection_map_b = NULL;
conn_fb->tme_fb_connection_map_pixel = NULL;
conn_fb->tme_fb_connection_map_pixel_count = 0;
/* update our framebuffer connection: */
conn_fb->tme_fb_connection_width = width;
conn_fb->tme_fb_connection_height = height;
conn_fb->tme_fb_connection_depth = gdkimage->depth;
conn_fb->tme_fb_connection_bits_per_pixel = _tme_gtk_gdkimage_bipp(gdkimage);
conn_fb->tme_fb_connection_skipx = 0;
conn_fb->tme_fb_connection_scanline_pad = _tme_gtk_gdkimage_scanline_pad(gdkimage);
conn_fb->tme_fb_connection_order = (gdkimage->byte_order == GDK_LSB_FIRST
? TME_ENDIAN_LITTLE
: TME_ENDIAN_BIG);
conn_fb->tme_fb_connection_buffer = gdkimage->mem;
switch (visual->type) {
case GDK_VISUAL_STATIC_GRAY:
case GDK_VISUAL_GRAYSCALE:
conn_fb->tme_fb_connection_class = TME_FB_XLAT_CLASS_MONOCHROME;
break;
default:
assert(FALSE);
/* FALLTHROUGH */
case GDK_VISUAL_STATIC_COLOR:
case GDK_VISUAL_PSEUDO_COLOR:
case GDK_VISUAL_DIRECT_COLOR:
case GDK_VISUAL_TRUE_COLOR:
conn_fb->tme_fb_connection_class = TME_FB_XLAT_CLASS_COLOR;
break;
}
switch (visual->type) {
case GDK_VISUAL_DIRECT_COLOR:
/* we set the primary maps to anything non-NULL, to indicate that
primaries are index mapped: */
conn_fb->tme_fb_connection_map_g = conn_fb;
conn_fb->tme_fb_connection_map_r = conn_fb;
conn_fb->tme_fb_connection_map_b = conn_fb;
/* FALLTHROUGH */
case GDK_VISUAL_TRUE_COLOR:
conn_fb->tme_fb_connection_mask_g = visual->green_mask;
conn_fb->tme_fb_connection_mask_r = visual->red_mask;
conn_fb->tme_fb_connection_mask_b = visual->blue_mask;
break;
default:
conn_fb->tme_fb_connection_mask_g = 0;
conn_fb->tme_fb_connection_mask_r = 0;
conn_fb->tme_fb_connection_mask_b = 0;
break;
}
/* get the needed colors: */
colorset = tme_fb_xlat_colors_get(conn_fb_other, scale, conn_fb, &colors_tme);
color_count = conn_fb->tme_fb_connection_map_pixel_count;
/* if we need to allocate colors, but the colorset is not tied to
the source framebuffer characteristics, and is identical to the
currently allocated colorset, we can reuse the previously
allocated maps and colors: */
if (color_count > 0
&& colorset != TME_FB_COLORSET_NONE
&& colorset == screen->tme_gtk_screen_colorset) {
/* free the requested color array: */
tme_free(colors_tme);
/* restore the previously allocated maps and colors: */
conn_fb->tme_fb_connection_map_g = map_g_old;
conn_fb->tme_fb_connection_map_r = map_r_old;
conn_fb->tme_fb_connection_map_b = map_b_old;
conn_fb->tme_fb_connection_map_pixel = map_pixel_old;
conn_fb->tme_fb_connection_map_pixel_count = map_pixel_count_old;
}
/* otherwise, we may need to free and/or allocate colors: */
else {
/* save the colorset signature: */
screen->tme_gtk_screen_colorset = colorset;
/* free any previously allocated maps and colors: */
if (map_g_old != NULL) {
tme_free((void *) map_g_old);
}
if (map_r_old != NULL) {
tme_free((void *) map_r_old);
}
if (map_b_old != NULL) {
tme_free((void *) map_b_old);
}
if (map_pixel_old != NULL) {
/* recreate the array of GdkColor: */
colors_gdk = tme_new(GdkColor, map_pixel_count_old);
color_i = 0;
do {
colors_gdk[color_i].pixel = map_pixel_old[color_i];
} while (++color_i < map_pixel_count_old);
/* free the colors: */
gdk_colormap_free_colors(gdk_colormap_get_system(),
colors_gdk,
map_pixel_count_old);
tme_free(colors_gdk);
tme_free((void *) map_pixel_old);
}
/* if we need to allocate colors: */
if (color_count > 0) {
/* make the GdkColor array, and count the number of distinct colors: */
colors_gdk = tme_new(GdkColor, color_count * 2);
color_count_distinct = 0;
for (color_i = 0; color_i < color_count; color_i++) {
color_j = colors_tme[color_i].tme_fb_color_pixel;
colors_gdk[color_j].green = colors_tme[color_i].tme_fb_color_value_g;
colors_gdk[color_j].red = colors_tme[color_i].tme_fb_color_value_r;
colors_gdk[color_j].blue = colors_tme[color_i].tme_fb_color_value_b;
if (color_j >= color_count_distinct) {
color_count_distinct = color_j + 1;
}
}
success = tme_new(gboolean, color_count_distinct);
/* allocate exact matches for as many colors as possible: */
gdk_colormap_alloc_colors(gdk_colormap_get_system(),
colors_gdk,
color_count_distinct,
FALSE,
FALSE,
success);
/* allocate read-only best matches for any colors we failed to
allocate exactly: */
warned_color_alloc = FALSE;
for (color_i = 0; color_i < color_count; color_i++) {
color_j = colors_tme[color_i].tme_fb_color_pixel;
if (!success[color_j]) {
if (!gdk_colormap_alloc_color(gdk_colormap_get_system(),
&colors_gdk[color_j],
FALSE,
TRUE)) {
if (!warned_color_alloc) {
warned_color_alloc = TRUE;
tme_log(&display->tme_gtk_display_element->tme_element_log_handle, 0, ENOMEM,
(&display->tme_gtk_display_element->tme_element_log_handle,
_("could not allocate all colors")));
}
}
}
colors_tme[color_i].tme_fb_color_pixel = colors_gdk[color_j].pixel;
}
/* free the arrays used with gdk_colormap_alloc_colors(): */
tme_free(success);
tme_free(colors_gdk);
/* set the needed colors: */
tme_fb_xlat_colors_set(conn_fb_other, scale, conn_fb, colors_tme);
}
}
/* compose the framebuffer translation question: */
fb_xlat_q.tme_fb_xlat_width = conn_fb_other->tme_fb_connection_width;
fb_xlat_q.tme_fb_xlat_height = conn_fb_other->tme_fb_connection_height;
fb_xlat_q.tme_fb_xlat_scale = (unsigned int) scale;
fb_xlat_q.tme_fb_xlat_src_depth = conn_fb_other->tme_fb_connection_depth;
fb_xlat_q.tme_fb_xlat_src_bits_per_pixel = conn_fb_other->tme_fb_connection_bits_per_pixel;
fb_xlat_q.tme_fb_xlat_src_skipx = conn_fb_other->tme_fb_connection_skipx;
fb_xlat_q.tme_fb_xlat_src_scanline_pad = conn_fb_other->tme_fb_connection_scanline_pad;
fb_xlat_q.tme_fb_xlat_src_order = conn_fb_other->tme_fb_connection_order;
fb_xlat_q.tme_fb_xlat_src_class = conn_fb_other->tme_fb_connection_class;
fb_xlat_q.tme_fb_xlat_src_map = (conn_fb_other->tme_fb_connection_map_g != NULL
? TME_FB_XLAT_MAP_INDEX
: TME_FB_XLAT_MAP_LINEAR);
fb_xlat_q.tme_fb_xlat_src_map_bits = conn_fb_other->tme_fb_connection_map_bits;
fb_xlat_q.tme_fb_xlat_src_mask_g = conn_fb_other->tme_fb_connection_mask_g;
fb_xlat_q.tme_fb_xlat_src_mask_r = conn_fb_other->tme_fb_connection_mask_r;
fb_xlat_q.tme_fb_xlat_src_mask_b = conn_fb_other->tme_fb_connection_mask_b;
fb_xlat_q.tme_fb_xlat_dst_depth = conn_fb->tme_fb_connection_depth;
fb_xlat_q.tme_fb_xlat_dst_bits_per_pixel = conn_fb->tme_fb_connection_bits_per_pixel;
fb_xlat_q.tme_fb_xlat_dst_skipx = conn_fb->tme_fb_connection_skipx;
fb_xlat_q.tme_fb_xlat_dst_scanline_pad = conn_fb->tme_fb_connection_scanline_pad;
fb_xlat_q.tme_fb_xlat_dst_order = conn_fb->tme_fb_connection_order;
fb_xlat_q.tme_fb_xlat_dst_map = (conn_fb->tme_fb_connection_map_g != NULL
? TME_FB_XLAT_MAP_INDEX
: TME_FB_XLAT_MAP_LINEAR);
fb_xlat_q.tme_fb_xlat_dst_mask_g = conn_fb->tme_fb_connection_mask_g;
fb_xlat_q.tme_fb_xlat_dst_mask_r = conn_fb->tme_fb_connection_mask_r;
fb_xlat_q.tme_fb_xlat_dst_mask_b = conn_fb->tme_fb_connection_mask_b;
/* ask the framebuffer translation question: */
fb_xlat_a = tme_fb_xlat_best(&fb_xlat_q);
/* if this translation isn't optimal, log a note: */
if (!tme_fb_xlat_is_optimal(fb_xlat_a)) {
tme_log(&display->tme_gtk_display_element->tme_element_log_handle, 0, TME_OK,
(&display->tme_gtk_display_element->tme_element_log_handle,
_("no optimal framebuffer translation function available")));
}
/* save the translation function: */
screen->tme_gtk_screen_fb_xlat = fb_xlat_a->tme_fb_xlat_func;
/* force the next translation to do a complete redraw: */
screen->tme_gtk_screen_full_redraw = TRUE;
/* unlock our mutex: */
tme_mutex_unlock(&display->tme_gtk_display_mutex);
/* done: */
return (TME_OK);
}
