gboolean alter_w_range_data(GtkWidget *widget, gpointer data)
{
gint index = (GINT)OBJ_GET((widget),"index");
gfloat value = 0.0;
GdkColor color;
WrField field = (WrField)(GINT)data;
if (!GTK_IS_WIDGET(gauge))
return FALSE;
switch (field)
{
case WR_LOWPOINT:
case WR_HIGHPOINT:
case WR_INSET:
case WR_LWIDTH:
value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
mtx_gauge_face_alter_warning_range(MTX_GAUGE_FACE(gauge),index,field,(void *)&value);
break;
case WR_COLOR_DAY:
case WR_COLOR_NITE:
gtk_color_button_get_color(GTK_COLOR_BUTTON(widget),&color);
mtx_gauge_face_alter_warning_range(MTX_GAUGE_FACE(gauge),index,field,(void *)&color);
break;
default:
break;
}
return TRUE;
}
gboolean alter_tgroup_data(GtkWidget *widget, gpointer data)
{
gint index = (GINT)OBJ_GET((widget),"index");
gfloat value = 0.0;
gchar * tmpbuf = NULL;
GdkColor color;
TgField field = (TgField)OBJ_GET(widget,"handler");
if (!GTK_IS_WIDGET(gauge))
return FALSE;
switch (field)
{
case TG_FONT_SCALE:
case TG_LAYER:
case TG_TEXT_INSET:
case TG_MAJ_TICK_INSET:
case TG_MIN_TICK_INSET:
case TG_MAJ_TICK_WIDTH:
case TG_MAJ_TICK_LENGTH:
case TG_MIN_TICK_WIDTH:
case TG_MIN_TICK_LENGTH:
case TG_START_ANGLE:
case TG_SWEEP_ANGLE:
case TG_NUM_MAJ_TICKS:
case TG_NUM_MIN_TICKS:
value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
mtx_gauge_face_alter_tick_group(MTX_GAUGE_FACE(gauge),index,field,(void *)&value);
break;
case TG_MAJ_TICK_COLOR_DAY:
case TG_MAJ_TICK_COLOR_NITE:
case TG_MIN_TICK_COLOR_DAY:
case TG_MIN_TICK_COLOR_NITE:
case TG_TEXT_COLOR_DAY:
case TG_TEXT_COLOR_NITE:
gtk_color_button_get_color(GTK_COLOR_BUTTON(widget),&color);
mtx_gauge_face_alter_tick_group(MTX_GAUGE_FACE(gauge),index,field,(void *)&color);
break;
case TG_FONT:
tmpbuf = g_strdup(gtk_font_button_get_font_name (GTK_FONT_BUTTON(widget)));
tmpbuf = g_strchomp(g_strdelimit(tmpbuf,"0123456789",' '));
mtx_gauge_face_alter_tick_group(MTX_GAUGE_FACE(gauge),index,field,(void *)tmpbuf);
g_free(tmpbuf);
break;
case TG_TEXT:
tmpbuf = g_strdup(gtk_entry_get_text (GTK_ENTRY(widget)));
mtx_gauge_face_alter_tick_group(MTX_GAUGE_FACE(gauge),index,field,(void *)tmpbuf);
g_free(tmpbuf);
default:
break;
}
return TRUE;
}
EXPORT gboolean animate_gauge(GtkWidget *widget, gpointer data)
{
gfloat lower = 0.0;
gfloat upper = 0.0;
if (!GTK_IS_WIDGET(gauge))
return FALSE;
gtk_widget_set_sensitive(widget,FALSE);
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), LBOUND, &lower);
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), UBOUND, &upper);
mtx_gauge_face_set_value(MTX_GAUGE_FACE (gauge),lower);
g_timeout_add(20,(GtkFunction)sweep_gauge, (gpointer)gauge);
return TRUE;
}
EXPORT gboolean create_new_gauge(GtkWidget * widget, gpointer data)
{
GtkWidget *tmp = NULL;
GladeXML *xml = glade_get_widget_tree(widget);
GtkWidget *parent = glade_xml_get_widget(xml,"gauge_frame");
gauge = mtx_gauge_face_new();
gtk_widget_set_events(gauge,GDK_POINTER_MOTION_HINT_MASK
| GDK_POINTER_MOTION_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK);
g_signal_connect(GTK_WIDGET(gauge),"motion_notify_event",G_CALLBACK(gauge_motion),NULL);
g_signal_connect(GTK_WIDGET(gauge),"button_press_event",G_CALLBACK(gauge_button),NULL);
gtk_container_add(GTK_CONTAINER(parent),gauge);
gtk_widget_show_all(parent);
mtx_gauge_face_redraw_canvas(MTX_GAUGE_FACE(gauge));
gauge_loaded = TRUE;
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"tab_notebook"),TRUE);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"animate_frame"),TRUE);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"new_gauge_menuitem"),FALSE);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"close_gauge_menuitem"),TRUE);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"load_gauge_menuitem"),FALSE);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"save_gauge_menuitem"),TRUE);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"save_as_menuitem"),TRUE);
update_attributes();
return (TRUE);
}
G_MODULE_EXPORT gboolean generic_spin_button_handler(GtkWidget *widget, gpointer data)
{
gfloat tmpf = 0.0;
MtxGaugeFace *g = NULL;
gint handler = 0;
tmpf = (gfloat)gtk_spin_button_get_value((GtkSpinButton *)widget);
if (!OBJ_GET((widget),"handler"))
{
printf("control %s has no handler\n",(gchar *)gtk_widget_get_name(widget));
return FALSE;
}
handler = (GINT)OBJ_GET((widget),"handler");
if (GTK_IS_WIDGET(gauge))
g = MTX_GAUGE_FACE(gauge);
else
return FALSE;
if (hold_handlers)
return TRUE;
changed = TRUE;
mtx_gauge_face_set_attribute(g,handler,tmpf);
if ((handler == UBOUND) || (handler == LBOUND))
update_attributes();
return TRUE;
}
EXPORT gboolean create_text_block_event(GtkWidget * widget, gpointer data)
{
GtkWidget *dialog = NULL;
MtxTextBlock *tblock = NULL;
GladeXML *xml = NULL;
gchar * filename = NULL;
gint result = 0;
if (!GTK_IS_WIDGET(gauge))
return FALSE;
filename = get_file(g_build_filename(GAUGEDESIGNER_GLADE_DIR,"gaugedesigner.glade",NULL),NULL);
if (filename)
{
xml = glade_xml_new(filename, "tblock_dialog", NULL);
g_free(filename);
}
else
{
printf("Can't locate primary glade file!!!!\n");
exit(-1);
}
glade_xml_signal_autoconnect(xml);
dialog = glade_xml_get_widget(xml,"tblock_dialog");
gtk_color_button_set_color(GTK_COLOR_BUTTON(glade_xml_get_widget(xml,"tblock_day_colorbutton")),&white);
gtk_color_button_set_color(GTK_COLOR_BUTTON(glade_xml_get_widget(xml,"tblock_nite_colorbutton")),&black);
if (!GTK_IS_WIDGET(dialog))
{
return FALSE;
}
result = gtk_dialog_run(GTK_DIALOG(dialog));
switch (result)
{
case GTK_RESPONSE_APPLY:
tblock = g_new0(MtxTextBlock, 1);
tblock->font_scale = gtk_spin_button_get_value(GTK_SPIN_BUTTON(glade_xml_get_widget(xml,"tblock_font_scale_spin")));
tblock->x_pos = gtk_spin_button_get_value(GTK_SPIN_BUTTON(glade_xml_get_widget(xml,"tblock_xpos_spin")));
tblock->y_pos = gtk_spin_button_get_value(GTK_SPIN_BUTTON(glade_xml_get_widget(xml,"tblock_ypos_spin")));
tblock->text = gtk_editable_get_chars(GTK_EDITABLE(glade_xml_get_widget(xml,"tblock_text_entry")),0,-1);
gtk_color_button_get_color(GTK_COLOR_BUTTON(glade_xml_get_widget(xml,"tblock_day_colorbutton")),&tblock->color[MTX_DAY]);
gtk_color_button_get_color(GTK_COLOR_BUTTON(glade_xml_get_widget(xml,"tblock_nite_colorbutton")),&tblock->color[MTX_NITE]);
tblock->font = (gchar *)gtk_font_button_get_font_name (GTK_FONT_BUTTON(glade_xml_get_widget(xml,"tblock_fontbutton")));
tblock->font = g_strchomp(g_strdelimit(tblock->font,"0123456789",' '));
changed = TRUE;
mtx_gauge_face_set_text_block_struct(MTX_GAUGE_FACE(gauge),tblock);
g_free(tblock->text);
g_free(tblock);
update_onscreen_tblocks();
break;
default:
break;
}
if (GTK_IS_WIDGET(dialog))
gtk_widget_destroy(dialog);
return (FALSE);
}
gboolean sweep_gauge(gpointer data)
{
static gfloat lower = 0.0;
static gfloat upper = 0.0;
gfloat interval = 0.0;
gfloat cur_val = 0.0;
GladeXML *xml = NULL;
GtkWidget *button = NULL;
static gboolean rising = TRUE;
GtkWidget * gauge = NULL;
gauge = (GtkWidget *)data;
if (!GTK_IS_WIDGET(gauge))
return FALSE;
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), LBOUND, &lower);
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), UBOUND, &upper);
interval = (upper-lower)/75.0;
mtx_gauge_face_get_value(MTX_GAUGE_FACE (gauge), &cur_val);
if (cur_val >= upper)
rising = FALSE;
if (cur_val <= lower)
rising = TRUE;
if (rising)
cur_val+=interval;
else
cur_val-=interval;
mtx_gauge_face_set_value (MTX_GAUGE_FACE (gauge),cur_val);
if (cur_val <= lower)
{
/* This cancels the timeout once one full complete sweep
* of the gauge
*/
xml = glade_get_widget_tree(gauge->parent);
button = glade_xml_get_widget(xml,"animate_button");
gtk_widget_set_sensitive(button,TRUE);
mtx_gauge_face_set_value (MTX_GAUGE_FACE (gauge),lower);
return FALSE;
}
else
return TRUE;
}
void load_gauge(GtkWidget *dash, xmlNode *node)
{
xmlNode *cur_node = NULL;
GtkWidget *gauge = NULL;
gchar * filename = NULL;
gint width = 0;
gint height = 0;
gint x_offset = 0;
gint y_offset = 0;
gchar *xml_name = NULL;
gchar *datasource = NULL;
if (!node->children)
{
printf("ERROR, load_gauge, xml node is empty!!\n");
return;
}
cur_node = node->children;
while (cur_node->next) { if (cur_node->type == XML_ELEMENT_NODE)
{
if (g_strcasecmp((gchar *)cur_node->name,"width") == 0)
generic_xml_gint_import(cur_node,&width);
if (g_strcasecmp((gchar *)cur_node->name,"height") == 0)
generic_xml_gint_import(cur_node,&height);
if (g_strcasecmp((gchar *)cur_node->name,"x_offset") == 0)
generic_xml_gint_import(cur_node,&x_offset);
if (g_strcasecmp((gchar *)cur_node->name,"y_offset") == 0)
generic_xml_gint_import(cur_node,&y_offset);
if (g_strcasecmp((gchar *)cur_node->name,"gauge_xml_name") == 0)
generic_xml_gchar_import(cur_node,&xml_name);
if (g_strcasecmp((gchar *)cur_node->name,"datasource") == 0)
generic_xml_gchar_import(cur_node,&datasource);
}
cur_node = cur_node->next;
}
if (xml_name && datasource)
{
gauge = mtx_gauge_face_new();
gtk_fixed_put(GTK_FIXED(dash),gauge,x_offset,y_offset);
xml_name = g_strdelimit(xml_name,"\\",'/');
filename = get_file(g_build_filename(PSEP,GAUGES_DATA_DIR,xml_name,NULL),NULL);
mtx_gauge_face_import_xml(MTX_GAUGE_FACE(gauge),filename);
gtk_widget_set_usize(gauge,width,height);
g_free(filename);
OBJ_SET_FULL((gauge),"datasource",g_strdup(datasource),g_free);
/* Cheat to get property window created... */
create_preview_list(NULL,NULL);
update_properties(gauge,GAUGE_ADD);
g_free(xml_name);
g_free(datasource);
gtk_widget_show_all(dash);
}
}
void update_text_controls()
{
gfloat tmp1 = 0.0;
gfloat tmp2 = 0.0;
gchar *tmpbuf0 = NULL;
gchar *tmpbuf = NULL;
GtkWidget * widget = NULL;
MtxGaugeFace *g = NULL;
GdkColor color;
if (GTK_IS_WIDGET(gauge))
g = MTX_GAUGE_FACE(gauge);
else
return;
if (!toplevel)
return;
hold_handlers = TRUE;
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"precision_spin"));
mtx_gauge_face_get_attribute(g, PRECISION, &tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),(gint)tmp1);
mtx_gauge_face_get_attribute(g, VALUE_FONTSCALE, &tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"value_font_scale_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
mtx_gauge_face_get_attribute(g, VALUE_XPOS, &tmp1);
mtx_gauge_face_get_attribute(g, VALUE_YPOS, &tmp2);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"value_xpos_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"value_ypos_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp2);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"value_font_button"));
tmpbuf0 = mtx_gauge_face_get_value_font(g);
tmpbuf = g_strdup_printf("%s 13",tmpbuf0);
gtk_font_button_set_font_name(GTK_FONT_BUTTON(widget),tmpbuf);
g_free(tmpbuf0);
g_free(tmpbuf);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"show_value_check"));
mtx_gauge_face_get_attribute(g, SHOW_VALUE, &tmp1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),(gint)tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"value_color_day_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_VALUE_FONT_DAY, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"value_color_nite_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_VALUE_FONT_NITE, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
hold_handlers = FALSE;
}
gboolean remove_tblock(GtkWidget * widget, gpointer data)
{
gint index = -1;
if (!GTK_IS_WIDGET(gauge))
return FALSE;
index = (GINT)OBJ_GET((widget),"tblock_index");
mtx_gauge_face_remove_text_block(MTX_GAUGE_FACE(gauge),index);
changed = TRUE;
update_onscreen_tblocks();
return TRUE;
}
G_MODULE_EXPORT gboolean day_nite_handler(GtkWidget *widget, gpointer data)
{
MtxGaugeFace *g = NULL;
gboolean state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if (GTK_IS_WIDGET(gauge))
g = MTX_GAUGE_FACE(gauge);
else
return FALSE;
if (state)
mtx_gauge_face_set_daytime_mode(g,TRUE);
else
mtx_gauge_face_set_daytime_mode(g,FALSE);
return TRUE;
}
void update_onscreen_tblocks()
{
GtkWidget *toptable = NULL;
static GtkWidget *table = NULL;
GtkWidget *subtable = NULL;
GtkWidget *dummy = NULL;
guint i = 0;
gint y = 1;
MtxTextBlock *tblock = NULL;
GtkAdjustment *adj = NULL;
GArray * array = NULL;
extern GladeXML *topxml;
if ((!topxml) || (!gauge))
return;
array = mtx_gauge_face_get_text_blocks(MTX_GAUGE_FACE(gauge));
toptable = glade_xml_get_widget(topxml,"text_blocks_layout_table");
if (!GTK_IS_WIDGET(toptable))
{
printf("toptable is NOT a valid widget!!\n");
return;
}
if (GTK_IS_WIDGET(table))
gtk_widget_destroy(table);
table = gtk_table_new(2,1,FALSE);
gtk_table_attach(GTK_TABLE(toptable),table,0,1,1,2,GTK_EXPAND|GTK_FILL,0,0,0);
OBJ_SET((toptable),"layout_table",table);
/* Repopulate the table with the current tblocks... */
y=1;
for (i=0;i<array->len; i++)
{
tblock = g_array_index(array,MtxTextBlock *, i);
subtable = build_tblock(tblock,i);
gtk_table_attach(GTK_TABLE(table),subtable,0,1,y,y+1,GTK_EXPAND|GTK_FILL,GTK_SHRINK,0,0);
gtk_widget_show_all(subtable);
y+=1;
}
/* Scroll to end */
dummy = glade_xml_get_widget(topxml,"tblock_swin");
adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(dummy));
adj->value = adj->upper;
gtk_widget_show_all(toptable);
}
EXPORT gboolean color_button_color_set(GtkWidget *widget, gpointer data)
{
GdkColor color;
gint handler = (GINT)OBJ_GET((widget),"handler");
if (!GTK_IS_WIDGET(gauge))
return FALSE;
if (hold_handlers)
return TRUE;
gtk_color_button_get_color(GTK_COLOR_BUTTON(widget),&color);
changed = TRUE;
mtx_gauge_face_set_color(MTX_GAUGE_FACE(gauge),handler,color);
return TRUE;
}
void update_onscreen_tgroups()
{
GtkWidget *toptable = NULL;
GtkWidget *subtable = NULL;
GtkWidget *table = NULL;
GtkWidget *dummy = NULL;
guint i = 0;
MtxTickGroup *tgroup = NULL;
const GArray * array = NULL;
GtkAdjustment *adj = NULL;
if ((!toplevel) || (!gauge))
return;
array = mtx_gauge_face_get_tick_groups(MTX_GAUGE_FACE(gauge));
toptable = GTK_WIDGET(gtk_builder_get_object(toplevel,"tick_groups_layout_table"));
if (!GTK_IS_WIDGET(toptable))
{
printf("toptable is NOT a valid widget!!\n");
return;
}
/* Get it and blow it away for re-creation */
table = OBJ_GET((toptable), "layout_table");
if (GTK_IS_WIDGET(table))
gtk_widget_destroy(table);
table = gtk_table_new(2,1,FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table),5);
gtk_table_attach_defaults(GTK_TABLE(toptable),table,0,1,1,2);
OBJ_SET((toptable),"layout_table",table);
/* Repopulate the table with the current tgroups... */
for (i=0;i<array->len; i++)
{
tgroup = g_array_index(array,MtxTickGroup *, i);
subtable = build_tgroup(tgroup,i);
gtk_table_attach(GTK_TABLE(table),subtable,0,1,i,i+1,GTK_EXPAND|GTK_FILL,GTK_SHRINK,0,0);
}
/* Scroll to end */
dummy = GTK_WIDGET(gtk_builder_get_object(toplevel,"tgroup_swin"));
adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(dummy));
gtk_adjustment_set_value(adj, gtk_adjustment_get_upper(adj));
gtk_widget_show_all(toptable);
}
G_MODULE_EXPORT gboolean checkbutton_handler(GtkWidget *widget, gpointer data)
{
gboolean state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
gint handler = (GINT)OBJ_GET((widget),"handler");
MtxGaugeFace *g = NULL;
if (GTK_IS_WIDGET(gauge))
g = MTX_GAUGE_FACE(gauge);
else
return FALSE;
if (hold_handlers)
return TRUE;
changed = TRUE;
mtx_gauge_face_set_attribute(g,handler, state);
return TRUE;
}
EXPORT gboolean change_font(GtkWidget *widget, gpointer data)
{
gchar * tmpbuf = NULL;
MtxGaugeFace *g = NULL;
tmpbuf = (gchar *)gtk_font_button_get_font_name (GTK_FONT_BUTTON(widget));
/* Strip out the font size as the gauge lib uses a different scaling
* method that scales with the size of the gauge
*/
tmpbuf = g_strchomp(g_strdelimit(tmpbuf,"0123456789",' '));
if (GTK_IS_WIDGET(gauge))
g = MTX_GAUGE_FACE(gauge);
else
return FALSE;
if (hold_handlers)
return TRUE;
changed = TRUE;
mtx_gauge_face_set_value_font(g, tmpbuf);
return TRUE;
}
void mtx_gauge_face_import_xml(MtxGaugeFace *gauge, const gchar * filename)
{
xmlDoc *doc = NULL;
xmlNode *root_element = NULL;
gchar *tmpbuf = NULL;
MtxGaugeFacePrivate *priv = NULL;
g_return_if_fail(gauge);
g_return_if_fail(filename);
priv = MTX_GAUGE_FACE_GET_PRIVATE(gauge);
g_return_if_fail(priv);
/*
* this initialize the library and check potential ABI mismatches
* between the version it was compiled for and the actual shared
* library used.
*/
LIBXML_TEST_VERSION
/*parse the file and get the DOM */
doc = xmlReadFile(filename, NULL, 0);
if (doc == NULL) {
printf("error: could not parse file %s\n",filename);
}
else
{
/*Get the root element node */
root_element = xmlDocGetRootElement(doc);
g_object_freeze_notify(G_OBJECT(gauge));
mtx_gauge_face_remove_all_text_blocks(gauge);
mtx_gauge_face_remove_all_alert_ranges(gauge);
mtx_gauge_face_remove_all_warning_ranges(gauge);
mtx_gauge_face_remove_all_tick_groups(gauge);
mtx_gauge_face_remove_all_polygons(gauge);
load_elements(gauge, root_element);
/* Fix for api break, default to CW gauges */
if (priv->rotation == 187)
priv->rotation = MTX_ROT_CCW;
if (priv->rotation == 188)
priv->rotation = MTX_ROT_CW;
priv->xc = priv->w / 2;
priv->yc = priv->h / 2;
priv->radius = MIN (priv->w/2, priv->h/2) - 5;
g_object_thaw_notify(G_OBJECT(gauge));
if ((GTK_IS_WINDOW(gtk_widget_get_parent(GTK_WIDGET(gauge)))) && (priv->w > 0) && (priv->h > 0))
gtk_window_resize(GTK_WINDOW(gtk_widget_get_parent(GTK_WIDGET(gauge))),priv->w,priv->h);
generate_gauge_background(gauge);
mtx_gauge_face_set_value(MTX_GAUGE_FACE(gauge),priv->lbound);
mtx_gauge_face_redraw_canvas (gauge);
priv->xml_filename = g_strdup(filename);
}
g_free(tmpbuf);
/*free the document */
xmlFreeDoc(doc);
/*
*Free the global variables that may
*have been allocated by the parser.
*/
xmlCleanupParser();
}
G_MODULE_EXPORT gboolean create_tick_group_event(GtkWidget * widget, gpointer data)
{
GtkWidget *dialog = NULL;
GtkWidget *dummy = NULL;
MtxTickGroup *tgroup = NULL;
gchar * filename = NULL;
gfloat tmp1 = 0.0;
gfloat tmp2 = 0.0;
gint result = 0;
MtxGaugeFace *g = NULL;
GError *error = NULL;
if (GTK_IS_WIDGET(gauge))
g = MTX_GAUGE_FACE(gauge);
if (!GTK_IS_WIDGET(gauge))
return FALSE;
filename = get_file(g_build_filename(GAUGEDESIGNER_GLADE_DIR,"tgroup.ui",NULL),NULL);
if (filename)
{
tgroups = gtk_builder_new();
if(!gtk_builder_add_from_file(tgroups,filename, &error))
{
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free(error);
exit(-1);
}
g_free(filename);
}
else
{
printf("Can't locate primary ui file!!!!\n");
exit(-1);
}
gtk_builder_connect_signals(tgroups,NULL);
dialog = GTK_WIDGET (gtk_builder_get_object(tgroups,"tgroup_dialog"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_text_day_colorbutton")),&white);
gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_text_nite_colorbutton")),&black);
gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_day_colorbutton")),&white);
gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_nite_colorbutton")),&black);
gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_day_colorbutton")),&white);
gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_nite_colorbutton")),&black);
OBJ_SET((gtk_builder_get_object(tgroups,"tg_start_angle_spin")),"lowpartner",gtk_builder_get_object(tgroups,"tg_lowpoint_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_start_angle_spin")),"highpartner",gtk_builder_get_object(tgroups,"tg_highpoint_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_start_angle_spin")),"high_angle",gtk_builder_get_object(tgroups,"tg_sweep_angle_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_start_angle_spin")),"spin_handler", GINT_TO_POINTER(ADJ_LOW_UNIT_PARTNER));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")),"highpartner",gtk_builder_get_object(tgroups,"tg_highpoint_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")),"low_angle",gtk_builder_get_object(tgroups,"tg_start_angle_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")),"spin_handler", GINT_TO_POINTER(ADJ_HIGH_UNIT_PARTNER));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_lowpoint_spin")),"lowpartner",gtk_builder_get_object(tgroups,"tg_start_angle_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_lowpoint_spin")),"spin_handler", GINT_TO_POINTER(ADJ_START_ANGLE_PARTNER));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_highpoint_spin")),"highpartner",gtk_builder_get_object(tgroups,"tg_sweep_angle_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_highpoint_spin")),"start_angle",gtk_builder_get_object(tgroups,"tg_start_angle_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_highpoint_spin")),"spin_handler", GINT_TO_POINTER(ADJ_SWEEP_ANGLE_PARTNER));
if (MTX_IS_GAUGE_FACE(g))
{
mtx_gauge_face_get_attribute(g,START_ANGLE,&tmp1);
mtx_gauge_face_get_attribute(g,SWEEP_ANGLE,&tmp2);
dummy = GTK_WIDGET(gtk_builder_get_object(tgroups,"tg_start_angle_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),tmp1);
dummy = GTK_WIDGET(gtk_builder_get_object(tgroups,"tg_sweep_angle_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),tmp2);
}
if (!GTK_IS_WIDGET(dialog))
{
return FALSE;
}
result = gtk_dialog_run(GTK_DIALOG(dialog));
switch (result)
{
case GTK_RESPONSE_APPLY:
tgroup = g_new0(MtxTickGroup, 1);
tgroup->font = (gchar *)gtk_font_button_get_font_name (GTK_FONT_BUTTON(gtk_builder_get_object(tgroups,"tg_tick_fontbutton")));
tgroup->font = g_strchomp(g_strdelimit(tgroup->font,"0123456789",' '));
tgroup->text = gtk_editable_get_chars(GTK_EDITABLE(gtk_builder_get_object(tgroups,"tg_tick_textentry")),0,-1);
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_text_day_colorbutton")),&tgroup->text_color[MTX_DAY]);
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_text_nite_colorbutton")),&tgroup->text_color[MTX_NITE]);
tgroup->font_scale = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_font_scale_spin")));
tgroup->text_inset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_text_inset_spin")));
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_day_colorbutton")),&tgroup->maj_tick_color[MTX_DAY]);
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_nite_colorbutton")),&tgroup->maj_tick_color[MTX_NITE]);
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_day_colorbutton")),&tgroup->min_tick_color[MTX_DAY]);
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_nite_colorbutton")),&tgroup->min_tick_color[MTX_NITE]);
tgroup->maj_tick_inset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_inset_spin")));
tgroup->min_tick_inset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_inset_spin")));
tgroup->maj_tick_width = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_width_spin")));
tgroup->min_tick_width = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_width_spin")));
tgroup->maj_tick_length = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_length_spin")));
tgroup->min_tick_length = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_length_spin")));
tgroup->start_angle = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_start_angle_spin")));
tgroup->sweep_angle = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")));
tgroup->num_maj_ticks = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_num_maj_ticks_spin")));
tgroup->num_min_ticks = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_num_min_ticks_spin")));
changed = TRUE;
mtx_gauge_face_set_tick_group_struct(MTX_GAUGE_FACE(gauge),tgroup);
g_free(tgroup->text);
g_free(tgroup);
update_onscreen_tgroups();
break;
default:
break;
}
if (GTK_IS_WIDGET(dialog))
gtk_widget_destroy(dialog);
return (FALSE);
}
void export_dash_xml(gchar * filename)
{
GtkWidget *dash = NULL;
GList *children = NULL;
GtkFixedChild *child = NULL;
gchar * tmpbuf = NULL;
guint i = 0;
xmlDocPtr doc = NULL; /* document pointer */
xmlNodePtr root_node = NULL;/* node pointers */
xmlNodePtr node = NULL;/* node pointers */
xmlDtdPtr dtd = NULL; /* DTD pointer */
GtkTreeIter parent;
GtkTreeIter iter;
GtkTreeModel *model = NULL;
gboolean state = FALSE;
gchar * iname = NULL;
gchar ** vector = NULL;
GtkAllocation allocation;
g_return_if_fail(filename);
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL,BAD_CAST "dashboard");
xmlDocSetRootElement(doc,root_node);
/*
* Creates a DTD declaration. Isn't mandatory.
*/
dtd = xmlCreateIntSubset(doc, BAD_CAST "dashboard", NULL, BAD_CAST "mtxdashboard.dtd");
dash = GTK_WIDGET(gtk_builder_get_object(toplevel,"dashboard"));
gtk_widget_get_allocation(dash, &allocation);
node = xmlNewChild(root_node,NULL,BAD_CAST "dash_geometry", NULL);
generic_xml_gint_export(node,"width",&allocation.width);
generic_xml_gint_export(node,"height",&allocation.height);
children = GTK_FIXED(dash)->children;
for(i=0;i<g_list_length(GTK_FIXED(dash)->children);i++)
{
child = g_list_nth_data(GTK_FIXED(dash)->children,i);
node = xmlNewChild(root_node,NULL,BAD_CAST "gauge", NULL);
gtk_widget_get_allocation(child->widget, &allocation);
generic_xml_gint_export(node,"width",&allocation.width);
generic_xml_gint_export(node,"height",&allocation.height);
generic_xml_gint_export(node,"x_offset",&child->x);
generic_xml_gint_export(node,"y_offset",&child->y);
tmpbuf = g_strrstr(mtx_gauge_face_get_xml_filename(MTX_GAUGE_FACE(child->widget)),"Gauges");
vector = g_strsplit(tmpbuf,PSEP,2);
generic_xml_gchar_export(node,"gauge_xml_name",&vector[1]);
g_strfreev(vector);
state = gtk_combo_box_get_active_iter(GTK_COMBO_BOX(OBJ_GET((child->widget),"combo")),&iter);
model = gtk_combo_box_get_model(GTK_COMBO_BOX(OBJ_GET((child->widget),"combo")));
gtk_tree_model_get(model,&iter,DATASOURCE_COL,&iname,-1);
generic_xml_gchar_export(node,"datasource",&iname);
}
xmlSaveFormatFileEnc(filename, doc, "utf-8", 1);
/*free the document */
xmlFreeDoc(doc);
/*
*Free the global variables that may
*have been allocated by the parser.
*/
xmlCleanupParser();
/*
* this is to debug memory for regression tests
*/
xmlMemoryDump();
return ;
}
void update_general_controls()
{
gfloat tmp1 = 0.0;
GtkWidget * widget = NULL;
MtxGaugeFace *g = NULL;
GdkColor color;
if (GTK_IS_WIDGET(gauge))
g = MTX_GAUGE_FACE(gauge);
else
return;
if (!toplevel)
return;
hold_handlers = TRUE;
mtx_gauge_face_get_attribute(g,ROTATION,&tmp1);
if (tmp1 == MTX_ROT_CW)
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"cw_rbutton"));
else if (tmp1 == MTX_ROT_CCW)
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"ccw_rbutton"));
else
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"cw_rbutton"));
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(widget),TRUE);
mtx_gauge_face_get_attribute(g,ANTIALIAS,&tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"antialiased_check"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),(gint)tmp1);
mtx_gauge_face_get_attribute(g,TATTLETALE,&tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"tattletale_check"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),(gint)tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"tattletale_alpha_spin"));
mtx_gauge_face_get_attribute(g,TATTLETALE_ALPHA,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_length_spin"));
mtx_gauge_face_get_attribute(g,NEEDLE_LENGTH,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_width_spin"));
mtx_gauge_face_get_attribute(g,NEEDLE_WIDTH,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_tip_width_spin"));
mtx_gauge_face_get_attribute(g,NEEDLE_TIP_WIDTH,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_tail_width_spin"));
mtx_gauge_face_get_attribute(g,NEEDLE_TAIL_WIDTH,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_tail_spin"));
mtx_gauge_face_get_attribute(g,NEEDLE_TAIL,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"start_angle_spin"));
mtx_gauge_face_get_attribute(g,START_ANGLE,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"sweep_angle_spin"));
mtx_gauge_face_get_attribute(g,SWEEP_ANGLE,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"lbound_spin"));
mtx_gauge_face_get_attribute(g,LBOUND,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"ubound_spin"));
mtx_gauge_face_get_attribute(g,UBOUND,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"background_color_day_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_BG_DAY, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"background_color_nite_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_BG_NITE, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_color_day_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_NEEDLE_DAY, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_color_nite_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_NEEDLE_NITE, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"gradient_begin_color_day_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_GRADIENT_BEGIN_DAY, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"gradient_begin_color_nite_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_GRADIENT_BEGIN_NITE, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"gradient_end_color_day_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_GRADIENT_END_DAY, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"gradient_end_color_nite_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_GRADIENT_END_NITE, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"daytime_radiobutton"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),mtx_gauge_face_get_daytime_mode(g));
hold_handlers = FALSE;
}
G_MODULE_EXPORT gboolean create_warning_span_event(GtkWidget * widget, gpointer data)
{
GtkBuilder *warnings;
GtkWidget *dialog = NULL;
GtkWidget *spinner = NULL;
GtkWidget *tmpwidget = NULL;
GtkWidget *cbutton = NULL;
MtxWarningRange *range = NULL;
gfloat lbound = 0.0;
gfloat ubound = 0.0;
gchar * filename = NULL;
gint result = 0;
GError *error = NULL;
gchar *pathstub = NULL;
if (!GTK_IS_WIDGET(gauge))
return FALSE;
pathstub = g_build_filename(GAUGEDESIGNER_GLADE_DIR,"w_range.ui",NULL);
filename = get_file(NULL,pathstub,NULL);
g_free(pathstub);
if (filename)
{
warnings = gtk_builder_new();
if(!gtk_builder_add_from_file(warnings,filename,&error))
{
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free(error);
exit(-1);
}
g_free(filename);
}
else
{
printf("Can't locate primary ui file!!!!\n");
exit(-1);
}
gtk_builder_connect_signals(warnings,NULL);
dialog = GTK_WIDGET (gtk_builder_get_object(warnings,"w_range_dialog"));
cbutton = GTK_WIDGET (gtk_builder_get_object(warnings,"range_day_colorbutton"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(cbutton),&white);
cbutton = GTK_WIDGET (gtk_builder_get_object(warnings,"range_nite_colorbutton"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(cbutton),&black);
if (!GTK_IS_WIDGET(dialog))
{
return FALSE;
}
/* Set the controls to sane ranges corresponding to the gauge */
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), LBOUND, &lbound);
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), UBOUND, &ubound);
spinner = GTK_WIDGET (gtk_builder_get_object(warnings,"range_lowpoint_spin"));
OBJ_SET(spinner,"builder",warnings);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(spinner),lbound,ubound);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner),(ubound-lbound)/2.0);
spinner = GTK_WIDGET (gtk_builder_get_object(warnings,"range_highpoint_spin"));
OBJ_SET(spinner,"builder",warnings);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(spinner),lbound,ubound);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner),ubound);
result = gtk_dialog_run(GTK_DIALOG(dialog));
switch (result)
{
case GTK_RESPONSE_APPLY:
range = g_new0(MtxWarningRange, 1);
range->lowpoint = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(warnings,"range_lowpoint_spin")));
range->highpoint = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(warnings,"range_highpoint_spin")));
range->inset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(warnings,"range_inset_spin")));
range->lwidth = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(warnings,"range_lwidth_spin")));
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(warnings,"range_day_colorbutton")),&range->color[MTX_DAY]);
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(warnings,"range_nite_colorbutton")),&range->color[MTX_NITE]);
changed = TRUE;
mtx_gauge_face_set_warning_range_struct(MTX_GAUGE_FACE(gauge),range);
g_free(range);
update_onscreen_w_ranges();
break;
default:
break;
}
if (GTK_IS_WIDGET(dialog))
gtk_widget_destroy(dialog);
return (FALSE);
}
void update_onscreen_w_ranges()
{
GtkWidget *container = NULL;
static GtkWidget *table = NULL;
GtkWidget *dummy = NULL;
GtkWidget *label = NULL;
GtkWidget *button = NULL;
GtkWidget *img = NULL;
GtkAdjustment *adj = NULL;
guint i = 0;
gint y = 1;
gfloat low = 0.0;
gfloat high = 0.0;
MtxWarningRange *range = NULL;
GArray * array = NULL;
if ((!toplevel) || (!GTK_IS_WIDGET(gauge)))
return;
array = (GArray *)mtx_gauge_face_get_warning_ranges(MTX_GAUGE_FACE(gauge));
container = GTK_WIDGET (gtk_builder_get_object(toplevel,"warning_range_viewport"));
if (!GTK_IS_WIDGET(container))
{
printf("color range viewport invalid!!\n");
return;
}
y=1;
if (GTK_IS_WIDGET(table))
gtk_widget_destroy(table);
table = gtk_table_new(2,7,FALSE);
gtk_container_add(GTK_CONTAINER(container),table);
if (array->len > 0)
{
/* Create headers */
label = gtk_label_new("Low");
gtk_table_attach(GTK_TABLE(table),label,1,2,0,1,GTK_EXPAND,GTK_SHRINK,0,0);
label = gtk_label_new("High");
gtk_table_attach(GTK_TABLE(table),label,2,3,0,1,GTK_EXPAND,GTK_SHRINK,0,0);
label = gtk_label_new("Inset");
gtk_table_attach(GTK_TABLE(table),label,3,4,0,1,GTK_EXPAND,GTK_SHRINK,0,0);
label = gtk_label_new("LWidth");
gtk_table_attach(GTK_TABLE(table),label,4,5,0,1,GTK_EXPAND,GTK_SHRINK,0,0);
label = gtk_label_new("Day Color");
gtk_table_attach(GTK_TABLE(table),label,5,6,0,1,GTK_EXPAND,GTK_SHRINK,0,0);
label = gtk_label_new("Night Color");
gtk_table_attach(GTK_TABLE(table),label,6,7,0,1,GTK_EXPAND,GTK_SHRINK,0,0);
}
/* Repopulate the table with the current ranges... */
for (i=0;i<array->len; i++)
{
range = g_array_index(array,MtxWarningRange *, i);
button = gtk_button_new();
img = gtk_image_new_from_stock("gtk-close",GTK_ICON_SIZE_MENU);
gtk_container_add(GTK_CONTAINER(button),img);
OBJ_SET((button),"range_index",GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(remove_w_range),NULL);
gtk_table_attach(GTK_TABLE(table),button,0,1,y,y+1,(GtkAttachOptions)0,(GtkAttachOptions)0,0,0);
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), LBOUND, &low);
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), UBOUND, &high);
dummy = gtk_spin_button_new_with_range(low,high,(high-low)/100);
OBJ_SET(dummy,"index",GINT_TO_POINTER(i));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),range->lowpoint);
g_signal_connect(G_OBJECT(dummy),"value_changed", G_CALLBACK(alter_w_range_data),GINT_TO_POINTER(WR_LOWPOINT));
gtk_table_attach(GTK_TABLE(table),dummy,1,2,y,y+1,GTK_SHRINK,GTK_SHRINK,0,0);
dummy = gtk_spin_button_new_with_range(low,high,(high-low)/100);
OBJ_SET(dummy,"index",GINT_TO_POINTER(i));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),range->highpoint);
g_signal_connect(G_OBJECT(dummy),"value_changed", G_CALLBACK(alter_w_range_data),GINT_TO_POINTER(WR_HIGHPOINT));
gtk_table_attach(GTK_TABLE(table),dummy,2,3,y,y+1,GTK_SHRINK,GTK_SHRINK,0,0);
dummy = gtk_spin_button_new_with_range(0,1,0.001);
OBJ_SET(dummy,"index",GINT_TO_POINTER(i));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),range->inset);
g_signal_connect(G_OBJECT(dummy),"value_changed", G_CALLBACK(alter_w_range_data),GINT_TO_POINTER(WR_INSET));
gtk_table_attach(GTK_TABLE(table),dummy,3,4,y,y+1,GTK_SHRINK,GTK_SHRINK,0,0);
dummy = gtk_spin_button_new_with_range(0,1,0.001);
OBJ_SET(dummy,"index",GINT_TO_POINTER(i));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),range->lwidth);
g_signal_connect(G_OBJECT(dummy),"value_changed", G_CALLBACK(alter_w_range_data),GINT_TO_POINTER(WR_LWIDTH));
gtk_table_attach(GTK_TABLE(table),dummy,4,5,y,y+1,GTK_SHRINK,GTK_SHRINK,0,0);
dummy = gtk_color_button_new_with_color(&range->color[MTX_DAY]);
OBJ_SET(dummy,"index",GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(dummy),"color_set", G_CALLBACK(alter_w_range_data),GINT_TO_POINTER(WR_COLOR_DAY));
gtk_table_attach(GTK_TABLE(table),dummy,5,6,y,y+1,GTK_SHRINK,GTK_SHRINK,0,0);
dummy = gtk_color_button_new_with_color(&range->color[MTX_NITE]);
OBJ_SET(dummy,"index",GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(dummy),"color_set", G_CALLBACK(alter_w_range_data),GINT_TO_POINTER(WR_COLOR_NITE));
gtk_table_attach(GTK_TABLE(table),dummy,6,7,y,y+1,GTK_SHRINK,GTK_SHRINK,0,0);
y++;
}
/* Scroll to end */
dummy = GTK_WIDGET (gtk_builder_get_object(toplevel,"crange_swin"));
adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(dummy));
gtk_adjustment_set_value(adj,gtk_adjustment_get_upper(adj));
gtk_widget_show_all(container);
}
/*!
\brief Creates a group of 2D Table Editors packed into a GtkNotebook
\param button is a pointer to the widget the user click on, which has bound
to is a list of the TE Table ID's which we need to create on-screen
representations for
\returns TRUE on success, FALSE otherwise
*/
G_MODULE_EXPORT gboolean create_2d_table_editor_group(GtkWidget *button)
{
GladeXML *main_xml = NULL;
GladeXML *xml = NULL;
GtkWidget *widget = NULL;
GtkWidget *window = NULL;
GtkWidget *notebook = NULL;
GtkWidget *curve = NULL;
GtkWidget *x_parent = NULL;
GtkWidget *y_parent = NULL;
GtkWidget *x_table = NULL;
GtkWidget *y_table = NULL;
GtkWidget *label = NULL;
GtkWidget *entry = NULL;
GtkWidget *dummy = NULL;
GtkWidget *gauge = NULL;
GtkWidget *parent = NULL;
GtkWidget *curve_parent = NULL;
CurveData *cdata = NULL;
GArray *x_entries = NULL;
GArray *y_entries = NULL;
GList *widget_list = NULL;
GList *curve_list = NULL;
GList *gauge_list = NULL;
gchar * tmpbuf = NULL;
gchar * filename = NULL;
gchar **vector = NULL;
GList ***ecu_widgets = NULL;
gint num_tabs = 0;
gint x_mult = 0;
gint y_mult = 0;
gint page = 0;
gint offset = 0;
gint i = 0;
gint j = 0;
gfloat tmpf = 0.0;
guint32 id = 0;
gint rows = 0;
gint table_num = 0;
Firmware_Details *firmware = NULL;
firmware = DATA_GET(global_data,"firmware");
ecu_widgets = DATA_GET(global_data,"ecu_widgets");
main_xml = (GladeXML *)DATA_GET(global_data,"main_xml");
if (!main_xml)
return FALSE;
xml = glade_xml_new(main_xml->filename,"table_editor_window",NULL);
window = glade_xml_get_widget(xml,"table_editor_window");
glade_xml_signal_autoconnect(xml);
g_signal_connect(G_OBJECT(window),"destroy_event",
G_CALLBACK(close_2d_editor),NULL);
g_signal_connect(G_OBJECT(window),"delete_event",
G_CALLBACK(close_2d_editor),NULL);
gtk_window_set_title(GTK_WINDOW(window),_("2D Table Group Editor"));
gtk_window_resize(GTK_WINDOW(window),800,530);
widget = glade_xml_get_widget(xml,"2d_close_button");
g_signal_connect_swapped(G_OBJECT(widget),"clicked",
G_CALLBACK(close_2d_editor),window);
widget = glade_xml_get_widget(xml,"get_data_button");
OBJ_SET(widget,"handler",GINT_TO_POINTER(READ_VE_CONST));
OBJ_SET_FULL(widget,"bind_to_list",g_strdup("get_data_buttons"),g_free);
bind_to_lists_f(widget,"get_data_buttons");
widget_list = g_list_prepend(widget_list,(gpointer)widget);
widget = glade_xml_get_widget(xml,"burn_data_button");
OBJ_SET(widget,"handler",GINT_TO_POINTER(BURN_FLASH));
OBJ_SET_FULL(widget,"bind_to_list",g_strdup("burners"),g_free);
bind_to_lists_f(widget,"burners");
widget_list = g_list_prepend(widget_list,(gpointer)widget);
/*
widget = glade_xml_get_widget(xml,"curve_editor_menuitem");
gtk_widget_set_sensitive(GTK_WIDGET(widget), FALSE);
*/
widget = glade_xml_get_widget(xml,"close_menuitem");
OBJ_SET(widget,"window",(gpointer)window);
widget = glade_xml_get_widget(xml,"te_layout_hbox1");
gtk_widget_destroy(widget);
widget = glade_xml_get_widget(xml,"te_layout_vbox");
tmpbuf = OBJ_GET(button,"te_tables");
vector = parse_keys_f(tmpbuf,&num_tabs,",");
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook),GTK_POS_LEFT);
gtk_box_pack_start(GTK_BOX(widget),notebook,TRUE,TRUE,0);
for (j = 0;j < num_tabs;j++)
{
table_num = (gint)strtod(vector[j],NULL);
if (table_num >= firmware->total_te_tables)
{
warn_user_f("Requested to create 2D table editor window for an undefined (out of range) table ID");
return FALSE;
}
if (!firmware->te_params)
{
warn_user_f("No 2D table Editor tables (te_tables) defined in interrogation profile, yet told to create a graph for a table... BUG detected!");
continue;
}
if (!firmware->te_params[table_num])
{
warn_user_f("Requested to create a 2D table editor window for an undefined table!");
continue;
}
xml = glade_xml_new(main_xml->filename,"te_layout_hbox1",NULL);
widget = glade_xml_get_widget(xml,"te_layout_hbox1");
label = gtk_label_new(firmware->te_params[table_num]->title);
gtk_misc_set_alignment(GTK_MISC(label),0,0.5);
if (firmware->te_params[table_num]->bind_to_list)
{
OBJ_SET_FULL(widget,"bind_to_list", g_strdup(firmware->te_params[table_num]->bind_to_list),g_free);
OBJ_SET(widget,"match_type", GINT_TO_POINTER(firmware->te_params[table_num]->match_type));
bind_to_lists_f(widget,firmware->te_params[table_num]->bind_to_list);
widget_list = g_list_prepend(widget_list,(gpointer)widget);
OBJ_SET_FULL(label,"bind_to_list", g_strdup(firmware->te_params[table_num]->bind_to_list),g_free);
OBJ_SET(label,"match_type", GINT_TO_POINTER(firmware->te_params[table_num]->match_type));
bind_to_lists_f(label,firmware->te_params[table_num]->bind_to_list);
widget_list = g_list_prepend(widget_list,(gpointer)label);
}
if (firmware->te_params[table_num]->gauge ||
firmware->te_params[table_num]->c_gauge ||
firmware->te_params[table_num]->f_gauge)
{
parent = glade_xml_get_widget(xml,"te_gaugeframe");
gauge = mtx_gauge_face_new();
gauge_list = g_list_prepend(gauge_list,(gpointer)gauge);
OBJ_SET(window,"gauge",gauge);
if (firmware->te_params[table_num]->gauge_temp_dep)
{
if ((GINT)DATA_GET(global_data,"mtx_temp_units") == CELSIUS)
tmpbuf = g_strdelimit(firmware->te_params[table_num]->c_gauge,"\\",'/');
else if ((GINT)DATA_GET(global_data,"mtx_temp_units") == KELVIN)
tmpbuf = g_strdelimit(firmware->te_params[table_num]->c_gauge,"\\",'/');
else
tmpbuf = g_strdelimit(firmware->te_params[table_num]->f_gauge,"\\",'/');
}
else
tmpbuf = g_strdelimit(firmware->te_params[table_num]->gauge,"\\",'/');
filename = get_file(g_strconcat(GAUGES_DATA_DIR,PSEP,tmpbuf,NULL),NULL);
mtx_gauge_face_import_xml(MTX_GAUGE_FACE(gauge),filename);
lookup_current_value_f(firmware->te_params[table_num]->gauge_datasource, &tmpf);
mtx_gauge_face_set_value(MTX_GAUGE_FACE(gauge),tmpf);
g_free(filename);
id = create_rtv_value_change_watch_f(firmware->te_params[table_num]->gauge_datasource,FALSE,"update_misc_gauge",(gpointer)gauge);
OBJ_SET(gauge,"gauge_id",GINT_TO_POINTER(id));
gtk_container_add(GTK_CONTAINER(parent),gauge);
}
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),widget,label);
curve_parent = glade_xml_get_widget(xml,"te_right_frame");
curve = mtx_curve_new();
curve_list = g_list_prepend(curve_list,(gpointer)curve);
mtx_curve_set_title(MTX_CURVE(curve),_(firmware->te_params[table_num]->title));
mtx_curve_set_x_axis_label(MTX_CURVE(curve),_(firmware->te_params[table_num]->x_axis_label));
mtx_curve_set_y_axis_label(MTX_CURVE(curve),_(firmware->te_params[table_num]->y_axis_label));
cdata = g_new0(CurveData, 1);
cdata->curve = curve;
cdata->axis = _X_;
cdata->source = firmware->te_params[table_num]->x_source;
id = create_rtv_value_change_watch_f(cdata->source,FALSE,"update_curve_marker",(gpointer)cdata);
mtx_curve_set_show_x_marker(MTX_CURVE(curve),TRUE);
OBJ_SET(curve,"cdata",(gpointer)cdata);
OBJ_SET(curve,"marker_id",GINT_TO_POINTER(id));
mtx_curve_set_auto_hide_vertexes(MTX_CURVE(curve),TRUE);
g_signal_connect(G_OBJECT(curve),"coords-changed",
G_CALLBACK(coords_changed), NULL);
g_signal_connect(G_OBJECT(curve),"vertex-proximity",
G_CALLBACK(vertex_proximity), NULL);
g_signal_connect(G_OBJECT(curve),"marker-proximity",
G_CALLBACK(marker_proximity), NULL);
label = glade_xml_get_widget(xml,"x_units");
gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->x_units);
label = glade_xml_get_widget(xml,"y_units");
gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->y_units);
label = glade_xml_get_widget(xml,"x_title");
gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->x_name);
label = glade_xml_get_widget(xml,"y_title");
gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->y_name);
rows = firmware->te_params[table_num]->bincount;
mtx_curve_set_empty_array(MTX_CURVE(curve),rows);
x_table = gtk_table_new(rows+1,1,FALSE);
y_table = gtk_table_new(rows+1,1,FALSE);
x_parent = glade_xml_get_widget(xml,"te_x_frame");
y_parent = glade_xml_get_widget(xml,"te_y_frame");
gtk_container_set_border_width(GTK_CONTAINER(x_table),5);
gtk_container_set_border_width(GTK_CONTAINER(y_table),5);
gtk_container_add(GTK_CONTAINER(x_parent),x_table);
gtk_container_add(GTK_CONTAINER(y_parent),y_table);
x_mult = get_multiplier_f(firmware->te_params[table_num]->x_size);
y_mult = get_multiplier_f(firmware->te_params[table_num]->y_size);
x_entries = g_array_new(FALSE,TRUE,sizeof(GtkWidget *));
y_entries = g_array_new(FALSE,TRUE,sizeof(GtkWidget *));
for (i=0;i<rows;i++)
{
/* X Column */
entry = gtk_entry_new();
OBJ_SET(entry,"last_value",GINT_TO_POINTER(-G_MAXINT));
gtk_entry_set_width_chars(GTK_ENTRY(entry),7);
OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i));
g_array_insert_val(x_entries,i,entry);
OBJ_SET(entry,"curve_axis",GINT_TO_POINTER(_X_));
OBJ_SET(entry,"dl_type",GINT_TO_POINTER(IMMEDIATE));
OBJ_SET(entry,"handler",GINT_TO_POINTER(GENERIC));
OBJ_SET_FULL(entry,"raw_lower",g_strdup_printf("%i",(firmware->te_params[table_num]->x_raw_lower)),g_free);
OBJ_SET_FULL(entry,"raw_upper",g_strdup_printf("%i",(firmware->te_params[table_num]->x_raw_upper)),g_free);
OBJ_SET(entry,"fromecu_mult",firmware->te_params[table_num]->x_fromecu_mult);
OBJ_SET(entry,"fromecu_add",firmware->te_params[table_num]->x_fromecu_add);
OBJ_SET(entry,"precision",GINT_TO_POINTER(firmware->te_params[table_num]->x_precision));
OBJ_SET(entry,"size",GINT_TO_POINTER(firmware->te_params[table_num]->x_size));
OBJ_SET(entry,"page",GINT_TO_POINTER(firmware->te_params[table_num]->x_page));
OBJ_SET(entry,"temp_dep",GINT_TO_POINTER(firmware->te_params[table_num]->x_temp_dep));
OBJ_SET(entry,"use_color",GINT_TO_POINTER(firmware->te_params[table_num]->x_use_color));
if(firmware->te_params[table_num]->x_temp_dep)
{
OBJ_SET(entry,"widget_temp",DATA_GET(global_data,"mtx_temp_units"));
OBJ_SET_FULL(entry,"bind_to_list", g_strdup("temperature"),g_free);
bind_to_lists_f(entry,"temperature");
}
offset = (i*x_mult) + firmware->te_params[table_num]->x_base;
OBJ_SET(entry,"offset",GINT_TO_POINTER(offset));
g_signal_connect(G_OBJECT(entry),"changed",
G_CALLBACK(update_2d_curve),curve);
g_signal_connect(G_OBJECT(entry),"changed",
G_CALLBACK(entry_changed_handler_f),NULL);
g_signal_connect(G_OBJECT(entry),"key_press_event",
G_CALLBACK(key_event_f),NULL);
g_signal_connect(G_OBJECT(entry),"key_release_event",
G_CALLBACK(key_event_f),NULL);
g_signal_connect(G_OBJECT(entry),"focus_out_event",
G_CALLBACK(focus_out_handler_f),NULL);
g_signal_connect(G_OBJECT(entry),"activate",
G_CALLBACK(std_entry_handler_f),NULL);
if (firmware->te_params[table_num]->reversed)
gtk_table_attach(GTK_TABLE(x_table),entry,
0,1,rows-i-1,rows-i, GTK_SHRINK,GTK_SHRINK,0,0);
else
gtk_table_attach(GTK_TABLE(x_table),entry,
0,1,i,i+1, GTK_SHRINK,GTK_SHRINK,0,0);
page = firmware->te_params[table_num]->x_page;
ecu_widgets[page][offset] = g_list_prepend(ecu_widgets[page][offset],(gpointer)entry);
widget_list = g_list_prepend(widget_list,(gpointer)entry);
update_widget(G_OBJECT(entry),NULL);
/* Y Column */
entry = gtk_entry_new();
OBJ_SET(entry,"last_value",GINT_TO_POINTER(-G_MAXINT));
gtk_entry_set_width_chars(GTK_ENTRY(entry),7);
OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i));
g_array_insert_val(y_entries,i,entry);
OBJ_SET(entry,"curve_axis",GINT_TO_POINTER(_Y_));
OBJ_SET(entry,"dl_type",GINT_TO_POINTER(IMMEDIATE));
OBJ_SET(entry,"handler",GINT_TO_POINTER(GENERIC));
OBJ_SET_FULL(entry,"raw_lower",g_strdup_printf("%i",(firmware->te_params[table_num]->y_raw_lower)),g_free);
OBJ_SET_FULL(entry,"raw_upper",g_strdup_printf("%i",(firmware->te_params[table_num]->y_raw_upper)),g_free);
OBJ_SET(entry,"fromecu_mult",firmware->te_params[table_num]->y_fromecu_mult);
OBJ_SET(entry,"fromecu_add",firmware->te_params[table_num]->y_fromecu_add);
OBJ_SET(entry,"precision",GINT_TO_POINTER(firmware->te_params[table_num]->y_precision));
OBJ_SET(entry,"size",GINT_TO_POINTER(firmware->te_params[table_num]->y_size));
OBJ_SET(entry,"page",GINT_TO_POINTER(firmware->te_params[table_num]->y_page));
OBJ_SET(entry,"temp_dep",GINT_TO_POINTER(firmware->te_params[table_num]->y_temp_dep));
OBJ_SET(entry,"use_color",GINT_TO_POINTER(firmware->te_params[table_num]->y_use_color));
if(firmware->te_params[table_num]->y_temp_dep)
{
OBJ_SET(entry,"widget_temp",DATA_GET(global_data,"mtx_temp_units"));
OBJ_SET_FULL(entry,"bind_to_list", g_strdup("temperature"),g_free);
bind_to_lists_f(entry,"temperature");
}
offset = (i*y_mult) + firmware->te_params[table_num]->y_base;
OBJ_SET(entry,"offset",GINT_TO_POINTER(offset));
g_signal_connect(G_OBJECT(entry),"changed",
G_CALLBACK(update_2d_curve),curve);
g_signal_connect(G_OBJECT(entry),"changed",
G_CALLBACK(entry_changed_handler_f),NULL);
g_signal_connect(G_OBJECT(entry),"key_press_event",
G_CALLBACK(key_event_f),NULL);
g_signal_connect(G_OBJECT(entry),"key_release_event",
G_CALLBACK(key_event_f),NULL);
g_signal_connect(G_OBJECT(entry),"focus_out_event",
G_CALLBACK(focus_out_handler_f),NULL);
g_signal_connect(G_OBJECT(entry),"activate",
G_CALLBACK(std_entry_handler_f),NULL);
if (firmware->te_params[table_num]->reversed)
gtk_table_attach(GTK_TABLE(y_table),entry,
0,1,rows-i-1,rows-i, GTK_SHRINK,GTK_SHRINK,0,0);
else
gtk_table_attach(GTK_TABLE(y_table),entry,
0,1,i,i+1, GTK_SHRINK,GTK_SHRINK,0,0);
page = firmware->te_params[table_num]->y_page;
ecu_widgets[page][offset] = g_list_prepend(ecu_widgets[page][offset],(gpointer)entry);
widget_list = g_list_prepend(widget_list,(gpointer)entry);
update_widget(G_OBJECT(entry),NULL);
}
/* Create the "LOCK" buttons */
dummy = gtk_toggle_button_new_with_label("Unlocked");
OBJ_SET(dummy,"axis",GINT_TO_POINTER(_X_));
g_signal_connect(G_OBJECT(dummy),"toggled",
G_CALLBACK(set_axis_locking),curve);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dummy),firmware->te_params[table_num]->x_lock);
gtk_table_attach(GTK_TABLE(x_table),dummy,
0,1,i,i+1, GTK_EXPAND|GTK_FILL,0,0,0);
dummy = gtk_toggle_button_new_with_label("Unlocked");
OBJ_SET(dummy,"axis",GINT_TO_POINTER(_Y_));
g_signal_connect(G_OBJECT(dummy),"toggled",
G_CALLBACK(set_axis_locking),curve);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dummy),firmware->te_params[table_num]->y_lock);
gtk_table_attach(GTK_TABLE(y_table),dummy,
0,1,i,i+1, GTK_EXPAND|GTK_FILL,0,0,0);
mtx_curve_set_x_precision(MTX_CURVE(curve),firmware->te_params[table_num]->x_precision);
mtx_curve_set_y_precision(MTX_CURVE(curve),firmware->te_params[table_num]->y_precision);
mtx_curve_set_hard_limits(MTX_CURVE(curve),
(gfloat)firmware->te_params[table_num]->x_raw_lower,
(gfloat)firmware->te_params[table_num]->x_raw_upper,
(gfloat)firmware->te_params[table_num]->y_raw_lower,
(gfloat)firmware->te_params[table_num]->y_raw_upper);
OBJ_SET(curve,"x_entries",x_entries);
OBJ_SET(curve,"y_entries",y_entries);
if (firmware->te_params[table_num]->bind_to_list)
g_list_foreach(get_list_f(firmware->te_params[table_num]->bind_to_list),alter_widget_state_f,NULL);
create_rtv_value_change_watch_f(cdata->source,TRUE,"update_curve_marker",(gpointer)cdata);
gtk_container_add(GTK_CONTAINER(curve_parent),curve);
}
OBJ_SET(window,"widget_list",widget_list);
OBJ_SET(window,"curve_list",curve_list);
OBJ_SET(window,"gauge_list",gauge_list);
gtk_widget_show_all(window);
return TRUE;
}
G_MODULE_EXPORT gboolean tg_spin_button_handler(GtkWidget *widget, gpointer data)
{
gint tmpi = 0;
gfloat tmpf = 0.0;
gfloat lbound = 0.0;
gfloat ubound = 0.0;
gfloat angle = 0.0;
gfloat sweep = 0.0;
gfloat tmp3 = 0.0;
gfloat percent = 0.0;
gfloat newval = 0.0;
GtkWidget *lowpartner = NULL;
GtkWidget *highpartner = NULL;
MtxGaugeFace *g = NULL;
gint handler = (GINT)OBJ_GET((widget),"spin_handler");
tmpf = (gfloat)gtk_spin_button_get_value((GtkSpinButton *)widget);
tmpi = (gint)(tmpf+0.00001);
if (GTK_IS_WIDGET(gauge))
g = MTX_GAUGE_FACE(gauge);
else
return FALSE;
if (hold_handlers)
return TRUE;
switch (handler)
{
case ADJ_LOW_UNIT_PARTNER:
lowpartner = OBJ_GET((widget),"lowpartner");
highpartner = OBJ_GET((widget),"highpartner");
if ((!GTK_IS_WIDGET(lowpartner)) ||
(!GTK_IS_WIDGET(highpartner)))
break;
mtx_gauge_face_get_attribute(g,START_ANGLE,&angle);
mtx_gauge_face_get_attribute(g,SWEEP_ANGLE,&sweep);
percent = (tmpf-angle)/(sweep);
mtx_gauge_face_get_attribute(g,LBOUND,&lbound);
mtx_gauge_face_get_attribute(g,UBOUND,&ubound);
newval = ((ubound-lbound)*percent)+lbound;
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lowpartner),newval);
tmp3 = gtk_spin_button_get_value(GTK_SPIN_BUTTON(OBJ_GET((widget),"high_angle")));
percent = tmp3/sweep+((tmpf-angle)/sweep);
newval = ((ubound-lbound)*percent)+lbound;
gtk_spin_button_set_value(GTK_SPIN_BUTTON(highpartner),newval);
break;
case ADJ_HIGH_UNIT_PARTNER:
highpartner = OBJ_GET((widget),"highpartner");
tmp3 = gtk_spin_button_get_value(GTK_SPIN_BUTTON(OBJ_GET((widget),"low_angle")));
if (!GTK_IS_WIDGET(highpartner))
break;
mtx_gauge_face_get_attribute(g,START_ANGLE,&angle);
mtx_gauge_face_get_attribute(g,SWEEP_ANGLE,&sweep);
percent = tmpf/sweep+((tmp3-angle)/sweep);
mtx_gauge_face_get_attribute(g,LBOUND,&lbound);
mtx_gauge_face_get_attribute(g,UBOUND,&ubound);
newval = ((ubound-lbound)*percent)+lbound;
gtk_spin_button_set_value(GTK_SPIN_BUTTON(highpartner),newval);
break;
case ADJ_START_ANGLE_PARTNER:
lowpartner = OBJ_GET((widget),"lowpartner");
if (!GTK_IS_WIDGET(lowpartner))
break;
mtx_gauge_face_get_attribute(g,LBOUND,&lbound);
mtx_gauge_face_get_attribute(g,UBOUND,&ubound);
percent = (tmpf-lbound)/(ubound-lbound);
mtx_gauge_face_get_attribute(g,START_ANGLE,&angle);
mtx_gauge_face_get_attribute(g,SWEEP_ANGLE,&sweep);
newval = ((sweep)*percent)+angle;
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lowpartner),newval);
break;
case ADJ_SWEEP_ANGLE_PARTNER:
highpartner = OBJ_GET((widget),"highpartner");
if (!GTK_IS_WIDGET(highpartner))
break;
tmp3 = gtk_spin_button_get_value(GTK_SPIN_BUTTON(OBJ_GET((widget),"start_angle")));
mtx_gauge_face_get_attribute(g,LBOUND,&lbound);
mtx_gauge_face_get_attribute(g,UBOUND,&ubound);
percent = (tmpf-lbound)/(ubound-lbound);
mtx_gauge_face_get_attribute(g,START_ANGLE,&angle);
mtx_gauge_face_get_attribute(g,SWEEP_ANGLE,&sweep);
newval = ((percent*sweep)+angle)-tmp3;
gtk_spin_button_set_value(GTK_SPIN_BUTTON(highpartner),newval);
break;
}
return (TRUE);
}
