MessageView *messageview_create(void)
{
MessageView *messageview;
GtkWidget *vbox;
GtkWidget *notebook;
HeaderView *headerview;
TextView *textview;
MimeView *mimeview;
debug_print(_("Creating message view...\n"));
messageview = g_new0(MessageView, 1);
messageview->type = MVIEW_TEXT;
headerview = headerview_create();
textview = textview_create();
textview->messageview = messageview;
mimeview = mimeview_create();
mimeview->textview = textview_create();
mimeview->textview->messageview = messageview;
mimeview->imageview = imageview_create();
mimeview->imageview->messageview = messageview;
mimeview->messageview = messageview;
notebook = gtk_notebook_new();
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
gtk_widget_show(notebook);
gtk_container_add(GTK_CONTAINER(notebook), GTK_WIDGET_PTR(textview));
gtk_notebook_set_tab_label_text
(GTK_NOTEBOOK(notebook), GTK_WIDGET_PTR(textview), _("Text"));
gtk_container_add(GTK_CONTAINER(notebook), GTK_WIDGET_PTR(mimeview));
gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(notebook),
GTK_WIDGET_PTR(mimeview),
_("Attachments"));
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
gtk_widget_show_all(notebook);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET_PTR(headerview),
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
gtk_widget_show(vbox);
/* to remove without destroyed */
gtk_widget_ref(GTK_WIDGET_PTR(mimeview->textview));
gtk_widget_ref(GTK_WIDGET_PTR(mimeview->imageview));
g_signal_connect(G_OBJECT(notebook), "switch_page",
G_CALLBACK(messageview_switch_page_cb), messageview);
messageview->vbox = vbox;
messageview->notebook = notebook;
messageview->new_window = FALSE;
messageview->window = NULL;
messageview->window_vbox = NULL;
messageview->body_vbox = NULL;
messageview->headerview = headerview;
messageview->textview = textview;
messageview->mimeview = mimeview;
messageview->statusbar = NULL;
messageview->statusbar_cid = 0;
messageview->current_page = 0;
return messageview;
}
void addParams (GtkNotebook *notebook, PluginParameters *params) {
int n;
GtkWidget *table = gtk_table_new (params->nbParams, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 11);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
for (n=0;n<params->nbParams;++n) {
if (params->params[n] == 0) {
GtkWidget *hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (table), hseparator, 0, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 5);
} else {
PluginParam *p = params->params[n];
if (p->type != PARAM_BOOLVAL) {
GtkWidget *label4 = gtk_label_new (p->name);
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table), label4, 0, 1, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
}
switch (p->type) {
case PARAM_INTVAL: {
GtkWidget *spinbutton_adj,*spinbutton;
spinbutton_adj = (GtkWidget*)gtk_adjustment_new (
p->param.ival.value,
p->param.ival.min, p->param.ival.max,
p->param.ival.step, p->param.ival.step*10,
p->param.ival.step*10);
spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_adj), 1, 0);
gtk_widget_show (spinbutton);
gtk_table_attach (GTK_TABLE (table), spinbutton, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinbutton),
GTK_UPDATE_IF_VALID);
p->user_data = spinbutton;
gtk_object_set_data (GTK_OBJECT(spinbutton),"param",(void*)p);
p->change_listener = my_int_listener;
gtk_signal_connect (GTK_OBJECT (spinbutton), "changed",
GTK_SIGNAL_FUNC (on_spinbutton_int_changed),
NULL);
break;
}
case PARAM_FLOATVAL: {
GtkWidget *progress,*prog_adj;
prog_adj = (GtkWidget*)gtk_adjustment_new (
p->param.fval.value,
p->param.fval.min, p->param.fval.max,
p->param.fval.step, p->param.fval.step*10,
p->param.fval.step*10);
progress = gtk_progress_bar_new_with_adjustment(GTK_ADJUSTMENT(prog_adj));
gtk_widget_show(progress);
gtk_table_attach (GTK_TABLE (table), progress, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 1);
p->user_data = progress;
p->change_listener = my_float_listener;
break;
}
case PARAM_LISTVAL: {
int i;
GList *combo_winsize_items = NULL;
GtkWidget *combo_entry_winsize = NULL;
GtkWidget *combo_winsize = gtk_combo_new ();
gtk_widget_show (combo_winsize);
gtk_table_attach (GTK_TABLE (table), combo_winsize, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_combo_set_value_in_list (GTK_COMBO (combo_winsize), TRUE, TRUE);
for (i=0;i<p->param.slist.nbChoices;++i)
combo_winsize_items = g_list_append (combo_winsize_items,
p->param.slist.choices[i]);
gtk_combo_set_popdown_strings (GTK_COMBO (combo_winsize), combo_winsize_items);
g_list_free (combo_winsize_items);
combo_entry_winsize = GTK_COMBO (combo_winsize)->entry;
gtk_widget_show (combo_entry_winsize);
gtk_entry_set_editable (GTK_ENTRY (combo_entry_winsize), FALSE);
gtk_entry_set_text (GTK_ENTRY (combo_entry_winsize), LVAL(*p));
p->change_listener = my_list_listener;
p->user_data = combo_entry_winsize;
gtk_object_set_data (GTK_OBJECT(combo_entry_winsize),"param",(void*)p);
gtk_signal_connect (GTK_OBJECT (combo_entry_winsize), "changed",
GTK_SIGNAL_FUNC (on_list_changed),
NULL);
break;
}
case PARAM_BOOLVAL: {
GtkWidget *checkbutton_double =
gtk_check_button_new_with_label (p->name);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_double),BVAL(*p));
gtk_widget_show (checkbutton_double);
gtk_table_attach (GTK_TABLE (table), checkbutton_double, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_signal_connect (GTK_OBJECT (checkbutton_double), "toggled",
GTK_SIGNAL_FUNC (on_bool_toggled),
NULL);
gtk_object_set_data (GTK_OBJECT(checkbutton_double),"param",(void*)p);
p->user_data = checkbutton_double;
p->change_listener = my_bool_listener;
break;
}
}
}
}
gtk_widget_show_all(GTK_WIDGET(table));
gtk_container_add(GTK_CONTAINER(notebook),table);
gtk_notebook_set_tab_label_text(notebook,GTK_WIDGET(table),params->name);
}
static void
hildon_font_selection_dialog_construct_notebook (HildonFontSelectionDialog *fontsel)
{
gint i;
GtkWidget *vbox_tab[3];
GtkWidget *font_color_box;
GtkWidget *caption_control;
GtkSizeGroup *group;
HildonFontSelectionDialogPrivate *priv = HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE (fontsel);
g_assert (priv);
for (i = 0; i < 3; i++)
vbox_tab[i] = gtk_vbox_new (TRUE, 0);
group = GTK_SIZE_GROUP (gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL));
/* Build the first page of the GtkNotebook: font style */
priv->cbx_font_type = gtk_combo_box_new_text ();
hildon_font_selection_dialog_show_available_fonts (fontsel);
caption_control = hildon_caption_new (group,
_("ecdg_fi_font_font"),
priv->cbx_font_type,
NULL,
HILDON_CAPTION_OPTIONAL);
gtk_box_pack_start (GTK_BOX (vbox_tab[0]), caption_control, FALSE, FALSE, 0);
priv->cbx_font_size = gtk_combo_box_new_text ();
hildon_font_selection_dialog_show_available_sizes (priv);
caption_control = hildon_caption_new (group,
_("ecdg_fi_font_size"),
priv->cbx_font_size,
NULL,
HILDON_CAPTION_OPTIONAL);
gtk_box_pack_start (GTK_BOX (vbox_tab[0]), caption_control, FALSE, FALSE, 0);
font_color_box = gtk_hbox_new (FALSE, 0);
priv->font_color_button = hildon_color_button_new ();
priv->color_set = FALSE;
priv->font_scaling = 1.0;
priv->color_modified_signal_handler =
g_signal_connect (G_OBJECT (priv->font_color_button), "notify::color",
G_CALLBACK (color_modified_cb), (gpointer) priv);
gtk_box_pack_start (GTK_BOX (font_color_box), priv->font_color_button, FALSE, FALSE, 0);
caption_control =
hildon_caption_new (group, _("ecdg_fi_font_colour_selector"),
font_color_box,
NULL, HILDON_CAPTION_OPTIONAL);
gtk_box_pack_start (GTK_BOX (vbox_tab[0]), caption_control, FALSE, FALSE, 0);
/* Build the second page of the GtkNotebook: font formatting */
priv->chk_bold = gtk_check_button_new ();
caption_control = hildon_caption_new (group,
_("ecdg_fi_font_bold"),
priv->chk_bold,
NULL,
HILDON_CAPTION_OPTIONAL);
gtk_box_pack_start (GTK_BOX (vbox_tab[1]), caption_control, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (priv->chk_bold), "clicked",
G_CALLBACK(toggle_clicked), NULL);
priv->chk_italic = gtk_check_button_new ();
caption_control = hildon_caption_new (group, _("ecdg_fi_font_italic"),
priv->chk_italic,
NULL, HILDON_CAPTION_OPTIONAL);
gtk_box_pack_start (GTK_BOX (vbox_tab[1]), caption_control, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(priv->chk_italic), "clicked",
G_CALLBACK(toggle_clicked), NULL);
priv->chk_underline = gtk_check_button_new();
caption_control =
hildon_caption_new (group, _("ecdg_fi_font_underline"),
priv->chk_underline, NULL,
HILDON_CAPTION_OPTIONAL);
gtk_box_pack_start (GTK_BOX (vbox_tab[1]), caption_control, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT(priv->chk_underline), "clicked",
G_CALLBACK (toggle_clicked), NULL);
/* Build the third page of the GtkNotebook: other font properties */
priv->chk_strikethrough = gtk_check_button_new ();
caption_control = hildon_caption_new(group, _("ecdg_fi_font_strikethrough"),
priv->chk_strikethrough, NULL,
HILDON_CAPTION_OPTIONAL);
gtk_box_pack_start (GTK_BOX (vbox_tab[2]), caption_control, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT(priv->chk_strikethrough), "clicked",
G_CALLBACK (toggle_clicked), NULL);
priv->cbx_positioning = gtk_combo_box_new_text ();
hildon_font_selection_dialog_show_available_positionings (priv);
caption_control =
hildon_caption_new(group, _("ecdg_fi_font_special"),
priv->cbx_positioning, NULL,
HILDON_CAPTION_OPTIONAL);
g_object_unref (group);
gtk_box_pack_start (GTK_BOX (vbox_tab[2]), caption_control, FALSE, FALSE, 0);
/* Populate notebook */
gtk_notebook_insert_page (priv->notebook, vbox_tab[0], NULL, 0);
gtk_notebook_insert_page (priv->notebook, vbox_tab[1], NULL, 1);
gtk_notebook_insert_page (priv->notebook, vbox_tab[2], NULL, 2);
gtk_notebook_set_tab_label_text (priv->notebook, vbox_tab[0],
_("ecdg_ti_font_dialog_style"));
gtk_notebook_set_tab_label_text (priv->notebook, vbox_tab[1],
_("ecdg_ti_font_dialog_format"));
gtk_notebook_set_tab_label_text (priv->notebook, vbox_tab[2],
_("ecdg_ti_font_dialog_other"));
gtk_widget_show_all (GTK_WIDGET (priv->notebook));
}
/*!
\brief bind_data() is a recursive function that is called for every container
widget in a glade frame and it's purpose is to search the datamap file passed
for the widget names in the glade file and if it's fond in the datamap to
load all the attribues listed and bind them to the object using GTK+'s
object model.
\param widget is the widget passed to load attributes on
\param user_data is the pointer to a BingGroup structure.
*/
G_MODULE_EXPORT void bind_data(GtkWidget *widget, gpointer user_data)
{
BindGroup *bindgroup = (BindGroup *)user_data;
ConfigFile *cfgfile = bindgroup->cfgfile;
GHashTable *groups = bindgroup->groups;
gchar * tmpbuf = NULL;
gchar * section = NULL;
gchar ** keys = NULL;
gint num_keys = 0;
gint offset = 0;
gint page = 0;
gint index = 0;
gchar * initializer = NULL;
GdkColor color;
gchar *size = NULL;
gint count = 0;
gint tmpi = 0;
gboolean hidden = FALSE;
gchar *ptr = NULL;
gchar **vector = NULL;
gchar **vec2 = NULL;
void (*func)(void) = NULL;
GList *list = NULL;
GList *list2 = NULL;
const gchar *name = NULL;
gboolean indexed = FALSE;
Firmware_Details *firmware = NULL;
GList ***ecu_widgets = NULL;
GList *tab_widgets = NULL;
void (*load_dep_obj)(GObject *, ConfigFile *,const gchar *,const gchar *) = NULL;
ENTER();
MTXDBG(TABLOADER,_("Entered"));
ecu_widgets = (GList ***)DATA_GET(global_data,"ecu_widgets");
firmware = (Firmware_Details *)DATA_GET(global_data,"firmware");
g_return_if_fail(ecu_widgets);
g_return_if_fail(firmware);
if (!GTK_IS_WIDGET(widget))
{
EXIT();
return;
}
if (GTK_IS_WIDGET(widget))
if (GTK_IS_CONTAINER(widget))
gtk_container_foreach(GTK_CONTAINER(widget),bind_data,user_data);
name = gtk_widget_get_name(widget);
if (!name)
{
EXIT();
return;
}
if (NULL != (ptr = g_strrstr_len(name,strlen(name),"_of_")))
{
indexed = TRUE;
ptr = g_strrstr_len(name,ptr-name,"_");
tmpbuf = g_strdelimit(g_strdup(ptr),"_",' ');
section = g_strndup(name,ptr-name);
/*printf("(indexed) section is %s\n",section);*/
gint result = sscanf(tmpbuf,"%d of %d",&index,&count);
/*printf("sscanf result %i\n",result);*
* printf("Found indexed value for \"%s\", index %i, count %i\n",tmpbuf,index,count);
*/
g_free(tmpbuf);
}
else
section = g_strdup(name);
if(cfg_read_string(cfgfile, section, "keys", &tmpbuf))
{
keys = parse_keys(tmpbuf,&num_keys,",");
MTXDBG(TABLOADER,_("Number of keys for %s is %i\n"),section,num_keys);
g_free(tmpbuf);
}
else
{
g_free(section);
EXIT();
return;
}
page = -1;
/* Store ptr to self in qdata, needed for bind_to_lists from groups*/
OBJ_SET(widget,"self",widget);
/* Bind the data in the "defaults" group per tab to EVERY var in that
* tab
*/
page = bind_group_data(cfgfile, G_OBJECT(widget), groups, "defaults");
if(cfg_read_string(cfgfile, section, "group", &tmpbuf))
{
page = bind_group_data(cfgfile,G_OBJECT(widget),groups,tmpbuf);
g_free(tmpbuf);
}
if ((!cfg_read_int(cfgfile, section, "page", &page)) && (page == -1))
{
MTXDBG(TABLOADER|CRITICAL,_("Object %s doesn't have a page assigned!!!!\n"),section);
}
/* Bind widgets to lists if they have the bind_to_list flag set...
*/
tmpbuf = NULL;
if (cfg_read_string(cfgfile, section, "bind_to_list", &tmpbuf))
{
bind_to_lists(widget, tmpbuf);
g_free(tmpbuf);
}
if (cfg_read_boolean(cfgfile,section,"ellipsize",&tmpi))
{
if ((GTK_IS_LABEL(widget)) && (tmpi))
{
OBJ_SET(widget,"ellipsize_preferred",GINT_TO_POINTER(TRUE));
if (DATA_GET(global_data,"ellipsize_tabs"))
gtk_label_set_ellipsize(GTK_LABEL(widget),PANGO_ELLIPSIZE_END);
}
}
/* Color selections */
if (cfg_read_string(cfgfile, section, "active_fg", &tmpbuf))
{
gdk_color_parse(tmpbuf, &color);
gtk_widget_modify_fg(widget, GTK_STATE_NORMAL, &color);
g_free(tmpbuf);
}
if (cfg_read_string(cfgfile, section, "inactive_fg", &tmpbuf))
{
gdk_color_parse(tmpbuf, &color);
gtk_widget_modify_fg(widget, GTK_STATE_INSENSITIVE, &color);
g_free(tmpbuf);
}
/* If this widget has a "depend_on" tag we need to load the dependancy
* information and store it for use when needed...
*/
if (cfg_read_string(cfgfile,section,"depend_on",&tmpbuf))
{
if (get_symbol("load_dependencies_obj",(void **)&load_dep_obj))
load_dep_obj(G_OBJECT(widget),cfgfile,section,"depend_on");
g_free(tmpbuf);
}
/* If this widget (a textview) has "create_tags" we call a special
* handler just for that..
*/
if (cfg_read_string(cfgfile,section,"create_tags",&tmpbuf))
{
load_tags(G_OBJECT(widget),cfgfile,section);
g_free(tmpbuf);
}
/* If this widget has "tooltip" set the tip on the widget */
if (cfg_read_string(cfgfile,section,"tooltip",&tmpbuf))
{
gtk_widget_set_tooltip_text(widget,tmpbuf);
g_free(tmpbuf);
}
/* If this widget (a label) has "set_label" we set the label on it
*/
if (cfg_read_string(cfgfile,section,"set_label",&tmpbuf))
{
/* printf("setting label on %s to \"%s\"\n",glade_get_widget_name(widget),tmpbuf);*/
gtk_label_set_text(GTK_LABEL(widget),tmpbuf);
g_free(tmpbuf);
}
/* If this widget is temp dependant, set the current units on it
*/
if (cfg_read_string(cfgfile,section,"temp_dep",&tmpbuf))
{
OBJ_SET(widget,"widget_temp",DATA_GET(global_data,"mtx_temp_units"));
g_free(tmpbuf);
}
/* If this widget has "register_as", register it with the supplied name
*/
if (cfg_read_string(cfgfile,section,"register_as",&tmpbuf))
{
register_widget(tmpbuf,widget);
g_free(tmpbuf);
}
/* If this widget has visible_functions defined */
if (cfg_read_string(cfgfile,section,"visible_functions",&tmpbuf))
{
vector = g_strsplit(tmpbuf,",",-1);
g_free(tmpbuf);
for (guint i=0;i<g_strv_length(vector);i++)
{
vec2 = g_strsplit(vector[i],":",2);
if (g_strv_length(vec2) != 2)
{
printf("ERROR in %s, visible_functions param is missing the framerate parameter (func:fps)\n",cfgfile->filename);
g_strfreev(vec2);
continue;
}
gint fps = (GINT)g_strtod(vec2[1],NULL);
get_symbol(vec2[0],(void **)&func);
if (func)
{
list = g_list_prepend(list,(gpointer)func);
list2 = g_list_prepend(list2,GINT_TO_POINTER(fps));
}
g_strfreev(vec2);
}
g_strfreev(vector);
OBJ_SET_FULL(widget,"func_list",list,g_list_free);
OBJ_SET_FULL(widget,"func_fps_list",list2,g_list_free);
}
/* If this widget has "initializer" there's a global variable
* with it's name on it
*/
if (cfg_read_string(cfgfile,section,"initializer",&initializer))
{
gint widget_type = 0;
if (!cfg_read_string(cfgfile,section,"widget_type",&tmpbuf))
MTXDBG(TABLOADER|CRITICAL,_("Object %s has initializer, but no widget_type!!!!\n"),section);
else
widget_type = translate_string(tmpbuf);
g_free(tmpbuf);
switch (widget_type)
{
case MTX_RANGE:
gtk_range_set_value(GTK_RANGE(widget),(GINT)DATA_GET(global_data,initializer));
break;
case MTX_SPINBUTTON:
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),(GINT)DATA_GET(global_data,initializer));
break;
case MTX_ENTRY:
gtk_entry_set_text(GTK_ENTRY(widget),(gchar *)DATA_GET(global_data,initializer));
default:
break;
}
g_free(initializer);
}
/* Hidden widgets have special handlers and should NOT be updated normally */
cfg_read_boolean(cfgfile,section, "hidden", &hidden);
offset = -1;
cfg_read_int(cfgfile,section, "offset", &offset);
if (offset >= 0 && indexed)
{
/*printf("indexed widget %s\n",name); */
if (cfg_read_string(cfgfile, section, "size", &size))
{
offset += index * get_multiplier ((DataSize)translate_string (size));
g_free(size);
}
else
{
if(OBJ_GET(widget, "size"))
{
offset += index * get_multiplier ((DataSize)(GINT)OBJ_GET(widget, "size"));
}
else
{
MTXDBG(TABLOADER|CRITICAL,_("Indexed Object %s has index and offset, but no size!!!!\n"),section);
g_free(section);
EXIT();
return;
}
}
/*printf("widget %s, offset %i\n",name,offset);*/
OBJ_SET(widget,"offset",GINT_TO_POINTER(offset));
}
if (offset >= 0)
{
/* The way we do it now is to STORE widgets in LISTS for each
* offset, thus we can have multiple on screen controls bound
* to single data offset in the ECU
*/
if (page < 0)
{
MTXDBG(TABLOADER|CRITICAL,_("Attempting to append widget beyond bounds of Firmware Parameters, there is a bug with this datamap widget %s, page %i, at offset %i...\n\n"),section,page,offset);
g_free(section);
EXIT();
return;
}
if (page < firmware->total_pages)
{
if (offset >= firmware->page_params[page]->length)
MTXDBG(TABLOADER|CRITICAL,_("Attempting to append widget beyond bounds of Firmware Parameters, there is a bug with this datamap widget %s, at offset %i...\n\n"),section,offset);
else if (!hidden)
{
tab_widgets = OBJ_GET(bindgroup->topframe,"tab_widgets");
tab_widgets = g_list_prepend(tab_widgets, widget);
OBJ_SET(bindgroup->topframe,"tab_widgets",tab_widgets);
ecu_widgets[page][offset] = g_list_prepend(
ecu_widgets[page][offset],
(gpointer)widget);
}
}
else
MTXDBG(TABLOADER|CRITICAL,_("Attempting to append widget beyond bounds of Firmware Parameters, there is a bug with this datamap for widget %s, at page %i offset %i...\n\n"),section,page,offset);
}
/* If there is a "group" key in a section it means that it gets the
* rest of it's setting from the groupname listed. This reduces
* redundant keys all throughout the file...
*/
bind_keys(G_OBJECT(widget), cfgfile, section, keys, num_keys);
g_strfreev(keys);
/* If this widget has the "choices" key (combobox)
*/
if (cfg_read_string(cfgfile,section,"choices",&tmpbuf))
{
combo_setup(G_OBJECT(widget),cfgfile,section);
g_free(tmpbuf);
}
if (cfg_read_string(cfgfile,section,"post_functions_with_arg",&tmpbuf))
{
run_post_functions_with_arg(tmpbuf,widget);
g_free(tmpbuf);
}
if (cfg_read_string(cfgfile,section,"post_functions",&tmpbuf))
{
run_post_functions(tmpbuf);
g_free(tmpbuf);
}
if (cfg_read_boolean(cfgfile,section,"show_widget",&tmpi))
{
if (tmpi)
gtk_widget_show(widget);
else
gtk_widget_hide(widget);
}
if (cfg_read_string(cfgfile,section,"set_tab_labels",&tmpbuf))
{
if (GTK_IS_NOTEBOOK(widget))
{
vector=g_strsplit(tmpbuf,",",-1);
if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(widget)) == g_strv_length(vector))
{
for (int i=0;i<g_strv_length(vector);i++)
{
gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(widget),
gtk_notebook_get_nth_page(GTK_NOTEBOOK(widget),i),
vector[i]);
}
}
g_strfreev(vector);
}
g_free(tmpbuf);
}
g_free(section);
MTXDBG(TABLOADER,_("Leaving"));
EXIT();
return;
}
static int fmcomms2adv_init(GtkWidget *notebook)
{
GtkWidget *fmcomms2adv_panel;
int i;
builder = gtk_builder_new();
nbook = GTK_NOTEBOOK(notebook);
if (!gtk_builder_add_from_file(builder, "fmcomms2_adv.glade", NULL))
gtk_builder_add_from_file(builder, OSC_GLADE_FILE_PATH "fmcomms2_adv.glade", NULL);
fmcomms2adv_panel = GTK_WIDGET(gtk_builder_get_object(builder, "fmcomms2adv_panel"));
for (i = 0; i < ARRAY_SIZE(attrs); i++)
connect_widget(builder, &attrs[i]);
gtk_combo_box_set_active(GTK_COMBO_BOX(
GTK_WIDGET(gtk_builder_get_object(builder, "bist_tone"))), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(
GTK_WIDGET(gtk_builder_get_object(builder, "bist_tone_frequency"))), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(
GTK_WIDGET(gtk_builder_get_object(builder, "tone_level"))), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(
GTK_WIDGET(gtk_builder_get_object(builder, "bist_prbs"))), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(
GTK_WIDGET(gtk_builder_get_object(builder, "loopback"))), 0);
g_builder_connect_signal(builder, "bist_tone", "changed",
G_CALLBACK(bist_tone_cb), builder);
g_builder_connect_signal(builder, "bist_tone_frequency", "changed",
G_CALLBACK(bist_tone_cb), builder);
g_builder_connect_signal(builder, "tone_level", "changed",
G_CALLBACK(bist_tone_cb), builder);
g_builder_connect_signal(builder, "c2q", "toggled",
G_CALLBACK(bist_tone_cb), builder);
g_builder_connect_signal(builder, "c1q", "toggled",
G_CALLBACK(bist_tone_cb), builder);
g_builder_connect_signal(builder, "c2i", "toggled",
G_CALLBACK(bist_tone_cb), builder);
g_builder_connect_signal(builder, "c1i", "toggled",
G_CALLBACK(bist_tone_cb), builder);
if (dev_slave) {
g_builder_connect_signal(builder, "mcs_sync", "clicked",
G_CALLBACK(mcs_cb), builder);
gtk_combo_box_set_active(
GTK_COMBO_BOX(gtk_builder_get_object(builder, "calibration_switch_control")), 0);
__cal_switch_ports_enable_cb(0);
g_builder_connect_signal(builder, "calibration_switch_control", "changed",
G_CALLBACK(cal_switch_ports_enable_cb), builder);
g_builder_connect_signal(builder, "tx_phase", "value-changed",
G_CALLBACK(tx_phase_hscale_value_changed), 0);
g_builder_connect_signal(builder, "do_fmcomms5_cal", "clicked",
G_CALLBACK(do_calibration), gtk_builder_get_object(builder, "do_fmcomms5_cal"));
g_builder_connect_signal(builder, "undo_fmcomms5_cal", "clicked",
G_CALLBACK(undo_calibration), NULL);
} else {
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "mcs_sync")));
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "frame_fmcomms5")));
}
this_page = gtk_notebook_append_page(GTK_NOTEBOOK(notebook), fmcomms2adv_panel, NULL);
gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(notebook), fmcomms2adv_panel, "FMComms2 Advanced");
g_builder_connect_signal(builder, "notebook1", "switch-page",
G_CALLBACK(change_page_cb),
GTK_WIDGET(gtk_builder_get_object(builder, "initialize")));
return 0;
}
void set_label (GtkNotebook *Notebook, gint CurrentPage)
{
gchar BaseTitle[MAX_TAB_LABEL_LENGTH];
gint i = 0, j = 0;
while (FPROPS(CurrentPage, BaseName[i]) != '\0')
{
if (i < MAX_TAB_LABEL_LENGTH)
BaseTitle[j++] = FPROPS(CurrentPage, BaseName[i++]);
else
{
for (i = -3; i <= -1; i++) BaseTitle[i+j] = '.';
break;
}
}
BaseTitle[j] = '\0';
if (FPROPS(CurrentPage, Changed[0]))
{
if (!FPROPS(CurrentPage, ReadOnly))
{
gchar *Title;
Title = g_strconcat ("*", BaseTitle, NULL);
gtk_notebook_set_tab_label_text (Notebook, gtk_notebook_get_nth_page
(Notebook, CurrentPage), Title);
gtk_notebook_set_menu_label_text (Notebook, gtk_notebook_get_nth_page
(Notebook, CurrentPage), Title);
g_free (Title);
}
else
{
gchar *Title;
Title = g_strconcat ("RO *", BaseTitle, NULL);
gtk_notebook_set_tab_label_text (Notebook, gtk_notebook_get_nth_page
(Notebook, CurrentPage), Title);
gtk_notebook_set_menu_label_text (Notebook, gtk_notebook_get_nth_page
(Notebook, CurrentPage), Title);
g_free (Title);
}
}
else
{
if (FPROPS(CurrentPage, ReadOnly))
{
gchar *Title;
Title = g_strconcat ("RO ", BaseTitle, NULL);
gtk_notebook_set_tab_label_text (Notebook, gtk_notebook_get_nth_page
(Notebook, CurrentPage), Title);
gtk_notebook_set_menu_label_text (Notebook, gtk_notebook_get_nth_page
(Notebook, CurrentPage), Title);
g_free (Title);
}
else
{
gtk_notebook_set_tab_label_text (Notebook, gtk_notebook_get_nth_page
(Notebook, CurrentPage), BaseTitle);
gtk_notebook_set_menu_label_text (Notebook, gtk_notebook_get_nth_page
(Notebook, CurrentPage),
BaseTitle);
}
}
}
