GtkWidget *
make_families_menu ()
{
GtkWidget *combo;
int n_families;
PangoFontFamily **families;
GList *family_list = NULL;
int i;
pango_context_list_families (context, &families, &n_families);
qsort (families, n_families, sizeof(char *), cmp_families);
for (i=0; i<n_families; i++)
family_list = g_list_prepend (family_list, pango_font_family_get_name (families[i]));
family_list = g_list_reverse (family_list);
combo = gtk_combo_new ();
gtk_combo_set_popdown_strings (GTK_COMBO (combo), family_list);
gtk_combo_set_value_in_list (GTK_COMBO (combo), TRUE, FALSE);
gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (combo)->entry), FALSE);
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), pango_font_description_get_family(font_description));
gtk_signal_connect (GTK_OBJECT (GTK_COMBO (combo)->entry), "changed",
GTK_SIGNAL_FUNC (set_family), NULL);
g_list_free (family_list);
return combo;
}
static GtkWidget *
create_combo (void)
{
GList *cbitems;
GtkCombo *combo;
cbitems = NULL;
cbitems = g_list_append (cbitems, "item0");
cbitems = g_list_append (cbitems, "item1 item1");
cbitems = g_list_append (cbitems, "item2 item2 item2");
cbitems = g_list_append (cbitems, "item3 item3 item3 item3");
cbitems = g_list_append (cbitems, "item4 item4 item4 item4 item4");
cbitems = g_list_append (cbitems, "item5 item5 item5 item5 item5 item5");
cbitems = g_list_append (cbitems, "item6 item6 item6 item6 item6");
cbitems = g_list_append (cbitems, "item7 item7 item7 item7");
cbitems = g_list_append (cbitems, "item8 item8 item8");
cbitems = g_list_append (cbitems, "item9 item9");
combo = GTK_COMBO (gtk_combo_new ());
gtk_combo_set_popdown_strings (combo, cbitems);
gtk_entry_set_text (GTK_ENTRY (combo->entry), "hello world");
gtk_editable_select_region (GTK_EDITABLE (combo->entry), 0, -1);
return GTK_WIDGET (combo);
}
void create_combo_field(gchar *text, gboolean hidden)
{
GtkWidget *cbo_first, *label, *box;
cbo_first=gtk_combo_new();
//entry = gtk_entry_new();
if (!cbo_first) quit (RETURN_ERROR_NOMEM);
// if (hidden) gtk_entry_set_visibility ((GtkEntry*)entry, FALSE);
gtk_signal_connect ((GtkObject*)cbo_first, key_press_event,
GTK_SIGNAL_FUNC (keypress_cb), NULL);
if(text) {
box = gtk_hbox_new(FALSE, 1);
if (!box) quit (RETURN_ERROR_NOMEM);
#if GTK_MAJOR_VERSION < 2
label = gtk_label_new(text);
if (!label) quit (RETURN_ERROR_NOMEM);
#else
label = gtk_label_new_with_mnemonic(text);
if (!label) quit (RETURN_ERROR_NOMEM);
gtk_label_set_mnemonic_widget((GtkLabel *)label, entry);
#endif
gtk_box_pack_start((GtkBox *)box, label, FALSE, TRUE, 0);
gtk_box_pack_end((GtkBox *)box, cbo_first, FALSE, TRUE, 0);
add_to_vbox(box);
} else {
add_to_vbox(cbo_first);
}
widgets = g_slist_append(widgets, cbo_first);
};
/* Create the widgets that will be shown on the Config dialog, and also perform
* any other loading operations necessary.
*/
GtkWidget *preset_init(void)
{
GtkWidget *label;
/* Read the presets, unless we've already read them */
preset_read();
/* If the widgets already exist, then don't create them */
if (box)
{
/* but do adjust their states */
preset_adjust(FALSE);
return box;
}
/* Create the container */
box = gtk_hbox_new(FALSE, 0);
/*gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);*/
gtk_widget_show(box);
/* Add a label for the combo box */
label = gtk_label_new("Title: ");
gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
gtk_widget_show(label);
/* Add a combo box */
combo = gtk_combo_new();
gtk_signal_connect(GTK_OBJECT(GTK_COMBO(combo)->entry), "changed", GTK_SIGNAL_FUNC(combo_cb), NULL);
gtk_box_pack_start(GTK_BOX(box), combo, FALSE, FALSE, 0);
gtk_widget_show(combo);
/* Add a small label */
label = gtk_label_new(" ");
gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
gtk_widget_show(label);
/* Add the [Load] button */
load = gtk_button_new_with_label("Load");
gtk_signal_connect(GTK_OBJECT(load), "clicked", GTK_SIGNAL_FUNC(button_cb), NULL);
gtk_box_pack_start(GTK_BOX(box), load, TRUE, TRUE, 0);
gtk_widget_show(load);
/* Add the [Save] button */
save = gtk_button_new_with_label("Save");
gtk_signal_connect(GTK_OBJECT(save), "clicked", GTK_SIGNAL_FUNC(button_cb), NULL);
gtk_box_pack_start(GTK_BOX(box), save, TRUE, TRUE, 0);
gtk_widget_show(save);
/* Add the [Erase] button */
erase = gtk_button_new_with_label("Erase");
gtk_signal_connect(GTK_OBJECT(erase), "clicked", GTK_SIGNAL_FUNC(button_cb), NULL);
gtk_box_pack_start(GTK_BOX(box), erase, TRUE, TRUE, 0);
gtk_widget_show(erase);
/* Adjust the states of all controls */
preset_adjust(FALSE);
/* Return the container */
return box;
}
void ifselect(GtkWidget *widget,gpointer data)
{
gint i = 0;
GtkWidget *dialog;
GtkWidget *_hbox;
GtkWidget *label;
GList *glist=NULL;
GtkWidget *ifCombo;
dialog = gnome_dialog_new(_("Choose a interface to capture"),_("OK"),NULL,NULL);
_hbox = gtk_hbox_new(FALSE,0);
label = gtk_label_new("Choose an interface: ");
ifCombo = gtk_combo_new();
for (i = 0; i < ifnum; i++)
{
glist = g_list_append(glist, ifitem[i].ifname);
}
gtk_combo_set_popdown_strings( GTK_COMBO(ifCombo), glist);
gtk_box_pack_start(GTK_BOX(_hbox),label,FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(_hbox),ifCombo,FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(GNOME_DIALOG(dialog)->vbox),_hbox,TRUE,TRUE,0);
gtk_signal_connect(GTK_OBJECT(GTK_COMBO(ifCombo)->entry), "activate",
GTK_SIGNAL_FUNC (get_ifcard_str),NULL);
gtk_widget_show(ifCombo);
gtk_widget_show(label);
gtk_widget_show(_hbox);
gtk_signal_connect(GTK_OBJECT(dialog),"clicked",GTK_SIGNAL_FUNC(dialog_ok),&dialog);
gtk_window_set_modal(GTK_WINDOW(dialog),TRUE);
gtk_widget_show(dialog);
gnome_dialog_set_parent(GNOME_DIALOG(dialog),GTK_WINDOW(app));
}
static GtkWidget *get_video_channels_widget()
{
GtkWidget *vbox;
GList *channellist = NULL;
vbox = gtk_vbox_new(FALSE, 20);
if (channels)
{
int i;
for (i=0;channels[i];i++)
channellist = g_list_append(channellist, channels[i]->name);
}
channelcombo = gtk_combo_new();
if (channellist)
gtk_combo_set_popdown_strings (GTK_COMBO (channelcombo), channellist);
if (current_channel >= 0)
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channelcombo)->entry),
channels[current_channel]->name);
gtk_signal_connect(GTK_OBJECT(GTK_COMBO(channelcombo)->entry), "changed",
GTK_SIGNAL_FUNC (channel_changed), NULL);
gtk_box_pack_start(GTK_BOX(vbox), channelcombo, TRUE, FALSE, 0);
gtk_widget_show(channelcombo);
return vbox;
}
/**** Combo Simple constructor ****/
int
clip_GTK_COMBOSIMPLENEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
GtkWidget *wid = NULL;
GtkWidget *list, *popup;
C_widget *cwid;
C_widget *centry, *clist, *cpopup;
CHECKOPT(1, MAP_type_of_ClipVarType);
wid = gtk_combo_new();
if (!wid)
goto err;
cwid = _register_widget(ClipMachineMemory, wid, cv);
if (!cwid)
goto err;
cwid->objtype = GTK_WIDGET_COMBO_SIMPLE;
gtk_widget_destroy(GTK_COMBO(wid)->list);
gtk_widget_destroy(GTK_COMBO(wid)->button);
gtk_widget_destroy(GTK_COMBO(wid)->popup);
gtk_widget_destroy(GTK_COMBO(wid)->popwin);
list = gtk_list_new();
popup = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(popup), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(popup), list);
GTK_COMBO(wid)->list = list;
GTK_COMBO(wid)->popup = popup;
gtk_list_set_selection_mode(GTK_LIST(list), GTK_SELECTION_SINGLE);
gtk_signal_connect(GTK_OBJECT(list), "select-child", GSF(_combo_simple_list_select), wid);
gtk_signal_connect(GTK_OBJECT(GTK_COMBO(wid)->entry), "changed", GSF(_combo_simple_entry_change), wid);
gtk_signal_connect(GTK_OBJECT(GTK_COMBO(wid)->entry), "focus-out-event", GSF(_combo_simple_entry_focus_out), wid);
centry = _register_widget(ClipMachineMemory, GTK_COMBO(wid)->entry, NULL);
clist = _register_widget(ClipMachineMemory, GTK_COMBO(wid)->list, NULL);
cpopup = _register_widget(ClipMachineMemory, GTK_COMBO(wid)->popup, NULL);
if (centry)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_ENTRY, ¢ry->obj);
if (clist)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_LIST, &clist->obj);
if (cpopup)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_POPUP, &cpopup->obj);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
return 0;
err:
return 1;
}
_HYPlatformPullDown::_HYPlatformPullDown(void)
{
_HYPullDown * parent = (_HYPullDown*)this;
theMenu = gtk_combo_new ();
backFill = HYColorToGDKColor((_HYColor) {
255,255,255
});
gtk_combo_set_value_in_list (GTK_COMBO(theMenu),true,false);
gtk_container_add(GTK_CONTAINER(parent->parentWindow),theMenu);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(theMenu)->entry),false);
GList* children = gtk_container_get_children(GTK_CONTAINER(theMenu));
g_signal_connect (GTK_WIDGET(children->next->data),"event",(GCallback)hy_pulldown_selection_start_callback_event,(_HYPullDown*)this);
g_signal_connect (GTK_COMBO(theMenu)->entry,"changed",(GCallback)hy_pulldown_selection_callback,(_HYPullDown*)this);
g_signal_connect (GTK_COMBO(theMenu)->popwin,"hide",(GCallback)hy_pulldown_unmap_event,(_HYPullDown*)this);
g_list_free (children);
//gtk_container_set_resize_mode(GTK_CONTAINER(theMenu), GTK_RESIZE_IMMEDIATE);
selection = 0;
cbSelection = -1;
if (!defaultPullDownFontPD) {
defaultPullDownFontPD = pango_font_description_new();
defaultPullDownFont.size = defaultPullDownFont.size*fontConversionFactor;
HYFont2PangoFontDesc (defaultPullDownFont,defaultPullDownFontPD);
}
gtk_widget_modify_font (theMenu, defaultPullDownFontPD);
gtk_widget_modify_font (GTK_COMBO(theMenu)->entry, defaultPullDownFontPD);
gtk_widget_show (theMenu);
//g_signal_connect (GTK_COMBO(theMenu)->entry,"changed",hy_pulldown_selection_callback,(_HYPullDown*)this);
}
int doProperties() {
GtkWidget *optionsWindow;
optionsWindow = gtk_dialog_new_with_buttons("Properties",GTK_WINDOW(window),GTK_DIALOG_DESTROY_WITH_PARENT,GTK_STOCK_SAVE,
GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
NULL );
GtkWidget *vbox;
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(optionsWindow)->vbox), vbox);
gtk_window_set_modal(GTK_WINDOW(optionsWindow), TRUE);
gtk_window_set_keep_above(GTK_WINDOW(optionsWindow), TRUE);
GtkWidget* deviceLabel;
deviceLabel = gtk_label_new("Device");
gtk_box_pack_start(GTK_BOX(vbox),deviceLabel, FALSE, FALSE, 5);
GtkWidget *combo;
GList *items = NULL;
items = g_list_append (items, "/dev/ttyUSB0");
//items = g_list_append (items, "First Item");
combo = gtk_combo_new ();
gtk_combo_set_popdown_strings (GTK_COMBO (combo), items);
gtk_box_pack_start(GTK_BOX(vbox),combo, FALSE, FALSE, 5);
GtkWidget *timeSwitch;
timeSwitch = gtk_check_button_new_with_label("Display time");
gtk_box_pack_start(GTK_BOX(vbox),timeSwitch, FALSE, FALSE, 5);
gtk_widget_show_all(optionsWindow);
return 0;
}
static GtkWidget *toolbar_add_zoom(GtkWidget *box) // Add zoom combo box
{
int i;
static char *txt[] = { "10%", "20%", "25%", "33%", "50%", "100%",
"200%", "300%", "400%", "800%", "1200%", "1600%", "2000%", NULL };
GtkWidget *combo, *combo_entry;
GList *combo_list = NULL;
combo = gtk_combo_new();
gtk_combo_set_value_in_list (GTK_COMBO (combo), FALSE, FALSE);
gtk_widget_show (combo);
combo_entry = GTK_COMBO (combo)->entry;
GTK_WIDGET_UNSET_FLAGS (combo_entry, GTK_CAN_FOCUS);
gtk_widget_set_usize(GTK_COMBO(combo)->button, 18, -1);
#if GTK_MAJOR_VERSION == 1
gtk_widget_set_usize(combo, 75, -1);
#else /* #if GTK_MAJOR_VERSION == 2 */
gtk_entry_set_width_chars(GTK_ENTRY(combo_entry), 6);
#endif
gtk_entry_set_editable( GTK_ENTRY(combo_entry), FALSE );
for ( i=0; txt[i]; i++ ) combo_list = g_list_append( combo_list, txt[i] );
gtk_combo_set_popdown_strings( GTK_COMBO(combo), combo_list );
g_list_free( combo_list );
gtk_entry_set_text( GTK_ENTRY(combo_entry), "100%" );
pack(box, combo);
return (combo);
}
GtkWidget * AddComboBox( GtkWidget * parent )
{
GtkWidget * CB;
CB=gtk_combo_new();
gtk_widget_set_name( CB,"CB" );
gtk_widget_show( CB );
if ( parent ) gtk_box_pack_start( GTK_BOX( parent ),CB,TRUE,TRUE,0 );
return CB;
}
static GtkWidget *create_dialog_right()
{
GtkWidget *right;
GtkWidget *widget;
GtkWidget *vbox;
right = gtk_vbox_new(FALSE, 10);
/* save, apply, close, exit */
widget = gtk_button_new_with_mnemonic("_Apply");
g_signal_connect(G_OBJECT(widget), "clicked",
G_CALLBACK(callback_apply), NULL);
gtk_box_pack_start(GTK_BOX(right), widget, FALSE, FALSE, 0);
widget = gtk_button_new_with_mnemonic("_Close dialog");
g_signal_connect(G_OBJECT(widget), "clicked",
G_CALLBACK(callback_close), NULL);
gtk_box_pack_start(GTK_BOX(right), widget, FALSE, FALSE, 0);
widget = gtk_button_new_with_mnemonic("E_xit wmblob");
g_signal_connect(G_OBJECT(widget), "clicked",
G_CALLBACK(callback_exit), NULL);
gtk_box_pack_start(GTK_BOX(right), widget, FALSE, FALSE, 0);
widget = gtk_button_new_with_mnemonic("A_bout...");
g_signal_connect(G_OBJECT(widget), "clicked",
G_CALLBACK(callback_about), NULL);
gtk_box_pack_start(GTK_BOX(right), widget, FALSE, FALSE, 0);
/* preset stuff */
vbox = new_frame(right, "Presets");
widget = gtk_button_new_with_mnemonic("_Load");
g_signal_connect(G_OBJECT(widget), "clicked",
G_CALLBACK(callback_preset_load), NULL);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
widget = gtk_button_new_with_mnemonic("_Save");
g_signal_connect(G_OBJECT(widget), "clicked",
G_CALLBACK(callback_preset_save), NULL);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
widget = gtk_button_new_with_mnemonic("_Delete");
g_signal_connect(G_OBJECT(widget), "clicked",
G_CALLBACK(callback_preset_delete), NULL);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
wg_preset_list = gtk_combo_new();
fill_in_presets(wg_preset_list);
gtk_widget_set_size_request(wg_preset_list, 128, 20);
gtk_box_pack_start(GTK_BOX(vbox), wg_preset_list, FALSE, FALSE, 0);
return(right);
}
/*--------------------------------------------------------------------------*/
static void
add_select_download_page( GnomeDruid *wdruid, GdkPixbuf *logo )
{
GtkWidget *wvbox;
GdkColor druid_bg_color = DRUID_BG_COLOR;
GdkColor druid_title_color = DRUID_TITLE_COLOR;
GtkWidget *whbox, *wcombo;
GList *name_list = NULL;
GList *p;
Site *site;
gb_debug (DEBUG_UPDATE, "START");
download_page = gnome_druid_page_standard_new_with_vals (_("Select download site"),
logo,
NULL);
gnome_druid_page_standard_set_background(GNOME_DRUID_PAGE_STANDARD(download_page),
&druid_bg_color);
gnome_druid_page_standard_set_logo_background(GNOME_DRUID_PAGE_STANDARD(download_page),
&druid_bg_color);
gnome_druid_page_standard_set_title_foreground( GNOME_DRUID_PAGE_STANDARD(download_page),
&druid_title_color);
gnome_druid_append_page( wdruid, GNOME_DRUID_PAGE(download_page) );
wvbox = GNOME_DRUID_PAGE_STANDARD(download_page)->vbox;
whbox = gtk_hbox_new( FALSE, 10 );
gtk_container_set_border_width( GTK_CONTAINER(whbox), 20 );
gtk_box_pack_start( GTK_BOX(wvbox), whbox, TRUE, TRUE, 0 );
gtk_box_pack_start( GTK_BOX(whbox),
gtk_label_new( _("Download site:") ),
FALSE, TRUE, 0 );
if ( site_list == NULL ) {
site_list = read_site_list();
}
for ( p=site_list; p!= NULL; p=p->next ) {
site = (Site *)p->data;
name_list = g_list_append( name_list, site->name );
}
wcombo = gtk_combo_new();
gtk_combo_set_popdown_strings( GTK_COMBO(wcombo), name_list );
g_list_free( name_list );
name_list = NULL;
site_entry = GTK_COMBO(wcombo)->entry;
gtk_entry_set_editable( GTK_ENTRY(site_entry), FALSE );
gtk_box_pack_start( GTK_BOX(whbox), wcombo, TRUE, TRUE, 0 );
gb_debug (DEBUG_UPDATE, "END");
}
int gnoclComboCmd ( ClientData data, Tcl_Interp *interp,
int objc, Tcl_Obj * const objv[] )
{
ComboParams *para;
int ret;
if ( gnoclParseOptions ( interp, objc, objv, comboOptions )
!= TCL_OK )
{
gnoclClearOptions ( comboOptions );
return TCL_ERROR;
}
para = g_new ( ComboParams, 1 );
para->interp = interp;
para->combo = GTK_COMBO ( gtk_combo_new( ) );
para->variable = NULL;
para->onChanged = NULL;
para->inSetVar = 0;
ret = gnoclSetOptions ( interp, comboOptions,
G_OBJECT ( para->combo ), -1 );
if ( ret == TCL_OK )
ret = configure ( interp, para, comboOptions );
gnoclClearOptions ( comboOptions );
if ( ret != TCL_OK )
{
g_free ( para );
gtk_widget_destroy ( GTK_WIDGET ( para->combo ) );
return TCL_ERROR;
}
para->name = gnoclGetAutoWidgetId();
g_signal_connect ( G_OBJECT ( para->combo ), "destroy",
G_CALLBACK ( destroyFunc ), para );
gnoclMemNameAndWidget ( para->name, GTK_WIDGET ( para->combo ) );
gtk_widget_show ( GTK_WIDGET ( para->combo ) );
Tcl_CreateObjCommand ( interp, para->name, comboFunc, para, NULL );
Tcl_SetObjResult ( interp, Tcl_NewStringObj ( para->name, -1 ) );
return TCL_OK;
}
PRIVATE void init_combo( Control *control ) {
GtkCombo *cb;
cb = GTK_COMBO( gtk_combo_new() );
g_assert( cb != NULL );
gtk_combo_disable_activate( cb );
if( ((Data *)control->g->data)->list != NULL )
gtk_combo_set_popdown_strings( cb, ((Data *)control->g->data)->list );
gtk_signal_connect( GTK_OBJECT( cb->entry ), "activate", GTK_SIGNAL_FUNC(entry_activated), control );
control->widget = GTK_WIDGET(cb);
}
/* options dialog */
static void
wavelan_create_options (Control *ctrl, GtkContainer *con, GtkWidget *done)
{
t_wavelan *wavelan = (t_wavelan *)ctrl->data;
GtkWidget *hbox, *label, *interface, *vbox, *autohide;
GtkWidget *combo;
GList *interfaces, *lp;
vbox = gtk_vbox_new(FALSE, 2);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(con), vbox);
hbox = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox);
label = gtk_label_new(_("Interface"));
gtk_widget_show(label);
interfaces = wavelan_query_interfaces ();
combo = gtk_combo_new ();
gtk_combo_set_popdown_strings (GTK_COMBO (combo), interfaces);
gtk_widget_show (combo);
interface = GTK_COMBO (combo)->entry;
gtk_entry_set_max_length(GTK_ENTRY(interface), 10);
if (wavelan->interface != NULL)
gtk_entry_set_text(GTK_ENTRY(interface), wavelan->interface);
g_signal_connect(interface, "changed", G_CALLBACK(wavelan_interface_changed),
wavelan);
gtk_widget_show(interface);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(hbox), combo, TRUE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1);
hbox = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox);
autohide = gtk_check_button_new_with_mnemonic(_("_Autohide when offline"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(autohide), wavelan->autohide);
g_signal_connect(autohide, "toggled", G_CALLBACK(wavelan_autohide_changed),
wavelan);
gtk_widget_show(autohide);
gtk_box_pack_start(GTK_BOX(hbox), autohide, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1);
for (lp = interfaces; lp != NULL; lp = lp ->next)
g_free (lp->data);
g_list_free (interfaces);
}
/*
* Creates a new GtkWidget of class GtkCombo, performing any specialized
* initialization needed for the widget to work correctly in this environment.
* If a dialog box is used to initialize the widget, return NULL from this
* function, and call data->callback with your new widget when it is done.
* If the widget needs a special destroy handler, add a signal here.
*/
GtkWidget*
gb_combo_new(GbWidgetNewData *data)
{
GtkWidget *new_widget;
new_widget = gtk_combo_new ();
gb_widget_create_from (GTK_COMBO (new_widget)->entry,
data->action == GB_CREATING ? "combo-entry" : NULL);
gb_widget_set_child_name (GTK_COMBO (new_widget)->entry, ComboEntry);
/* This defaults to TRUE. */
gtk_object_set_data (GTK_OBJECT (new_widget), OKIfEmpty, "TRUE");
return new_widget;
}
void init_clients_g(t_gui *gui)
{
gui->opt.list.list_client = init_cl_list();
gui->opt.labels.nb_clients_l = gtk_label_new("Nombre clients : ");
gtk_fixed_put(GTK_FIXED(gui->opt.sys.frame),
gui->opt.labels.nb_clients_l, 30, 150);
gui->opt.combo.nb_clients = gtk_combo_new();
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(gui->opt.combo.nb_clients)->entry),
FALSE);
gtk_combo_set_popdown_strings(GTK_COMBO(gui->opt.combo.nb_clients),
gui->opt.list.list_client) ;
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(gui->opt.combo.nb_clients)->entry),
"1");
gtk_fixed_put(GTK_FIXED(gui->opt.sys.frame), gui->opt.combo.nb_clients,
150, 145);
}
static GtkWidget*
sw_make_sg(char *name, GtkSizeGroup *sg) {
SettingsWidget *sw = sw_lookup(name);
switch (sw->type) {
case SW_TOGGLE:
sw->widget = gtk_check_button_new_with_mnemonic(_(sw->caption));
toggle_tie(sw);
return sw->widget;
case SW_RADIO:
sw->widget = gtk_radio_button_new_with_mnemonic(NULL,
_(sw->caption));
radio_tie(sw);
return sw->widget;
case SW_TEXT:
sw->widget = gtk_entry_new();
text_tie(sw);
return labelled_box_new_sg(_(sw->caption), sw->widget, sg);
case SW_INTEGER:
sw->widget = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(sw->widget), 4);
integer_tie(sw);
return labelled_box_new(_(sw->caption), sw->widget);
case SW_SPIN_INTEGER:
{
gdouble default_value = *(gint*)sw->conf;
GtkObject *adj = gtk_adjustment_new(default_value,
/* client code should override these */
G_MINDOUBLE, G_MAXDOUBLE, 1.0, 1.0, 0);
sw->widget = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 1, 1);
}
spin_integer_tie(sw);
return labelled_box_new_expand(_(sw->caption), sw->widget, FALSE);
case SW_COMBO:
sw->widget = gtk_combo_new();
combo_tie(sw);
return labelled_box_new(_(sw->caption), sw->widget);
case SW_COMMAND:
return command_make(sw);
case SW_CUSTOM:
if (sw->caption && sw->widget)
return labelled_box_new(_(sw->caption), sw->widget);
break;
default:
break;
}
return NULL;
}
static GtkWidget *
make_styles_combo ()
{
GtkWidget *combo;
combo = gtk_combo_new ();
gtk_combo_set_value_in_list (GTK_COMBO (combo), TRUE, FALSE);
gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (combo)->entry), FALSE);
gtk_signal_connect (GTK_OBJECT (GTK_COMBO (combo)->entry), "changed",
GTK_SIGNAL_FUNC (set_style), NULL);
styles_combo = combo;
fill_styles_combo (combo);
return combo;
}
static void
limited_int_build(node_gui_t *ng, gboolean ishex)
{
unsigned long i;
GtkWidget *listw;
const GList *list;
ng->combo = gtk_combo_new();
gtk_combo_set_value_in_list(GTK_COMBO(ng->combo), TRUE, FALSE);
gtk_combo_set_use_arrows(GTK_COMBO(ng->combo), FALSE);
ng->entry = GTK_COMBO(ng->combo)->entry;
gtk_entry_set_editable(GTK_ENTRY(ng->entry), FALSE);
gtk_signal_connect(GTK_OBJECT(ng->entry), "changed",
GTK_SIGNAL_FUNC(on_limited_int_combo_changed), ng);
listw = GTK_COMBO(ng->combo)->list;
gtk_list_clear_items(GTK_LIST(listw), 0, -1);
list = cml_node_get_enumdefs(ng->node);
if (list != 0)
{
for ( ; list != 0 ; list = list->next)
{
cml_enumdef *ed = (cml_enumdef *)list->data;
add_list_entry(listw, cml_node_get_banner(ed->symbol), ed->value);
}
}
else
{
for (list = cml_node_get_range(ng->node) ; list != 0 ; list = list->next)
{
cml_subrange *sr = (cml_subrange *)list->data;
for (i = sr->begin ; i <= sr->end ; i++)
{
char valuebuf[32];
sprintf(valuebuf, (ishex ? "0x%lX" : "%ld"), i);
add_list_entry(listw, valuebuf, i);
}
}
}
node_gui_attach_widget(ng, ng->combo, VALUE);
}
int main (int argc, char *argv[])
{
GtkWidget *ventana;
GtkWidget *boton;
GtkWidget *entrada;
GtkWidget *caja;
GtkWidget *combo;
GtkWidget *spinner;
GtkAdjustment *ajuste;
GList *opciones;
gtk_init(&argc, &argv);
ventana = gtk_window_new(GTK_WINDOW_TOPLEVEL);
boton = gtk_button_new_with_label("Click me");
caja = gtk_vbox_new(TRUE,2);
entrada = gtk_entry_new();
combo = gtk_combo_new();
ajuste = (GtkAdjustment *)gtk_adjustment_new(1.0, -100.0, 100.0, 0.5,
10.0, 0.0);
spinner = gtk_spin_button_new(ajuste, 1, 1);
opciones = NULL;
opciones = g_list_append(opciones, "Opcion 1");
opciones = g_list_append(opciones, "Opcion 2");
opciones = g_list_append(opciones, "Opcion 3");
opciones = g_list_append(opciones, "Opcion 4");
gtk_combo_set_popdown_strings ((GtkCombo *)combo, opciones);
gtk_box_pack_start ((GtkBox *) caja, entrada, TRUE, TRUE, 2);
gtk_box_pack_start ((GtkBox *) caja, combo, TRUE, TRUE, 2);
gtk_box_pack_start ((GtkBox *) caja, spinner, TRUE, TRUE, 2);
gtk_box_pack_start ((GtkBox *) caja, boton, TRUE, TRUE, 2);
gtk_container_add((GtkContainer *)ventana, caja);
gtk_widget_show_all(ventana);
gtk_main();
return 0;
}
/**** Combo box constructor ****/
int
clip_GTK_COMBONEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
GtkWidget *wid = NULL;
C_widget *cwid;
C_widget *centry, *clist, *cbutton, *cpopup, *cpopwin;
CHECKOPT(1, MAP_type_of_ClipVarType);
wid = gtk_combo_new();
if (!wid)
goto err;
cwid = _register_widget(ClipMachineMemory, wid, cv);
centry = _register_widget(ClipMachineMemory, GTK_COMBO(wid)->entry, NULL);
clist = _register_widget(ClipMachineMemory, GTK_COMBO(wid)->list, NULL);
cbutton = _register_widget(ClipMachineMemory, GTK_COMBO(wid)->button, NULL);
cpopup = _register_widget(ClipMachineMemory, GTK_COMBO(wid)->popup, NULL);
cpopwin = _register_widget(ClipMachineMemory, GTK_COMBO(wid)->popwin, NULL);
if (centry)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_ENTRY, ¢ry->obj);
if (clist)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_LIST, &clist->obj);
if (cbutton)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_BUTTON, &cbutton->obj);
if (cpopup)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_POPUP, &cpopup->obj);
if (cpopwin)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_POPWIN, &cpopwin->obj);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
return 0;
err:
return 1;
}
static void
mood_add(JamView *view) {
moodpic_add(view);
/*view->moodbutton = gtk_button_new_with_label(_("Mood"));
gtk_size_group_add_widget(view->sizegroup, view->moodbutton);*/
view->moodcombo = gtk_combo_new();
gtk_widget_set_usize(GTK_COMBO(view->moodcombo)->entry, 100, -1);
mood_populate(view);
/*view->moodbox = gtk_hbox_new(FALSE, 12);
gtk_box_pack_start(GTK_BOX(view->moodbox), view->moodbutton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(view->moodbox), view->moodcombo, TRUE, TRUE, 0);*/
view->moodbox = labelled_box_new_sg(_("_Mood:"), view->moodcombo, view->sizegroup),
gtk_widget_show_all(view->moodbox);
gtk_box_pack_start(GTK_BOX(view->moodpicbar), view->moodbox, TRUE, TRUE, 0);
if (view->pic)
gtk_box_reorder_child(GTK_BOX(view->moodpicbar), view->moodbox, 0);
}
void
stpui_create_new_combo(option_t *option, GtkWidget *table,
int hpos, int vpos, gboolean is_optional)
{
GtkWidget *event_box = gtk_event_box_new();
GtkWidget *combo = gtk_combo_new();
option->checkbox = gtk_check_button_new();
gtk_table_attach(GTK_TABLE(table), option->checkbox,
hpos, hpos + 1, vpos, vpos + 1,
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
option->info.list.combo = combo;
gtk_container_add(GTK_CONTAINER(event_box), combo);
gtk_widget_show(combo);
gtk_widget_show(event_box);
stpui_set_help_data(event_box, gettext(option->fast_desc->help));
stpui_table_attach_aligned
(GTK_TABLE(table), hpos + 1, vpos, gettext(option->fast_desc->text),
0.0, 0.5, event_box, 2, TRUE);
option->info.list.label = table_label(GTK_TABLE(table), hpos, vpos);
}
GtkWidget* CreateFileCombo(const char* entryText)
{
GList* list = NULL;
list = g_list_append(list, strdup(entryText));
for (int i = 0; i < NUM_FILE_HISTORY; i++) {
const char* fileName =
MyConfig->GetStringValue(CONFIG_APP_FILE_0 + i);
if (fileName == NULL || fileName[0] == '\0'
|| !strcmp(fileName, entryText)) {
continue;
}
list = g_list_append(list, strdup(fileName));
}
GtkWidget* combo = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo), list);
gtk_combo_set_use_arrows_always(GTK_COMBO(combo), 1);
GtkWidget* entry = GTK_COMBO(combo)->entry;
gtk_entry_set_text(GTK_ENTRY(entry), entryText);
return combo;
}
gpointer gui_pulldown_new(const gchar *text, GList *list, gint edit, GtkWidget *box)
{
GtkWidget *hbox, *label, *combo;
combo = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo), list);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo)->entry), edit);
if (box)
{
/* create the text/spinner layout */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 0);
if (text)
{
label = gtk_label_new(text);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(hbox), combo, FALSE, FALSE, 0);
}
else
gtk_box_pack_end(GTK_BOX(hbox), combo, TRUE, TRUE, 0);
}
return(GTK_COMBO(combo)->entry);
}
GtkWidget*
create_win_main (void)
{
GtkWidget *win_main;
GtkWidget *vbox1;
GtkWidget *table1;
GtkWidget *vbox2;
GtkWidget *label_lang;
GtkWidget *combo1;
GtkWidget *combo_lang;
GtkWidget *vbox3;
GtkWidget *label_keyb;
GtkWidget *combo2;
GtkWidget *combo_keyb;
GtkWidget *pixmap1;
GtkWidget *pixmap2;
GtkWidget *hbuttonbox1;
guint button_ok_key;
GtkWidget *button_ok;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new ();
win_main = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (win_main, "win_main");
gtk_object_set_data (GTK_OBJECT (win_main), "win_main", win_main);
gtk_window_set_title (GTK_WINDOW (win_main), _("dyne:bolic :: lost in babylon"));
gtk_window_set_position (GTK_WINDOW (win_main), GTK_WIN_POS_CENTER);
gtk_window_set_policy (GTK_WINDOW (win_main), FALSE, FALSE, FALSE);
gtk_window_set_wmclass (GTK_WINDOW (win_main), "babylon", "dynebolic");
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox1, "vbox1");
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (win_main), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (win_main), vbox1);
table1 = gtk_table_new (2, 2, FALSE);
gtk_widget_set_name (table1, "table1");
gtk_widget_ref (table1);
gtk_object_set_data_full (GTK_OBJECT (win_main), "table1", table1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox1), table1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table1), 5);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox2, "vbox2");
gtk_widget_ref (vbox2);
gtk_object_set_data_full (GTK_OBJECT (win_main), "vbox2", vbox2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox2);
gtk_table_attach (GTK_TABLE (table1), vbox2, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 10);
label_lang = gtk_label_new (_("Choose your language:"));
gtk_widget_set_name (label_lang, "label_lang");
gtk_widget_ref (label_lang);
gtk_object_set_data_full (GTK_OBJECT (win_main), "label_lang", label_lang,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_lang);
gtk_box_pack_start (GTK_BOX (vbox2), label_lang, FALSE, FALSE, 0);
combo1 = gtk_combo_new ();
gtk_widget_set_name (combo1, "combo1");
gtk_widget_ref (combo1);
gtk_object_set_data_full (GTK_OBJECT (win_main), "combo1", combo1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (combo1);
gtk_box_pack_start (GTK_BOX (vbox2), combo1, FALSE, FALSE, 0);
combo_lang = GTK_COMBO (combo1)->entry;
gtk_widget_set_name (combo_lang, "combo_lang");
gtk_widget_ref (combo_lang);
gtk_object_set_data_full (GTK_OBJECT (win_main), "combo_lang", combo_lang,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (combo_lang);
gtk_entry_set_editable (GTK_ENTRY (combo_lang), FALSE);
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox3, "vbox3");
gtk_widget_ref (vbox3);
gtk_object_set_data_full (GTK_OBJECT (win_main), "vbox3", vbox3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox3);
gtk_table_attach (GTK_TABLE (table1), vbox3, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox3), 10);
label_keyb = gtk_label_new (_("Choose your keyboard layout:"));
gtk_widget_set_name (label_keyb, "label_keyb");
gtk_widget_ref (label_keyb);
gtk_object_set_data_full (GTK_OBJECT (win_main), "label_keyb", label_keyb,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_keyb);
gtk_box_pack_start (GTK_BOX (vbox3), label_keyb, FALSE, FALSE, 0);
combo2 = gtk_combo_new ();
gtk_widget_set_name (combo2, "combo2");
gtk_widget_ref (combo2);
gtk_object_set_data_full (GTK_OBJECT (win_main), "combo2", combo2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (combo2);
gtk_box_pack_start (GTK_BOX (vbox3), combo2, FALSE, FALSE, 0);
combo_keyb = GTK_COMBO (combo2)->entry;
gtk_widget_set_name (combo_keyb, "combo_keyb");
gtk_widget_ref (combo_keyb);
gtk_object_set_data_full (GTK_OBJECT (win_main), "combo_keyb", combo_keyb,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (combo_keyb);
gtk_entry_set_editable (GTK_ENTRY (combo_keyb), FALSE);
pixmap1 = create_pixmap (win_main, "locale.xpm");
gtk_widget_set_name (pixmap1, "pixmap1");
gtk_widget_ref (pixmap1);
gtk_object_set_data_full (GTK_OBJECT (win_main), "pixmap1", pixmap1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pixmap1);
gtk_table_attach (GTK_TABLE (table1), pixmap1, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
pixmap2 = create_pixmap (win_main, "charselect.xpm");
gtk_widget_set_name (pixmap2, "pixmap2");
gtk_widget_ref (pixmap2);
gtk_object_set_data_full (GTK_OBJECT (win_main), "pixmap2", pixmap2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pixmap2);
gtk_table_attach (GTK_TABLE (table1), pixmap2, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_set_name (hbuttonbox1, "hbuttonbox1");
gtk_widget_ref (hbuttonbox1);
gtk_object_set_data_full (GTK_OBJECT (win_main), "hbuttonbox1", hbuttonbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox1, FALSE, FALSE, 0);
button_ok = gtk_button_new_with_label ("");
button_ok_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (button_ok)->child),
_("_Ok"));
gtk_widget_add_accelerator (button_ok, "clicked", accel_group,
button_ok_key, GDK_MOD1_MASK, (GtkAccelFlags) 0);
gtk_widget_set_name (button_ok, "button_ok");
gtk_widget_ref (button_ok);
gtk_object_set_data_full (GTK_OBJECT (win_main), "button_ok", button_ok,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_ok);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), button_ok);
gtk_container_set_border_width (GTK_CONTAINER (button_ok), 3);
GTK_WIDGET_SET_FLAGS (button_ok, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (win_main), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
gtk_signal_connect (GTK_OBJECT (combo1), "realize",
GTK_SIGNAL_FUNC (on_combo1_realize),
NULL);
gtk_signal_connect (GTK_OBJECT (combo_lang), "changed",
GTK_SIGNAL_FUNC (on_combo_lang_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (combo2), "realize",
GTK_SIGNAL_FUNC (on_combo2_realize),
NULL);
gtk_signal_connect (GTK_OBJECT (combo_keyb), "changed",
GTK_SIGNAL_FUNC (on_combo_keyb_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (button_ok), "released",
GTK_SIGNAL_FUNC (on_button_ok_released),
NULL);
gtk_window_add_accel_group (GTK_WINDOW (win_main), accel_group);
return win_main;
}
void
start(void* v)
{
GtkWidget *scrolled_win, *tree, *hpanes, *vbox, *menu, *list;
/*static gchar *itemnames[] = {"One", "Two", "Three", "Four", "Five"};*/
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
gint nmenu_items;
gint i;
GtkWidget *table;
GtkWidget *name_label, *info_vbox;
GtkWidget *type_label;
GtkWidget *annot_label, *annot_hbox, *annot_vscroll;
GtkWidget *sep1;
GtkWidget *props_hbox, *props_scrollwin;
GtkWidget *menu_item;
gtk_init (&SFE_Globals.ArgC, &SFE_Globals.ArgV);
SFE_Globals.Data = stCreateStruct("new","x-unknown/x-unknown");
SFE_Globals.Modified = 0;
SFE_Globals.HideColTitles = 0;
/* a generic toplevel window */
SFE_Globals.Window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(SFE_Globals.Window), "Centrallix Structure File Editor");
gtk_signal_connect (GTK_OBJECT(SFE_Globals.Window), "delete_event", GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
gtk_widget_set_usize(SFE_Globals.Window, 600, 350);
/** Build the Open File... dialog box **/
SFE_Globals.OpenDialog = gtk_file_selection_new("Open File...");
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(SFE_Globals.OpenDialog)->cancel_button),
"clicked", (GtkSignalFunc)sfe_ui_FileOpenCancel, GTK_OBJECT(SFE_Globals.OpenDialog));
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(SFE_Globals.OpenDialog)->ok_button),
"clicked", (GtkSignalFunc)sfe_ui_FileOpenOk, GTK_OBJECT(SFE_Globals.OpenDialog));
/* vertical box organizing the menu vs. rest of app */
vbox = gtk_vbox_new(FALSE,1);
gtk_container_add(GTK_CONTAINER(SFE_Globals.Window), vbox);
gtk_widget_show(vbox);
/* menu */
nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
accel_group = gtk_accel_group_new();
item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);
gtk_window_add_accel_group(GTK_WINDOW(SFE_Globals.Window), accel_group);
menu = gtk_item_factory_get_widget(item_factory, "<main>");
gtk_box_pack_start(GTK_BOX(vbox), menu, FALSE, TRUE, 0);
/*menu_item = gtk_item_factory_get_widget(GTK_ITEM_FACTORY(item_factory),"/View/Column Titles");
gtk_menu_item_activate(GTK_MENU_ITEM(menu_item));*/
gtk_widget_show(menu);
/* horizontal layout box organizing the treeview and the data view pane */
hpanes = gtk_hpaned_new();
gtk_container_add(GTK_CONTAINER(vbox), hpanes);
gtk_container_set_border_width (GTK_CONTAINER(hpanes), 5);
gtk_paned_set_gutter_size(GTK_PANED(hpanes), 16);
gtk_widget_show(hpanes);
/* A generic scrolled window - for the treeview. */
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_usize (scrolled_win, 150, 200);
gtk_container_add (GTK_CONTAINER(hpanes), scrolled_win);
gtk_widget_show (scrolled_win);
/* Create the root tree and add it to the scrolled window */
tree = gtk_tree_new();
gtk_signal_connect (GTK_OBJECT(tree), "select_child",
GTK_SIGNAL_FUNC(cb_select_child), tree);
gtk_signal_connect (GTK_OBJECT(tree), "unselect_child",
GTK_SIGNAL_FUNC(cb_unselect_child), tree);
gtk_signal_connect (GTK_OBJECT(tree), "selection_changed",
GTK_SIGNAL_FUNC(sfe_ui_TreeSelectionChanged), tree);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_win), tree);
gtk_tree_set_selection_mode (GTK_TREE(tree), GTK_SELECTION_SINGLE);
gtk_tree_set_view_mode(GTK_TREE(tree), GTK_TREE_VIEW_ITEM);
gtk_widget_show (tree);
SFE_Globals.TreeView = tree;
/** build the item name section **/
info_vbox = gtk_vbox_new(FALSE,1);
gtk_container_add(GTK_CONTAINER(hpanes), info_vbox);
gtk_widget_show(info_vbox);
table = gtk_table_new(3,2,FALSE);
gtk_box_pack_start(GTK_BOX(info_vbox), table, FALSE, TRUE, 0);
gtk_widget_show(table);
name_label = gtk_label_new("Name:");
gtk_label_set_justify(GTK_LABEL(name_label), GTK_JUSTIFY_LEFT);
gtk_table_attach(GTK_TABLE(table), name_label, 0, 1, 0, 1, 0, 0, 0, 0);
gtk_widget_show(name_label);
SFE_Globals.NameEdit = gtk_entry_new_with_max_length(63);
gtk_table_attach(GTK_TABLE(table), SFE_Globals.NameEdit, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0, 0);
gtk_widget_show(SFE_Globals.NameEdit);
/** Item type **/
type_label = gtk_label_new("Type:");
gtk_label_set_justify(GTK_LABEL(type_label), GTK_JUSTIFY_LEFT);
gtk_table_attach(GTK_TABLE(table), type_label, 0, 1, 1, 2, 0, 0, 0, 0);
gtk_widget_show(type_label);
SFE_Globals.TypeCombo = gtk_combo_new();
gtk_table_attach(GTK_TABLE(table), SFE_Globals.TypeCombo, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0, 8);
gtk_widget_show(SFE_Globals.TypeCombo);
/** Annotation/description/comments section **/
annot_label = gtk_label_new("Desc:");
gtk_label_set_justify(GTK_LABEL(annot_label), GTK_JUSTIFY_LEFT);
gtk_table_attach(GTK_TABLE(table), annot_label, 0, 1, 2, 3, 0, 0, 0, 0);
gtk_widget_show(annot_label);
annot_hbox = gtk_hbox_new(FALSE,1);
gtk_table_attach(GTK_TABLE(table), annot_hbox, 1, 2, 2, 3, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0, 0);
gtk_widget_show(annot_hbox);
SFE_Globals.AnnotText = gtk_text_new(NULL,NULL);
gtk_text_set_editable(GTK_TEXT(SFE_Globals.AnnotText), TRUE);
gtk_widget_set_usize(SFE_Globals.AnnotText, 100, 48);
gtk_container_add(GTK_CONTAINER(annot_hbox), SFE_Globals.AnnotText);
gtk_widget_show(SFE_Globals.AnnotText);
annot_vscroll = gtk_vscrollbar_new(GTK_TEXT(SFE_Globals.AnnotText)->vadj);
gtk_box_pack_end(GTK_BOX(annot_hbox), annot_vscroll, FALSE, TRUE, 0);
gtk_widget_show(annot_vscroll);
sep1 = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(info_vbox), sep1, FALSE, TRUE, 8);
gtk_widget_show(sep1);
/** Add a columnar list box for the attributes **/
props_scrollwin = gtk_scrolled_window_new(NULL,NULL);
gtk_container_add(GTK_CONTAINER(info_vbox), props_scrollwin);
gtk_widget_show(props_scrollwin);
SFE_Globals.AttrsCList = gtk_clist_new_with_titles(2, props_clist_titles);
gtk_clist_set_selection_mode(GTK_CLIST(SFE_Globals.AttrsCList), GTK_SELECTION_SINGLE);
gtk_container_add(GTK_CONTAINER(props_scrollwin), SFE_Globals.AttrsCList);
gtk_widget_show(SFE_Globals.AttrsCList);
gtk_signal_connect (GTK_OBJECT(SFE_Globals.AttrsCList), "select_row",
GTK_SIGNAL_FUNC(sfe_ui_CListAttrSelected), SFE_Globals.AttrsCList);
#if 0
/** Put some cruft in the treeview **/
for (i = 0; i < 5; i++)
{
GtkWidget *subtree, *item;
gint j;
/* Create a tree item */
item = gtk_tree_item_new_with_label (itemnames[i]);
/* Add it to the parent tree */
gtk_tree_append (GTK_TREE(tree), item);
gtk_widget_show (item);
subtree = gtk_tree_new();
/* This is still necessary if you want these signals to be called
* for the subtree's children. Note that selection_change will be
* signalled for the root tree regardless.
*/
gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
GTK_SIGNAL_FUNC(cb_select_child), subtree);
gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
GTK_SIGNAL_FUNC(cb_unselect_child), subtree);
/* Set this item's subtree - note that you cannot do this until
* AFTER the item has been added to its parent tree!
*/
gtk_tree_item_set_subtree (GTK_TREE_ITEM(item), subtree);
for (j = 0; j < 5; j++)
{
GtkWidget *subitem;
/* Create a subtree item, in much the same way */
subitem = gtk_tree_item_new_with_label (itemnames[j]);
gtk_tree_append (GTK_TREE(subtree), subitem);
gtk_widget_show (subitem);
}
}
#endif
/** Open the main window **/
gtk_widget_show (SFE_Globals.Window);
/** Load any file specified on the command line **/
if (SFE_Globals.ArgC == 2 && SFE_Globals.ArgV[1])
sfeLoadFile(SFE_Globals.ArgV[1]);
else
sfeRebuildUI(SFE_Globals.Data, GTK_TREE(tree));
/** Create the attribute editing window **/
SFE_Globals.AttrEditWindow = sfe_ui_CreateAttrDialog();
/** Enter the event loop for GTK **/
gtk_main();
thExit();
}
void create_window(int *argc, char ***argv)
{
GList *gtk_baud_list=NULL;
int i;
gtk_init(argc, argv);
firmware_label = gtk_label_new("Firmware:");
gtk_label_set_justify(GTK_LABEL(firmware_label), GTK_JUSTIFY_RIGHT);
gtk_widget_show(firmware_label);
firmware_entry = gtk_entry_new();
gtk_widget_set_usize(firmware_entry, 110, 0);
gtk_entry_set_text(GTK_ENTRY(firmware_entry), file_setting());
gtk_widget_show(firmware_entry);
program_button = gtk_button_new_with_label("Program Now");
if (file_exists(file_setting())) {
gtk_widget_set_sensitive(program_button, TRUE);
} else {
gtk_widget_set_sensitive(program_button, FALSE);
}
gtk_widget_show(program_button);
line1_hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(line1_hbox), firmware_label, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(line1_hbox), firmware_entry, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(line1_hbox), program_button, FALSE, FALSE, 2);
gtk_widget_show(line1_hbox);
port_label = gtk_label_new("Port:");
gtk_label_set_justify(GTK_LABEL(port_label), GTK_JUSTIFY_RIGHT);
gtk_widget_show(port_label);
port_entry = gtk_entry_new();
gtk_widget_set_usize(port_entry, 80, 0);
gtk_entry_set_text(GTK_ENTRY(port_entry), port_setting());
open_serial_port(port_setting());
gtk_widget_show(port_entry);
baud_label = gtk_label_new("Baud:");
gtk_label_set_justify(GTK_LABEL(baud_label), GTK_JUSTIFY_RIGHT);
gtk_widget_show(baud_label);
baud_combo = gtk_combo_new();
for (i=0; baud_list[i] != NULL; i++) {
gtk_baud_list = g_list_append(gtk_baud_list, baud_list[i]);
}
gtk_combo_set_popdown_strings(GTK_COMBO(baud_combo), gtk_baud_list);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(baud_combo)->entry), FALSE);
gtk_widget_set_usize(baud_combo, 75, 0);
for (i=0; baud_list[i] != NULL; i++) {
if (strcmp(baud_list[i], baud_setting()) == 0) {
gtk_list_select_item(GTK_LIST(GTK_COMBO(baud_combo)->list), i);
break;
}
}
gtk_widget_show(baud_combo);
line2_hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(line2_hbox), port_label, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(line2_hbox), port_entry, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(line2_hbox), baud_label, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(line2_hbox), baud_combo, FALSE, FALSE, 2);
gtk_widget_show(line2_hbox);
crystal_label = gtk_label_new("Crystal:");
gtk_label_set_justify(GTK_LABEL(crystal_label), GTK_JUSTIFY_RIGHT);
gtk_widget_show(crystal_label);
crystal_entry = gtk_entry_new();
gtk_widget_set_usize(crystal_entry, 80, 0);
gtk_entry_set_text(GTK_ENTRY(crystal_entry), crystal_setting());
gtk_widget_show(crystal_entry);
mhz_label = gtk_label_new("(MHz)");
gtk_label_set_justify(GTK_LABEL(mhz_label), GTK_JUSTIFY_LEFT);
gtk_widget_show(mhz_label);
line3_hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(line3_hbox), crystal_label, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(line3_hbox), crystal_entry, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(line3_hbox), mhz_label, FALSE, FALSE, 2);
gtk_widget_show(line3_hbox);
reboot_button = gtk_button_new_with_label("Reboot");
gtk_widget_set_sensitive(reboot_button, TRUE);
gtk_widget_show(reboot_button);
bootloader_button = gtk_button_new_with_label("Booloader");
gtk_widget_show(bootloader_button);
quit_button = gtk_button_new_with_label("Quit");
gtk_widget_show(quit_button);
line4_hbox = gtk_hbox_new(TRUE, 2);
gtk_box_pack_start(GTK_BOX(line4_hbox), reboot_button, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(line4_hbox), bootloader_button, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(line4_hbox), quit_button, TRUE, TRUE, 2);
gtk_widget_show(line4_hbox);
main_vbox = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(main_vbox), line1_hbox, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(main_vbox), line2_hbox, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(main_vbox), line3_hbox, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(main_vbox), line4_hbox, TRUE, TRUE, 2);
gtk_widget_show(main_vbox);
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_add(GTK_CONTAINER(main_window), main_vbox);
gtk_widget_show(main_window);
}
