/*
we get here when the entry in a cell is changed (typed a digit), we
copy it to the entry above the sheet.
*/
static void
show_entry(GtkWidget *widget, Register_Window *rw)
{
char *text;
GtkSheet *sheet;
GtkWidget * sheet_entry;
gint row, col;
if(widget==NULL|| rw==NULL)
{
printf("Warning show_entry(%x,%x)\n",(unsigned int)widget,(unsigned int)rw);
return;
}
if(!GTK_WIDGET_HAS_FOCUS(widget)) return;
sheet=GTK_SHEET(rw->register_sheet);
sheet_entry = gtk_sheet_get_entry(sheet);
row=sheet->active_cell.row; col=sheet->active_cell.col;
if(gpsim_get_register_name(gp->pic_id,rw->type, rw->row_to_address[row]+col))
{
if((text=gtk_entry_get_text (GTK_ENTRY(sheet_entry))))
gtk_entry_set_text(GTK_ENTRY(rw->entry), text);
}
}
// button press handler
static gint
do_popup(GtkWidget *widget, GdkEventButton *event, Register_Window *rw)
{
GtkWidget *popup;
// GdkModifierType mods;
GtkSheet *sheet;
popup=rw->popup_menu;
if(widget==NULL || event==NULL || rw==NULL)
{
printf("Warning do_popup(%x,%x,%x)\n",(unsigned int)widget,(unsigned int)event,(unsigned int)rw);
return 0;
}
sheet=GTK_SHEET(widget);
if( (event->type == GDK_BUTTON_PRESS) && (event->button == 3) )
{
/* if (event->window == sheet->column_title_window )
//printf("popup column window\n");
return TRUE;
else if (event->window == sheet->row_title_window )
//printf("popup window\n");
return TRUE;
else*/
popup_rw = rw;
gtk_menu_popup(GTK_MENU(popup), NULL, NULL, NULL, NULL,
3, event->time);
}
return FALSE;
}
static void xref_update_cell(struct cross_reference_to_gui *xref, int new_value)
{
Register *reg;
Register_Window *rw;
int address;
if(xref == NULL)
{
printf("Warning update_register_cell: xref=%x\n",(unsigned int)xref);
if(xref->data == NULL || xref->parent_window==NULL)
{
printf("Warning update_register_cell: xref->data=%x, xref->parent_window=%x\n",(unsigned int)xref->data,(unsigned int)xref->parent_window);
}
return;
}
reg = (Register *) (xref->data);
rw = (Register_Window *) (xref->parent_window);
if(reg->row > GTK_SHEET(rw->register_sheet)->maxrow)
{
puts("Warning reg->row > maxrow in xref_update_cell");
return;
}
address = rw->row_to_address[reg->row]+reg->col;
rw->registers[address]->update_full=TRUE;
update_register_cell(rw, address);
update_ascii(rw,reg->row);
}
static void update_ascii(Register_Window *rw, gint row)
{
gint i;
gchar name[32];
if(rw == NULL || row<0 || row > rw->register_sheet->maxrow)
{
printf("Warning update_ascii(%x,%x)\n",(unsigned int)rw,row);
return;
}
if(row<0 || row>rw->register_sheet->maxrow)
return;
for(i=0; i<REGISTERS_PER_ROW; i++)
{
name[i] = rw->registers[rw->row_to_address[row] + i]->value;
if( (name[i] < ' ') || (name[i]>'z'))
name[i] = '.';
}
name[REGISTERS_PER_ROW] = 0;
gtk_sheet_set_cell(GTK_SHEET(rw->register_sheet), row,REGISTERS_PER_ROW, GTK_JUSTIFY_RIGHT,name);
}
GList *
glade_gtk_sheet_get_children(GladeWidgetAdaptor *adaptor, GtkContainer *container)
{
GList *children = NULL;
GtkSheet *sheet;
gint col;
#ifdef GTK_SHEET_DEBUG
g_debug("glade_gtk_sheet_get_children: called");
#endif
g_return_val_if_fail (GTK_IS_SHEET (container), NULL);
sheet = GTK_SHEET(container);
/*
gtk_container_forall (container,
gtk_sheet_children_callback,
&children);
*/
for (col=0; col<=sheet->maxcol; col++)
{
children = g_list_append(children, sheet->column[col]);
}
/* Is the children list already reversed? */
return children;
}
void
glade_gtk_sheet_remove_child(GladeWidgetAdaptor *adaptor, GObject *object, GObject *child)
{
gint col;
GtkSheet *sheet;
GtkSheetColumn *oldcol;
#ifdef GTK_SHEET_DEBUG
g_debug("glade_gtk_sheet_remove_child: called");
#endif
g_return_if_fail (GTK_IS_SHEET (object));
g_return_if_fail (GTK_IS_WIDGET (child));
sheet = GTK_SHEET(object);
oldcol = GTK_SHEET_COLUMN(child);
for (col=0; col<=sheet->maxcol; col++)
{
if (oldcol == sheet->column[col])
{
gtk_sheet_delete_columns(sheet, col, 1);
return;
}
}
g_warning("glade_gtk_sheet_remove_child: couldn't remove child %p", child);
}
void RegWindow_update(Register_Window *rw)
{
GUI_Processor *gp;
int address;
gboolean row_changed;
int j, i;
if(rw == NULL)
{
printf("Warning RegWindow_update(%x)\n",(unsigned int)rw);
return;
}
if( !((GUI_Object*)rw)->enabled)
return;
if(!GTK_WIDGET_VISIBLE(((GUI_Object*)rw)->window))
{
puts("ASHFSDHHFDHFD");
return;
}
if(!rw->registers_loaded)
return;
gp = ((GUI_Object*)rw)->gp;
if(gp==NULL || gp->pic_id==0)
{
puts("Warning gp or gp->pic_id == NULL in RegWindow_update");
return;
}
// gtk_sheet_freeze(rw->register_sheet);
for(j = 0; j<=GTK_SHEET(rw->register_sheet)->maxrow; j++)
{
if(rw->row_to_address[j]==-1)
continue;
row_changed = FALSE;
for(i = 0; i<REGISTERS_PER_ROW; i++)
{
address = rw->row_to_address[j]+i;
if(rw->registers[address]->value!=-1 || rw->registers[address]->update_full)
if(update_register_cell(rw, rw->row_to_address[j]+i) == TRUE)
row_changed = TRUE;
}
if(row_changed)
update_ascii(rw,j);
}
}
void
RecordView::AddSheetRecord (Sheet * sheet) {
ASSERT (sheet != NULL);
GtkSheet * gtksheet = GTK_SHEET (sheet->gtk_sheet);
GtkSheetRange range = {gtksheet->range.row0, 0, gtksheet->range.rowi, 0};
Row * tuple = row_new (gtksheet->maxcol + 1);
gint sheet_rows = 1;
// More than one row is selected; we must transpose them all into the RV sheet.
if (range.row0 != range.rowi) {
sheet_rows = range.rowi - range.row0 + 1;
}
Sheet * record_sheet = this->wb->add_new_sheet (this->wb,sheet->name,gtksheet->maxcol + 1,sheet_rows);
int column = 0, row = 0;
do {
sheet->get_row (sheet, range.row0, tuple->cells, tuple->size);
// Change the titles of the columns to the row titles. This is only going to work if the
// row titles have been explicitly set somewhere inside of the plugin.
record_sheet->set_column_title (record_sheet,
row,
sheet->row_titles->cells[range.row0]->value->str);
for (int ii = 0; ii < tuple->size; ii++) {
// We only need to change the row titles once. This can happen on our last iteration.
if (range.row0 == range.rowi) {
record_sheet->set_row_title (record_sheet,
ii,
sheet->column_titles->cells[ii]->value->str);
}
record_sheet->set_cell (record_sheet,
ii,
column,
tuple->cells[ii]->value->str);
if (sheet->cells[range.row0][ii]->attributes.highlighted == TRUE) {
record_sheet->set_cell_background (record_sheet, ii, column, "#ffffcc");
}
else if (((ii + 1) % 2) == 0) {
record_sheet->set_cell_background (record_sheet, ii, column, "#f9f7f9");
}
}
range.row0++; column++; row++;
} while (range.row0 <= range.rowi);
tuple->destroy (tuple);
}
static void
clipboard_handler(GtkWidget *widget, GdkEventKey *key)
{
GtkSheet *sheet;
sheet = GTK_SHEET(widget);
if(key->state & GDK_CONTROL_MASK || key->keyval==GDK_Control_L ||
key->keyval==GDK_Control_R){
if((key->keyval=='c' || key->keyval == 'C') && sheet->state != GTK_STATE_NORMAL){
if(GTK_SHEET_IN_CLIP(sheet)) gtk_sheet_unclip_range(sheet);
gtk_sheet_clip_range(sheet, sheet->range);
}
if(key->keyval=='x' || key->keyval == 'X')
gtk_sheet_unclip_range(sheet);
}
}
/*! \brief Delete Attribute dialog
*
* This function throws up the "Delete foo, are you sure?" dialog
* box. It offers two buttons: "yes" and "cancel".
*/
void x_dialog_delattrib()
{
GtkWidget *dialog;
gint mincol, maxcol;
GtkSheet *sheet;
gint cur_page;
/* First verify that exactly one column is selected. */
cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
sheet = GTK_SHEET(sheets[cur_page]);
if (sheet == NULL) {
return;
}
mincol = x_gtksheet_get_min_col(sheet);
maxcol = x_gtksheet_get_max_col(sheet);
if ( (mincol != maxcol) || (mincol == -1) || (maxcol == -1) ) {
/* Improper selection -- maybe throw up error box? */
return;
}
/* Create the dialog */
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
_("Are you sure you want to delete this attribute?"));
gtk_window_set_title(GTK_WINDOW(dialog), _("Delete attribute"));
switch(gtk_dialog_run(GTK_DIALOG(dialog))) {
case GTK_RESPONSE_YES:
/* call the fcn to actually delete the attrib column. */
s_toplevel_delete_attrib_col(); /* this fcn figures out
* which col to delete. */
break;
default:
break;
}
gtk_widget_destroy(dialog);
}
void
glade_gtk_sheet_replace_child(
GladeWidgetAdaptor *adaptor,
GObject *object,
GObject *old_obj,
GObject *new_obj)
{
gint col;
GtkSheet *sheet;
GtkSheetColumn *oldcol, *newcol;
#ifdef GTK_SHEET_DEBUG
g_debug("glade_gtk_sheet_replace_child: called %p -> %p", old_obj, new_obj);
#endif
g_return_if_fail (GTK_IS_SHEET (object));
g_return_if_fail (GTK_IS_WIDGET (old_obj));
if (GLADE_IS_PLACEHOLDER (new_obj))
{
glade_gtk_sheet_remove_child (adaptor, object, old_obj);
return;
}
g_return_if_fail (GTK_IS_WIDGET (new_obj));
sheet = GTK_SHEET(object);
oldcol = GTK_SHEET_COLUMN(old_obj);
newcol = GTK_SHEET_COLUMN(new_obj);
for (col=0; col<=sheet->maxcol; col++)
{
if (oldcol == sheet->column[col])
{
g_object_unref(sheet->column[col]);
sheet->column[col] = newcol;
return;
}
}
g_warning("glade_gtk_sheet_replace_child: couldn't replace child %p by %p", old_obj, new_obj);
}
/* when we have new data in the entry above the sheet, we
copy the data to the cells/registers
this don't get called when it is clicked
in, only when we hit return
*/
static void
activate_sheet_entry(GtkWidget *widget, Register_Window *rw)
{
GtkSheet *sheet;
// GtkEntry *sheet_entry;
gint row, col;
// gint justification=GTK_JUSTIFY_RIGHT;
if(widget==NULL|| rw==NULL)
{
printf("Warning activate_sheet_entry(%x,%x)\n",(unsigned int)widget,(unsigned int)rw);
return;
}
sheet=GTK_SHEET(rw->register_sheet);
row=sheet->active_cell.row; col=sheet->active_cell.col;
parse_numbers(GTK_WIDGET(sheet),sheet->active_cell.row,sheet->active_cell.col,rw);
update_ascii(rw,row);
}
void
glade_gtk_sheet_add_child(GladeWidgetAdaptor *adaptor, GObject *object, GObject *child)
{
GtkSheet *sheet;
GtkSheetColumn *newcol;
GladeWidget *child_widget = glade_widget_get_from_gobject (child);
const gchar *name = glade_widget_get_name(child_widget);
g_return_if_fail (GTK_IS_SHEET (object));
g_return_if_fail (GTK_IS_WIDGET (child));
#ifdef GTK_SHEET_DEBUG
g_debug("glade_gtk_sheet_add_child: %s %d",
name ? name : "NULL",
GLADE_IS_WIDGET(child)
);
#endif
sheet = GTK_SHEET(object);
newcol = GTK_SHEET_COLUMN(child);
gtk_sheet_buildable_add_child_internal(sheet, newcol, name);
}
/*! \brief Add all items to the top level window
*
* This function updates the top level window
* after a new page is read in.
*
* It does the following:
*
* -# Create a new gtksheet having the current dimensions.
* -# Call x_gktsheet_add_row_labels(comp_count, master_*_list_head)
* -# Call x_gktsheet_add_col_labels(comp_attrib_count, master_*_attrib_list_head)
* -# Call x_gktsheet_add_row_labels(net_count, master_*_list_head)
* -# Call x_gktsheet_add_col_labels(net_attrib_count, master_*_attrib_list_head)
* -# loop on i, j -- call x_gtksheet_add_entry(i, j, attrib_value)
* -# Call gtk_widget_show(window) to show new window.
*/
void
x_window_add_items()
{
gint i, j;
gint num_rows, num_cols;
gchar *text, *error_string;
gint visibility, show_name_value;
/* Do these sanity check to prevent later segfaults */
if (sheet_head->comp_count == 0) {
error_string = _("No components found in entire design!\nDo you have refdeses on your components?");
x_dialog_fatal_error(error_string, 1);
}
if (sheet_head->comp_attrib_count == 0) {
error_string = _("No configurable component attributes found in entire design!\nPlease attach at least some attributes before running gattrib.");
x_dialog_fatal_error(error_string, 2);
}
if (sheet_head->pin_count == 0) {
error_string = _("No pins found on any components!\nPlease check your design.");
x_dialog_fatal_error(error_string, 3);
}
/* initialize the gtksheet. */
x_gtksheet_init(); /* this creates a new gtksheet having dimensions specified
* in sheet_head->comp_count, etc. . . */
if (sheet_head->comp_count > 0 ) {
x_gtksheet_add_row_labels(GTK_SHEET(sheets[0]),
sheet_head->comp_count, sheet_head->master_comp_list_head);
x_gtksheet_add_col_labels(GTK_SHEET(sheets[0]),
sheet_head->comp_attrib_count, sheet_head->master_comp_attrib_list_head);
}
#ifdef UNIMPLEMENTED_FEATURES
/* This is not ready. I need to implement net attributes */
if (sheet_head->net_count > 0 ) {
x_gtksheet_add_row_labels(GTK_SHEET(sheets[1]),
sheet_head->net_count, sheet_head->master_net_list_head);
x_gtksheet_add_col_labels(GTK_SHEET(sheets[1]),
sheet_head->net_attrib_count, sheet_head->master_net_attrib_list_head);
} else {
x_gtksheet_add_row_labels(GTK_SHEET(sheets[1]), 1, NULL);
x_gtksheet_add_col_labels(GTK_SHEET(sheets[1]), 1, NULL);
}
#endif
#ifdef UNIMPLEMENTED_FEATURES
if (sheet_head->pin_count > 0 ) {
x_gtksheet_add_row_labels(GTK_SHEET(sheets[2]),
sheet_head->pin_count, sheet_head->master_pin_list_head);
x_gtksheet_add_col_labels(GTK_SHEET(sheets[2]),
sheet_head->pin_attrib_count, sheet_head->master_pin_attrib_list_head);
}
#endif
/* ------ Comp sheet: put values in the individual cells ------- */
num_rows = sheet_head->comp_count;
num_cols = sheet_head->comp_attrib_count;
for (i = 0; i < num_rows; i++) {
for (j = 0; j < num_cols; j++) {
if ( (sheet_head->component_table)[i][j].attrib_value ) { /* NULL = no entry */
text = (gchar *) g_strdup( (sheet_head->component_table)[i][j].attrib_value );
visibility = (sheet_head->component_table)[i][j].visibility;
show_name_value = (sheet_head->component_table)[i][j].show_name_value;
x_gtksheet_add_cell_item( GTK_SHEET(sheets[0]), i, j, (gchar *) text,
visibility, show_name_value );
g_free(text);
}
}
}
#ifdef UNIMPLEMENTED_FEATURES
/* ------ Net sheet: put values in the individual cells ------- */
num_rows = sheet_head->net_count;
num_cols = sheet_head->net_attrib_count;
for (i = 0; i < num_rows; i++) {
for (j = 0; j < num_cols; j++) {
if ( (sheet_head->net_table)[i][j].attrib_value ) { /* NULL = no entry */
text = (gchar *) g_strdup( (sheet_head->net_table)[i][j].attrib_value );
visibility = (sheet_head->net_table)[i][j].visibility;
show_name_value = (sheet_head->component_table)[i][j].show_name_value;
x_gtksheet_add_cell_item( GTK_SHEET(sheets[1]), i, j, (gchar *) text,
visibility, show_name_value );
g_free(text);
}
}
}
#endif
#ifdef UNIMPLEMENTED_FEATURES
/* ------ Pin sheet: put pin attribs in the individual cells ------- */
num_rows = sheet_head->pin_count;
num_cols = sheet_head->pin_attrib_count;
for (i = 0; i < num_rows; i++) {
for (j = 0; j < num_cols; j++) {
if ( (sheet_head->pin_table)[i][j].attrib_value ) { /* NULL = no entry */
text = (gchar *) g_strdup( (sheet_head->pin_table)[i][j].attrib_value );
/* pins have no visibility attributes, must therefore provide default. */
x_gtksheet_add_cell_item( GTK_SHEET(sheets[2]), i, j, (gchar *) text,
VISIBLE, SHOW_VALUE );
g_free(text);
}
}
}
#endif
gtk_widget_show_all( GTK_WIDGET(window) );
}
/*! \brief Extract attributes from gtksheet into TABLE
*
* This function does the actual heavy lifting of looping
* through the spreadsheet, extracting the attribs from
* the cells, and placing them back into TABLE. This is the
* first step in saving out a project.
*
* \param local_gtk_sheet GtkSheet to save
* \param master_row_list STRING_LIST of rows
* \param master_col_list STRING_LIST of columns
* \param local_table TABLE structure to fill
* \param num_rows Number of rows in table
* \param num_cols Number of columns in table
*/
void s_table_gtksheet_to_table(GtkSheet *local_gtk_sheet, STRING_LIST *master_row_list,
STRING_LIST *master_col_list, TABLE **local_table,
int num_rows, int num_cols)
{
int row, col;
STRING_LIST *row_list_item;
gchar *row_title;
STRING_LIST *col_list_item;
gchar *col_title;
gchar *attrib_value;
#ifdef DEBUG
printf("********** Entering s_table_gtksheet_to_table ******************\n");
#endif
row_list_item = master_row_list;
for (row = 0; row < num_rows; row++) {
row_title = (gchar *) g_strdup(row_list_item->data);
col_list_item = master_col_list;
for (col = 0; col < num_cols; col++) {
col_title = (gchar *) g_strdup(col_list_item->data);
/* get value of attrib in cell */
attrib_value = (gchar *) gtk_sheet_cell_get_text(GTK_SHEET(local_gtk_sheet), row, col);
#if 0
if (strlen(attrib_value) == 0) {
/* g_free(attrib_value); */ /* sometimes we have spurious, zero length strings creep */
attrib_value = NULL; /* into the GtkSheet */
}
#endif
#ifdef DEBUG
printf("In s_table_gtksheet_to_table, found attrib_value = %s in cell row=%d, col=%d\n",
attrib_value, row, col);
#endif
/* first handle attrib value in cell */
#ifdef DEBUG
printf(" Updating attrib_value %s\n", attrib_value);
#endif
g_free( local_table[row][col].attrib_value );
if (attrib_value != NULL) {
local_table[row][col].attrib_value = (gchar *) g_strdup(attrib_value);
} else {
local_table[row][col].attrib_value = NULL;
}
/* next handle name of row (also held in TABLE cell) */
#ifdef DEBUG
printf(" Updating row_name %s\n", row_title);
#endif
g_free( local_table[row][col].row_name );
if (row_title != NULL) {
local_table[row][col].row_name = (gchar *) g_strdup(row_title);
} else {
local_table[row][col].row_name = NULL;
}
/* finally handle name of col */
#ifdef DEBUG
printf(" Updating col_name %s\n", col_title);
#endif
g_free( local_table[row][col].col_name );
if (col_title != NULL) {
local_table[row][col].col_name = (gchar *) g_strdup(col_title);
} else {
local_table[row][col].col_name = NULL;
}
/* get next col list item and then iterate. */
col_list_item = col_list_item->next;
}
row_list_item = row_list_item->next;
}
return;
}
/*! \brief Add a new attribute to the top level
*
* This function gets called when the user has entered a new attrib name,
* and clicked the OK button. It does this:
* -# It figures out which attrib/sheet is being added to
* -# It destroys the old table in preparation for the new attrib.
* -# It adds the new attrib to the master lists.
* -# It creates a new table with the new attrib.
* -# It then adds the appropriate col to the gtksheet.
* \param new_attrib_name attribute to be added
*/
void s_toplevel_add_new_attrib(gchar *new_attrib_name) {
gint cur_page; /* current page in notbook */
gint old_comp_attrib_count;
if (strcmp(new_attrib_name, "_cancel") == 0) {
return; /* user pressed cancel or closed window with no value in entry */
}
/* Next must figure out which sheet the attrib belongs to. */
cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
#ifdef DEBUG
printf("In s_toplevel_add_new_attrib, adding new attrib to page %d.\n",
cur_page);
#endif
switch (cur_page) {
case 0: /* component attribute */
/* Eventually, I want to just resize the table to accomodate the
* new attrib. However, that is difficult. Therefore, I will just
* destroy the old table and recreate it for now. */
/*
s_table_destroy(sheet_head->component_table,
sheet_head->comp_count, sheet_head->comp_attrib_count);
*/
old_comp_attrib_count = sheet_head->comp_attrib_count;
#ifdef DEBUG
printf("In s_toplevel_add_new_attrib, before adding new comp attrib.\n");
printf(" comp_attrib_count = %d\n", old_comp_attrib_count);
#endif
s_string_list_add_item(sheet_head->master_comp_attrib_list_head,
&(sheet_head->comp_attrib_count),
new_attrib_name);
s_string_list_sort_master_comp_attrib_list();
#ifdef DEBUG
printf("In s_toplevel_add_new_attrib, just updated comp_attrib string list.\n");
printf(" new comp_attrib_count = %d\n", sheet_head->comp_attrib_count);
#endif
/* Now create new table */
/* sheet_head->component_table = s_table_new(sheet_head->comp_count,
sheet_head->comp_attrib_count);
*/
/* resize table to accomodate new attrib col */
sheet_head->component_table =
s_table_resize(sheet_head->component_table,
sheet_head->comp_count,
old_comp_attrib_count, sheet_head->comp_attrib_count);
#ifdef DEBUG
printf("In s_toplevel_add_new_attrib, just resized component table.\n");
#endif
/* Fill out new sheet with new stuff from gtksheet */
gtk_sheet_insert_columns(GTK_SHEET(sheets[0]), sheet_head->comp_attrib_count, 1);
x_gtksheet_add_col_labels(GTK_SHEET(sheets[0]),
sheet_head->comp_attrib_count,
sheet_head->master_comp_attrib_list_head);
#ifdef DEBUG
printf("In s_toplevel_add_new_attrib, just updated gtksheet.\n");
#endif
break;
case 1: /* net attribute */
/* insert into net attribute list */
break;
case 2: /* pin attribute */
/* insert into pin attribute list */
break;
} /* switch */
return;
}
void RegWindow_new_processor(Register_Window *rw, GUI_Processor *gp)
{
#define NAME_SIZE 32
gint i,j,reg_number, border_mask, border_width;
GtkSheet *sheet;
struct cross_reference_to_gui *cross_reference;
gboolean row_created;
GtkSheetRange range;
int pic_id;
if(rw == NULL || gp == NULL)
return;
rw->processor=1;
if( !((GUI_Object*)rw)->enabled)
return;
rw->gui_obj.gp = gp;
pic_id = gp->pic_id;
for(i=0;i<MAX_REGISTERS;i++)
{
if(rw->registers[i]!=NULL)
free(rw->registers[i]);
rw->registers[i]=NULL;
}
sheet=GTK_SHEET(rw->register_sheet);
row_created=FALSE;
for(j=0;j<MAX_REGISTERS/REGISTERS_PER_ROW;j++)
rw->row_to_address[j]=-1;
// gtk_widget_hide(GTK_WIDGET(sheet));
gtk_sheet_freeze(sheet);
j=0;
for(reg_number=0;reg_number<gpsim_get_register_memory_size(pic_id, rw->type);reg_number++)
{
i=reg_number%REGISTERS_PER_ROW;
if(i==0 && row_created)
{
j++;
row_created=FALSE;
}
rw->registers[reg_number] = (Register *)malloc(sizeof(Register));
rw->registers[reg_number]->row = j;
rw->registers[reg_number]->col = i;
rw->registers[reg_number]->value = -1;
rw->registers[reg_number]->update_full=TRUE;
if(gpsim_get_register_name (pic_id, rw->type,reg_number))
{
rw->registers[reg_number]->value = gpsim_get_register_value(pic_id, rw->type,reg_number);
/* Now create a cross-reference link that the simulator can use to
* send information back to the gui
*/
cross_reference = (struct cross_reference_to_gui *) malloc(sizeof(struct cross_reference_to_gui));
cross_reference->parent_window_type = WT_register_window;
cross_reference->parent_window = (gpointer) rw;
cross_reference->data = (gpointer) rw->registers[reg_number];
cross_reference->update = xref_update_cell;
cross_reference->remove = xref_remove_cell;
gpsim_assign_register_xref(pic_id, rw->type, reg_number, (gpointer) cross_reference);
if(!row_created)
{
char row_label[100];
if(sheet->maxrow<j)
{
gtk_sheet_add_row(sheet,1);
}
sprintf(row_label,"%x0",reg_number/REGISTERS_PER_ROW);
gtk_sheet_row_button_add_label(sheet, j, row_label);
gtk_sheet_set_row_title(sheet, j, row_label);
rw->row_to_address[j] = reg_number - reg_number%REGISTERS_PER_ROW;
row_created=TRUE;
}
}
}
if(j < sheet->maxrow)
{
// printf(">>>>>>>%d %d %d\n",j,sheet->maxrow,sheet->maxrow+1-j);
gtk_sheet_delete_rows(sheet,j,sheet->maxrow-j);
}
rw->registers_loaded = 1;
range.row0=0;
range.rowi=sheet->maxrow;
range.col0=0;
range.coli=sheet->maxcol;
gtk_sheet_range_set_font(sheet, range, normal_style->font);
border_mask = GTK_SHEET_RIGHT_BORDER |
GTK_SHEET_LEFT_BORDER |
GTK_SHEET_BOTTOM_BORDER |
GTK_SHEET_TOP_BORDER;
border_width = 1;
gtk_sheet_range_set_border(sheet, range, border_mask, border_width, 0);
border_mask = GTK_SHEET_LEFT_BORDER;
border_width = 3;
range.col0=REGISTERS_PER_ROW;
range.coli=REGISTERS_PER_ROW;
gtk_sheet_range_set_border(sheet, range, border_mask, border_width, 0);
// set values in the sheet
RegWindow_update(rw);
gtk_sheet_thaw(sheet);
// gtk_widget_show(GTK_WIDGET(sheet));
RegWindow_select_register(rw, 0);
if(gpsim_get_register_memory_size(pic_id,rw->type)==0)
{
((GUI_Object*)rw)->change_view((GUI_Object*)rw,VIEW_HIDE);
rw->allow_change_view=0;
}
else if(!GTK_WIDGET_VISIBLE(((GUI_Object*)rw)->window))
{
rw->allow_change_view=1;
((GUI_Object*)rw)->change_view((GUI_Object*)rw,VIEW_SHOW);
}
}
/*! \brief Delete an attribute column
*
* This function gets called when the user has selected a single attrib
* column, selected the edit->delete attrib item from the pull-down
* menu, and then said "yes" to the confirm dialog.
*/
void s_toplevel_delete_attrib_col() {
gint cur_page; /* current page in notbook */
gint mincol, maxcol;
GtkSheet *sheet;
gchar *attrib_name;
/* Repeat previous checks */
cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
sheet = GTK_SHEET(sheets[cur_page]);
if (sheet == NULL) {
return;
}
mincol = x_gtksheet_get_min_col(sheet);
maxcol = x_gtksheet_get_max_col(sheet);
if ( (mincol != maxcol) || (mincol == -1) || (maxcol == -1) ) {
return;
}
#ifdef DEBUG
printf("In s_toplevel_delete_attrib_col, checks were OK, now do real work\n");
#endif
/* Rebuild the gattrib-specific data structures */
switch (cur_page) {
case 0: /* component attribute */
/* Eventually, I want to just resize the table after deleting the
* attrib. However, that is difficult. Therefore, I will just
* destroy the old table and recreate it for now. */
s_table_destroy(sheet_head->component_table,
sheet_head->comp_count, sheet_head->comp_attrib_count);
/* Get name (label) of the col to delete from the gtk sheet */
attrib_name = g_strdup( gtk_sheet_column_button_get_label(sheet, mincol) );
if (attrib_name != NULL) {
#ifdef DEBUG
printf("In s_toplevel_delete_attrib_col, attrib to delete = %s\n", attrib_name);
#endif
} else {
fprintf(stderr, "In s_toplevel_delete_attrib_col, can't get attrib name\n");
return;
}
#ifdef DEBUG
printf("In s_toplevel_delete_attrib_col, before deleting comp attrib.\n");
printf(" comp_attrib_count = %d\n", sheet_head->comp_attrib_count);
#endif
s_string_list_delete_item(&(sheet_head->master_comp_attrib_list_head),
&(sheet_head->comp_attrib_count),
attrib_name);
s_string_list_sort_master_comp_attrib_list(); /* this renumbers list also */
g_free(attrib_name);
#ifdef DEBUG
printf("In s_toplevel_delete_attrib_col, just updated comp_attrib string list.\n");
printf(" new comp_attrib_count = %d\n", sheet_head->comp_attrib_count);
#endif
/* Now create new table with new attrib count*/
sheet_head->component_table = s_table_new(sheet_head->comp_count,
sheet_head->comp_attrib_count);
#ifdef DEBUG
printf("In s_toplevel_delete_attrib_col, just updated SHEET_DATA info.\n");
#endif
break;
case 1: /* net attribute */
/* insert into net attribute list */
break;
case 2: /* pin attribute */
/* insert into pin attribute list */
break;
} /* switch */
/* Delete col on gtksheet */
#ifdef DEBUG
printf("In s_toplevel_delete_attrib_col, about to delete col in gtksheet.\n");
#endif
gtk_sheet_delete_columns (sheet, mincol, 1);
#ifdef DEBUG
printf("In s_toplevel_delete_attrib_col, done deleting col in gtksheet.\n");
#endif
sheet_head->CHANGED = TRUE; /* Set changed flag so user is prompted when exiting */
return;
}
static gboolean update_register_cell(Register_Window *rw, unsigned int reg_number)
{
gchar name[16];
gint new_value;
unsigned int pic_id;
GtkSheetRange range;
gboolean retval=FALSE;
GUI_Processor *gp;
if(rw == NULL || reg_number<0 || reg_number>MAX_REGISTERS)
{
printf("Warning update_register_cell(%x,%x)\n",(unsigned int)rw,reg_number);
return 0;
}
pic_id = rw->gui_obj.gp->pic_id;
if((reg_number >= MAX_REGISTERS) || (reg_number >= gpsim_get_register_memory_size(pic_id,rw->type)))
return 0;
gp=((GUI_Object*)rw)->gp;
range.row0=rw->registers[reg_number]->row;
range.rowi=rw->registers[reg_number]->row;
range.col0=rw->registers[reg_number]->col;
range.coli=rw->registers[reg_number]->col;
if(rw->registers[reg_number]->update_full)
{
rw->registers[reg_number]->update_full=FALSE;
if(gpsim_get_register_name(pic_id, rw->type,reg_number))
{
new_value=gpsim_get_register_value(pic_id, rw->type,reg_number);
if(new_value==INVALID_VALUE)
sprintf (name, "??");
else
sprintf (name, "%02x", new_value);
}
else
{
new_value=-1; // magic value
sprintf(name, "----");
}
if(rw->registers[reg_number]->row<=rw->register_sheet->maxrow)
{
gtk_sheet_set_cell(GTK_SHEET(rw->register_sheet),
rw->registers[reg_number]->row,
rw->registers[reg_number]->col,
GTK_JUSTIFY_RIGHT,name);
}
// else the register is invalid and out of the register sheet
if(new_value != rw->registers[reg_number]->value)
{
rw->registers[reg_number]->value = new_value;
rw->registers[reg_number]->update_full=TRUE;
gtk_sheet_range_set_foreground(GTK_SHEET(rw->register_sheet), range, &item_has_changed_color);
}
else
gtk_sheet_range_set_foreground(GTK_SHEET(rw->register_sheet), range, &normal_fg_color);
if(gpsim_reg_has_breakpoint(pic_id, rw->type, reg_number))
gtk_sheet_range_set_background(GTK_SHEET(rw->register_sheet), range, &breakpoint_color);
else if(gpsim_get_register_name(((GUI_Object*)rw)->gp->pic_id, rw->type, reg_number)==NULL)
gtk_sheet_range_set_background(GTK_SHEET(rw->register_sheet), range, &invalid_color);
else if(gpsim_register_is_alias(((GUI_Object*)rw)->gp->pic_id, rw->type, reg_number))
gtk_sheet_range_set_background(GTK_SHEET(rw->register_sheet), range, &alias_color);
else
{
if(gpsim_register_is_sfr(pic_id, rw->type, reg_number))
gtk_sheet_range_set_background(GTK_SHEET(rw->register_sheet), range, &sfr_bg_color);
else
gtk_sheet_range_set_background(GTK_SHEET(rw->register_sheet), range, &normal_bg_color);
}
retval=TRUE;
}
else if((new_value=gpsim_get_register_value(pic_id, rw->type,reg_number)) != rw->registers[reg_number]->value) {
if(new_value==INVALID_VALUE)
{
rw->registers[reg_number]->value = -1;
sprintf (name, "??");
}
else
{
// the register is changed since last update
rw->registers[reg_number]->value = new_value;
sprintf (name, "%02x", new_value);
}
gtk_sheet_set_cell(GTK_SHEET(rw->register_sheet),
rw->registers[reg_number]->row,
rw->registers[reg_number]->col,
GTK_JUSTIFY_RIGHT,name);
rw->registers[reg_number]->update_full=TRUE;
gtk_sheet_range_set_foreground(GTK_SHEET(rw->register_sheet), range, &item_has_changed_color);
retval=TRUE;
}
return retval;
}
void
BuildRegisterWindow(Register_Window *rw)
{
GtkWidget *window;
GtkWidget *register_sheet;
GtkWidget *main_vbox;
GtkWidget *scrolled_window;
#define MAXROWS (MAX_REGISTERS/REGISTERS_PER_ROW)
#define MAXCOLS (REGISTERS_PER_ROW+1)
GtkSheet *sheet;
gchar name[10];
gint i;
gint column_width,char_width;
int x,y,width,height;
if(rw==NULL)
{
printf("Warning build_register_viewer(%x)\n",(unsigned int)rw);
return;
}
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
((GUI_Object*)rw)->window=window;
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window);
//GTK_SIGNAL_FUNC (quit), NULL);
main_vbox=gtk_vbox_new(FALSE,1);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox),0);
gtk_container_add(GTK_CONTAINER(window), main_vbox);
gtk_widget_show(main_vbox);
if(rw->type==REGISTER_RAM)
{
register_sheet=gtk_sheet_new(1,MAXCOLS,"gpsim Register Viewer [RAM]");
gtk_window_set_title(GTK_WINDOW(window), "register viewer [RAM]");
// Add a status bar
StatusBar_create(main_vbox,gp->status_bar);
}
else
{
register_sheet=gtk_sheet_new(1,MAXCOLS,"gpsim Register Viewer [EEPROM]");
gtk_window_set_title(GTK_WINDOW(window), "register viewer [EEPROM]");
}
GTK_WIDGET_UNSET_FLAGS(register_sheet,GTK_CAN_DEFAULT);
rw->register_sheet = GTK_SHEET(register_sheet);
/* create popupmenu */
rw->popup_menu=build_menu(sheet,rw);
build_entry_bar(main_vbox, rw);
width=((GUI_Object*)rw)->width;
height=((GUI_Object*)rw)->height;
x=((GUI_Object*)rw)->x;
y=((GUI_Object*)rw)->y;
gtk_window_set_default_size(GTK_WINDOW(rw->gui_obj.window), width,height);
gtk_widget_set_uposition(GTK_WIDGET(rw->gui_obj.window),x,y);
gtk_signal_connect(GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC(delete_event), rw);
scrolled_window=gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrolled_window), register_sheet);
GTK_SHEET_SET_FLAGS(register_sheet, GTK_SHEET_CLIP_TEXT);
gtk_widget_show(register_sheet);
gtk_widget_show(scrolled_window);
gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(gtk_sheet_get_entry(GTK_SHEET(register_sheet))),
"changed", (GtkSignalFunc)show_entry, rw);
gtk_signal_connect(GTK_OBJECT(register_sheet),
"activate", (GtkSignalFunc)activate_sheet_cell,
(gpointer) rw);
gtk_signal_connect(GTK_OBJECT(rw->entry),
"changed", (GtkSignalFunc)show_sheet_entry, rw);
gtk_signal_connect(GTK_OBJECT(rw->entry),
"activate", (GtkSignalFunc)activate_sheet_entry,
rw);
// gtk_widget_realize(window);
char_width = gdk_string_width (normal_style->font,"9");
column_width = 3 * char_width + 6;
sheet=rw->register_sheet;
for(i=0; i<sheet->maxcol; i++){
//sprintf(name,"0x%02x",i);
sprintf(name,"%02x",i);
gtk_sheet_column_button_add_label(sheet, i, name);
gtk_sheet_set_column_title(sheet, i, name);
gtk_sheet_set_column_width (sheet, i, column_width);
}
sprintf(name,"ASCII");
gtk_sheet_column_button_add_label(sheet, i, name);
gtk_sheet_set_column_title(sheet, i, name);
gtk_sheet_set_column_width (sheet, i, REGISTERS_PER_ROW*char_width + 6);
gtk_sheet_set_row_titles_width(sheet, column_width);
gtk_signal_connect(GTK_OBJECT(sheet),
"key_press_event",
(GtkSignalFunc) clipboard_handler,
NULL);
gtk_signal_connect(GTK_OBJECT(sheet),
"resize_range",
(GtkSignalFunc) resize_handler,
rw);
gtk_signal_connect(GTK_OBJECT(sheet),
"move_range",
(GtkSignalFunc) move_handler,
rw);
gtk_signal_connect(GTK_OBJECT(sheet),
"button_press_event",
(GtkSignalFunc) do_popup,
rw);
gtk_signal_connect(GTK_OBJECT(sheet),
"set_cell",
(GtkSignalFunc) parse_numbers,
rw);
// rw->gui_obj.window = window;
gtk_signal_connect_after(GTK_OBJECT(rw->gui_obj.window), "configure_event",
GTK_SIGNAL_FUNC(gui_object_configure_event),rw);
gtk_widget_show (window);
gtk_widget_grab_default(rw->location);
rw->gui_obj.enabled=1;
for(i=0;i<MAX_REGISTERS;i++)
rw->registers[i]=NULL;
if(rw->processor)
{
RegWindow_new_processor(rw, ((GUI_Object*)rw)->gp);
}
}
/*
static void
do_quit_app(GtkWidget *widget)
{
exit_gpsim();
}
*/
void RegWindow_select_register(Register_Window *rw, int regnumber)
{
GtkSheet *sheet;
GtkEntry *sheet_entry;
char cell[100],*n;
char *text;
GtkSheetCellAttr attributes;
GtkSheetRange range;
int row, col;
if(rw == NULL || regnumber > MAX_REGISTERS || regnumber<0)
{
printf("Warning RegWindow_select_register(%x,%x)\n",(unsigned int)rw,regnumber);
return;
}
if(rw->registers[regnumber] == NULL)
return;
row=rw->registers[regnumber]->row;
col=rw->registers[regnumber]->col;
range.row0=range.rowi=row;
range.col0=range.coli=col;
gtk_sheet_select_range(GTK_SHEET(rw->register_sheet),&range);
if(GTK_SHEET(rw->register_sheet)->view.col0>range.col0 ||
GTK_SHEET(rw->register_sheet)->view.coli<range.coli ||
GTK_SHEET(rw->register_sheet)->view.row0>range.row0 ||
GTK_SHEET(rw->register_sheet)->view.rowi<range.rowi)
gtk_sheet_moveto(GTK_SHEET(rw->register_sheet),row,col,0.5,0.5);
sheet=rw->register_sheet;
sheet_entry = GTK_ENTRY(gtk_sheet_get_entry(sheet));
cell[0] = 0;
if(((GUI_Object*)rw)->gp)
{
n = gpsim_get_register_name(((GUI_Object*)rw)->gp->pic_id, rw->type, regnumber);
if(n==NULL)
puts("Warning n==NULL in RegWindow_select_register");
else
strncpy(cell,n,100);
}
gtk_label_set(GTK_LABEL(rw->location), cell);
gtk_entry_set_max_length(GTK_ENTRY(rw->entry),
GTK_ENTRY(sheet_entry)->text_max_length);
if((text=gtk_entry_get_text(GTK_ENTRY(gtk_sheet_get_entry(sheet)))))
gtk_entry_set_text(GTK_ENTRY(rw->entry), text);
else
gtk_entry_set_text(GTK_ENTRY(rw->entry), "");
gtk_sheet_get_attributes(sheet,sheet->active_cell.row,
sheet->active_cell.col, &attributes);
gtk_entry_set_editable(GTK_ENTRY(rw->entry), attributes.is_editable);
gtk_sheet_range_set_justification(sheet, sheet->range, GTK_JUSTIFY_RIGHT);
}
// called when user has selected a menu item
static void
popup_activated(GtkWidget *widget, gpointer data)
{
GtkSheet *sheet;
menu_item *item;
int i,j;
unsigned int pic_id;
GtkSheetRange range;
unsigned int address;
int value;
if(widget==NULL || data==NULL)
{
printf("Warning popup_activated(%x,%x)\n",(unsigned int)widget,(unsigned int)data);
return;
}
item = (menu_item *)data;
sheet=GTK_SHEET(popup_rw->register_sheet);
range = sheet->range;
pic_id = ((GUI_Object*)popup_rw)->gp->pic_id;
switch(item->id)
{
case MENU_BREAK_READ:
for(j=range.row0;j<=range.rowi;j++)
for(i=range.col0;i<=range.coli;i++)
{
address=popup_rw->row_to_address[j]+i;
gpsim_reg_set_read_breakpoint(pic_id, popup_rw->type, address);
}
break;
case MENU_BREAK_WRITE:
for(j=range.row0;j<=range.rowi;j++)
for(i=range.col0;i<=range.coli;i++)
{
address=popup_rw->row_to_address[j]+i;
gpsim_reg_set_write_breakpoint(pic_id, popup_rw->type, address);
}
break;
case MENU_BREAK_READ_VALUE:
value = gui_get_value("value to read for breakpoint:");
if(value<0)
break; // Cancel
for(j=range.row0;j<=range.rowi;j++)
for(i=range.col0;i<=range.coli;i++)
{
address=popup_rw->row_to_address[j]+i;
gpsim_reg_set_read_value_breakpoint(pic_id, popup_rw->type, address, value);
}
break;
case MENU_BREAK_WRITE_VALUE:
value = gui_get_value("value to write for breakpoint:");
if(value<0)
break; // Cancel
for(j=range.row0;j<=range.rowi;j++)
for(i=range.col0;i<=range.coli;i++)
{
address=popup_rw->row_to_address[j]+i;
gpsim_reg_set_write_value_breakpoint(pic_id, popup_rw->type, address, value);
}
break;
case MENU_BREAK_CLEAR:
for(j=range.row0;j<=range.rowi;j++)
for(i=range.col0;i<=range.coli;i++)
{
address=popup_rw->row_to_address[j]+i;
gpsim_reg_clear_breakpoints(pic_id, popup_rw->type,address);
}
break;
case MENU_ADD_WATCH:
for(j=range.row0;j<=range.rowi;j++)
for(i=range.col0;i<=range.coli;i++)
{
address=popup_rw->row_to_address[j]+i;
WatchWindow_add(popup_rw->gui_obj.gp->watch_window,pic_id, popup_rw->type, address);
}
break;
default:
puts("Unhandled menuitem?");
break;
}
}
// when a new cell is selected, we write changes in
// previously selected cell to gpsim
static void
parse_numbers(GtkWidget *widget, int row, int col, Register_Window *rw)
{
GtkSheet *sheet;
gchar *text;
int justification,n=0;
GUI_Processor *gp;
sheet=GTK_SHEET(widget);
if(widget==NULL ||
row>sheet->maxrow || row<0 ||
col>sheet->maxcol || col<0 || rw==NULL)
{
printf("Warning parse_numbers(%x,%x,%x,%x)\n",(unsigned int)widget,row,col,(unsigned int)rw);
return;
}
gp = ((GUI_Object*)rw)->gp;
//printf ("parse_numbers %d %d\n", row, col);
justification=GTK_JUSTIFY_RIGHT;
if(col < REGISTERS_PER_ROW)
{
int reg = rw->row_to_address[row] + col;
if( rw->row_to_address[row] == -1)
{
puts("Warning row_to_address[row] == -1 in parse_numbers");
return;
}
text = gtk_entry_get_text(GTK_ENTRY(sheet->sheet_entry));
errno = 0;
if(text!=NULL && strlen(text)>0)
n = get_number_in_string(text);
else
errno = ERANGE;
if(errno != 0)
{
n = gpsim_get_register_value(gp->pic_id, rw->type, reg);
rw->registers[reg]->value = -1;
}
if(gpsim_get_register_name(gp->pic_id,rw->type, reg))
{
if(n != rw->registers[reg]->value)
{
//puts("Writing new value");
gpsim_put_register_value(gp->pic_id, rw->type, reg, n&0xff);
update_ascii(rw,row);
}
}
}
else
; // ignore user changes in ascii column for right now
}
