예제 #1
0
파일: srv-prop.c 프로젝트: IR4T4/xqf
void combo_set_vals (GtkWidget *combo, GList *strlist, const char *str) {

	g_return_if_fail(GTK_IS_COMBO(combo));

	if (!strlist) {
		gtk_list_clear_items (GTK_LIST (GTK_COMBO (combo)->list), 0, -1);
	} else {
		/*
		 *  gtk_combo_set_popdown_strings (actually gtk_list_insert_items) 
		 *  automatically selects the first one and puts it into entry.  
		 *  That should not happen.  Drop selection mode for a moment 
		 *  to prevent that.
		 */

		gtk_list_set_selection_mode (GTK_LIST (GTK_COMBO (combo)->list),
				GTK_SELECTION_SINGLE);
		gtk_combo_set_popdown_strings (GTK_COMBO (combo), strlist);
		gtk_list_set_selection_mode (GTK_LIST (GTK_COMBO (combo)->list),
				GTK_SELECTION_BROWSE);
	}

	if (str) {
		gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), str);
		gtk_entry_set_position (GTK_ENTRY (GTK_COMBO (combo)->entry), 0);
	}
	else {
		gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), "");
	}
}
예제 #2
0
PRIVATE void refresh_combo(Control *control) {
    Data *data = control->g->data;

    if( ((Data *)control->g->data)->list != NULL )
	gtk_combo_set_popdown_strings( GTK_COMBO(control->widget), data->list );

}
예제 #3
0
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);
}
예제 #4
0
int GetPrinterToGList(const char* combo_name)
{
	PrintersInfo* printers = NULL;
	GList* list = NULL;
	GtkWidget *combo = NULL, *entry = NULL;
	PrinterInfo* info = NULL;
	int i = 0;

	printers = g_printers;
	if(NULL == printers){
		if(GetAllPrinters() < 0){
			return -1;
		}
		printers = g_printers;
	}

	for(i = 0; i < g_list_length(printers->printer_list); i++){
		info = (PrinterInfo*)g_list_nth_data(printers->printer_list, i);
		if(info != NULL){
			list = g_list_append(list, info->name);
		}
	}
	combo = glade_xml_get_widget(g_main_xml, combo_name);
	if(combo != NULL){
		entry = GTK_COMBO(combo)->entry;
	}

	if(list != NULL){
		gtk_combo_set_popdown_strings(GTK_COMBO(combo), list);
		gtk_entry_set_text(GTK_ENTRY(entry), printers->curr_printer->name);
		g_list_free(list);
	}
	return 0;
}
예제 #5
0
파일: viewer.c 프로젝트: testfarm/testfarm
static void search_text(viewer_t *viewer, int from_start)
{
  char *text = (char *) gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(viewer->search_combo)->entry));
  int info_only = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(viewer->search_info));
  int case_sensitive = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(viewer->search_case));
  GList *item;

  if ( *text == '\0' )
    return;

  item = g_list_find_custom(viewer->search_list, text, (GCompareFunc) strcmp);
  if ( item == NULL ) {
    text = strdup(text);
  }
  else {
    text = g_list_nth_data(item, 0);
    viewer->search_list = g_list_remove(viewer->search_list, text);
  }

  viewer->search_list = g_list_prepend(viewer->search_list, text);

  gtk_combo_set_popdown_strings(GTK_COMBO(viewer->search_combo), viewer->search_list) ;
  gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(viewer->search_combo)->entry), text);

  gdk_window_set_cursor(viewer->window->window, viewer->cursor_watch);
  gdk_flush();

  list_search_text(viewer->list, text, from_start, info_only, case_sensitive);

  gdk_window_set_cursor(viewer->window->window, NULL);
}
예제 #6
0
GtkWidget *
TPCCTableProps_new (test_t * lpBench)
{
  TPCCTableProps *newdlg =
      TPCC_TABLE_PROPS (gtk_type_new (TPCCTableProps_get_type ()));
  ServerDSN *dsn;
  int inx;

  newdlg->lpBench = lpBench;
  dsn = SERVER_DSN (newdlg->dsn = ServerDSN_new (lpBench));
  gtk_signal_connect (GTK_OBJECT (newdlg->dsn), "dsns_changed",
      GTK_SIGNAL_FUNC (set_dsn_combos), newdlg->combos);

  for (inx = 0; inx < 9; inx++)
    {
      if (dsn->dsn_info.dsns)
	gtk_combo_set_popdown_strings (GTK_COMBO (newdlg->combos[inx]),
	    dsn->dsn_info.dsns);
      gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (newdlg->combos[inx])->entry),
	  lpBench->tpc.c.tableDSNS[inx]);
    }
  gtk_spin_button_set_value (GTK_SPIN_BUTTON (newdlg->n_ware),
      newdlg->lpBench->tpc.c.count_ware);
  return (GTK_WIDGET (newdlg));
}
예제 #7
0
파일: schema.c 프로젝트: jakob/mdbtools
void 
gmdb_schema_new_cb(GtkWidget *w, gpointer data) 
{
	GList *glist = NULL;
	GtkWidget *combo;
	MdbCatalogEntry *entry;
	int i;
   
	/* load the interface */
	schemawin_xml = glade_xml_new(GMDB_GLADEDIR "gmdb-schema.glade", NULL, NULL);
	/* connect the signals in the interface */
	glade_xml_signal_autoconnect(schemawin_xml);
	/* set up capabilities call back. TODO: autoconnect should do that */
	combo = glade_xml_get_widget(schemawin_xml, "combo-list2");
	g_signal_connect( G_OBJECT (combo), "selection_changed",
		G_CALLBACK(gmdb_schema_capabilities_cb), schemawin_xml);
	
	/* set signals with user data, anyone know how to do this in glade? */
	combo = glade_xml_get_widget (schemawin_xml, "table_combo");

	glist = g_list_append(glist, ALL_TABLES);
	/* add all user tables in catalog to list */
	for (i=0; i < mdb->num_catalog; i++) {
		entry = g_ptr_array_index (mdb->catalog, i);
		if (mdb_is_user_table(entry)) {
			glist = g_list_append(glist, entry->object_name);
		}
	} /* for */
	gtk_combo_set_popdown_strings(GTK_COMBO(combo), glist);
	g_list_free(glist);

	check_default_options();
	refresh_available_options();
}
예제 #8
0
파일: url.c 프로젝트: C3MA/fc_mplayer
void ShowURLDialog(void)
{
    urlItem *item;

    if (URLDialog)
        gtkRaise(URLDialog);
    else
        URLDialog = CreateURLDialog();

    item = listMgr(URLLIST_GET, 0);

    if (item) {
        g_list_free(urlEntries);
        urlEntries = NULL;

        while (item) {
            urlEntries = g_list_append(urlEntries, (gchar *)item->url);
            item       = item->next;
        }
    }

    if (urlEntries) {
        gtk_entry_set_text(GTK_ENTRY(urlEntry), urlEntries->data);
        gtk_combo_set_popdown_strings(GTK_COMBO(urlCombo), urlEntries);
    }

    gtk_widget_show(URLDialog);
}
예제 #9
0
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;
}
예제 #10
0
static void
gtkam_chooser_set_port_list (GtkamChooser *chooser, GList *list)
{
	gchar *port;
	guint i;

	g_return_if_fail (GTKAM_IS_CHOOSER (chooser));

        if (list) {

		/* Remember the old entry */
		port = g_strdup (gtk_entry_get_text (
						chooser->priv->entry_port));
		gtk_combo_set_popdown_strings (chooser->priv->combo_port, list);
		for (i = 0; i < g_list_length (list); i++)
			if (!strcmp (g_list_nth_data (list, i), port))
				gtk_entry_set_text (chooser->priv->entry_port,
						    port);
		g_free (port);
		gtk_widget_set_sensitive (
				GTK_WIDGET (chooser->priv->combo_port), TRUE);
		gtk_widget_set_sensitive (
				GTK_WIDGET (chooser->priv->button_add), TRUE);
	} else {
		gtk_widget_set_sensitive (
				GTK_WIDGET (chooser->priv->combo_port), FALSE);
		gtk_widget_set_sensitive (
				GTK_WIDGET (chooser->priv->button_add), FALSE);
	}
}
예제 #11
0
파일: login.c 프로젝트: nightmorph/LogJam
static void
populate_user_list(login_dlg *ldlg) {
	GSList *l;
	GList *strings = NULL;
	JamHost *host = ldlg->curhost;
	JamAccount *acc;

	gtk_widget_set_sensitive(ldlg->bupdate, JAM_HOST_IS_LJ(ldlg->curhost));

	for (l = host->accounts; l != NULL; l = l->next) {
		strings = g_list_append(strings, (char*)jam_account_get_username(l->data));
	}
	if (strings)
		gtk_combo_set_popdown_strings(GTK_COMBO(ldlg->cusername), strings);
	else
		gtk_list_clear_items(GTK_LIST(GTK_COMBO(ldlg->cusername)->list), 0, -1);

	if (host->lastaccount) {
		acc = host->lastaccount;
	} else if (host->accounts) {
		acc = host->accounts->data;
	} else {
		acc = NULL;
	}

	gtk_entry_set_text(GTK_ENTRY(ldlg->eusername),
			acc ? jam_account_get_username(acc) : "");
	load_account(ldlg, acc);
}
예제 #12
0
void ShowURLDialogBox( void )
{
    if ( URL ) gtkActive( URL );
    else URL=create_URL();

    if ( urlList )
    {
        urlItem * item = urlList;
        g_list_free( URLComboEntrys );
        URLComboEntrys=NULL;
        while( item )
        {
            URLComboEntrys=g_list_append( URLComboEntrys,(gchar *)item->url );
            item=item->next;
        }
    }

    if ( URLComboEntrys )
    {
        gtk_entry_set_text( GTK_ENTRY( URLEntry ),URLComboEntrys->data );
        gtk_combo_set_popdown_strings( GTK_COMBO( URLCombo ),URLComboEntrys );
    }

    gtk_widget_show( URL );
}
예제 #13
0
static void
gtkam_chooser_update_for_model (GtkamChooser *chooser)
{
	const gchar *model;
	int m, result, i;
	CameraAbilities a;
	GtkWidget *dialog;
	GList *list;

	/* Get abilities of selected model */
	model = gtk_entry_get_text (chooser->priv->entry_model);
	if (!model || !*model)
		return;
	m = gp_abilities_list_lookup_model (chooser->priv->al, model);
	result = gp_abilities_list_get_abilities (chooser->priv->al, m, &a);
	if (result < 0) {
		dialog = gtkam_error_new (result, NULL, GTK_WIDGET (chooser),
			_("Could not get abilities of model '%s'."), model);
		gtk_widget_show (dialog);
		return;
	}

	/* Update port combo */
	gtkam_chooser_set_port_mask (chooser, a.port);

	/* Update speed combo */
	list = g_list_append (NULL, _("Best"));
	for (i = 0; a.speed[i]; i++)
		list = g_list_append (list, g_strdup_printf ("%i", a.speed[i]));
	gtk_combo_set_popdown_strings (chooser->priv->combo_speed, list);
	gtk_widget_set_sensitive (GTK_WIDGET (chooser->priv->combo_speed),
				  !(a.port == GP_PORT_USB));
}
예제 #14
0
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;
}
예제 #15
0
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;
}
예제 #16
0
static void
callback_audioCodecChanged( GtkWidget *widget, gpointer data )
{
	int codec = selectedAudioCodecIndex();
	int i;

	if (g_VcrCompDialog.audioAttribGList != 0)
	{
		g_list_free( g_VcrCompDialog.audioAttribGList );
		g_VcrCompDialog.audioAttribGList = 0;
	}

	for (i = 0; i < VCRComp_numAudioCodecAttribs( codec ); i++)
		g_VcrCompDialog.audioAttribGList = g_list_append( g_VcrCompDialog.audioAttribGList,
		                                                  (gchar*)VCRComp_audioCodecAttribName( codec, i ) );

	if (g_VcrCompDialog.audioAttribGList == 0)
	{
		gtk_widget_set_sensitive( g_VcrCompDialog.audioAttribCombo, FALSE );
		gtk_widget_set_sensitive( g_VcrCompDialog.audioAttribEntry, FALSE );
		gtk_widget_set_sensitive( g_VcrCompDialog.audioAttribChangeButton, FALSE );
		gtk_entry_set_text( GTK_ENTRY(g_VcrCompDialog.audioAttribEntry), "" );
	}
	else
	{
		gtk_widget_set_sensitive( g_VcrCompDialog.audioAttribCombo, TRUE );
		gtk_widget_set_sensitive( g_VcrCompDialog.audioAttribEntry, TRUE );
		gtk_widget_set_sensitive( g_VcrCompDialog.audioAttribChangeButton, TRUE );
		gtk_combo_set_popdown_strings( GTK_COMBO(g_VcrCompDialog.audioAttribCombo), g_VcrCompDialog.audioAttribGList );
		callback_audioAttribChanged( NULL, NULL );
	}
}
예제 #17
0
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));
}
예제 #18
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);
}
예제 #19
0
static void
set_dsn_combos (GtkWidget * check, gpointer widget)
{
  TPCATableProps *tbl = TPCA_TABLE_PROPS (widget);
  ServerDSN *dsn = SERVER_DSN (check);
  if (dsn->dsn_info.dsns)
    {
      gtk_combo_set_popdown_strings (GTK_COMBO (tbl->branch_dsn),
	  dsn->dsn_info.dsns);
      gtk_combo_set_popdown_strings (GTK_COMBO (tbl->teller_dsn),
	  dsn->dsn_info.dsns);
      gtk_combo_set_popdown_strings (GTK_COMBO (tbl->account_dsn),
	  dsn->dsn_info.dsns);
      gtk_combo_set_popdown_strings (GTK_COMBO (tbl->history_dsn),
	  dsn->dsn_info.dsns);
    }
}
예제 #20
0
/*
 * Sets the properties of the widget. This is used for both applying the
 * properties changed in the property editor, and also for loading.
 */
static void
gb_combo_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
  gboolean value_in_list, ok_if_empty, case_sensitive, arrows, arrows_always;
  gchar *items;
  GList *item_list = NULL;

  value_in_list = gb_widget_input_bool (data, ValueInList);
  if (data->apply)
    {
      gtk_object_set_data (GTK_OBJECT (widget), ValueInList,
			   value_in_list ? "TRUE" : NULL);
    }

  ok_if_empty = gb_widget_input_bool (data, OKIfEmpty);
  if (data->apply)
    {
      gtk_object_set_data (GTK_OBJECT (widget), OKIfEmpty,
			   ok_if_empty ? "TRUE" : NULL);
    }

  case_sensitive = gb_widget_input_bool (data, Case);
  if (data->apply)
    gtk_combo_set_case_sensitive (GTK_COMBO (widget), case_sensitive);
  arrows = gb_widget_input_bool (data, Arrows);
  if (data->apply)
    gtk_combo_set_use_arrows (GTK_COMBO (widget), arrows);
  arrows_always = gb_widget_input_bool (data, Always);
  if (data->apply)
    gtk_combo_set_use_arrows_always (GTK_COMBO (widget), arrows_always);

  items = gb_widget_input_text (data, Items);
  if (data->apply)
    {
      gchar *pos = items;
      gchar *items_end = &items[strlen (items)];

      while (pos < items_end)
	{
	  gchar *item_end = strchr (pos, '\n');
	  if (item_end == NULL)
	    item_end = items_end;
	  *item_end = '\0';
	  item_list = g_list_append (item_list, pos);
	  pos = item_end + 1;
	}
      if (item_list)
	gtk_combo_set_popdown_strings (GTK_COMBO (widget), item_list);
      else
	gtk_list_clear_items (GTK_LIST (GTK_COMBO (widget)->list), 0, -1);
      g_list_free (item_list);
    }
  if (data->action == GB_APPLYING)
    g_free (items);
}
예제 #21
0
void
gmdb_table_export_populate_dialog(GladeXML *xml)
{
	GList *glist = NULL;
	GtkWidget *combo;

	/* Create the widgets */
	combo = glade_xml_get_widget (xml, "term_combo");
	glist = g_list_append(glist, LF);
	glist = g_list_append(glist, CR);
	glist = g_list_append(glist, CRLF);
    	gtk_combo_set_popdown_strings(GTK_COMBO(combo), glist);
	g_list_free(glist);

	combo = glade_xml_get_widget (xml, "sep_combo");
	glist = NULL;
	glist = g_list_append(glist, COMMA);
	glist = g_list_append(glist, TAB);
	glist = g_list_append(glist, SPACE);
	glist = g_list_append(glist, COLON);
	glist = g_list_append(glist, SEMICOLON);
	glist = g_list_append(glist, PIPE);
    	gtk_combo_set_popdown_strings(GTK_COMBO(combo), glist);
	g_list_free(glist);

	combo = glade_xml_get_widget (xml, "quote_combo");
	glist = NULL;
	glist = g_list_append(glist, ALWAYS);
	glist = g_list_append(glist, NEVER);
	glist = g_list_append(glist, AUTOMAT);
    	gtk_combo_set_popdown_strings(GTK_COMBO(combo), glist);
	g_list_free(glist);

	combo = glade_xml_get_widget (xml, "qchar_combo");
	glist = NULL;
	glist = g_list_append(glist, "\"");
	glist = g_list_append(glist, "'");
	glist = g_list_append(glist, "`");
    	gtk_combo_set_popdown_strings(GTK_COMBO(combo), glist);
	g_list_free(glist);
}
예제 #22
0
void ShowEquConfig( void )
{
 GList * Items = NULL;

 if ( EquConfig ) gtkActive( EquConfig );
    else EquConfig=create_EquConfig();

 Items=g_list_append( Items,(gpointer)MSGTR_EQU_Front_Right  );
 Items=g_list_append( Items,(gpointer)MSGTR_EQU_Front_Left );
 Items=g_list_append( Items,(gpointer)MSGTR_EQU_Back_Right );
 Items=g_list_append( Items,(gpointer)MSGTR_EQU_Back_Left );
 Items=g_list_append( Items,(gpointer)MSGTR_EQU_Center );
 Items=g_list_append( Items,(gpointer)MSGTR_EQU_Bass );

 gtk_combo_set_popdown_strings( GTK_COMBO( CBChannel1 ),Items );
 gtk_combo_set_popdown_strings( GTK_COMBO( CBChannel2 ),Items );
 gtk_combo_set_popdown_strings( GTK_COMBO( CBChannel3 ),Items );
 gtk_combo_set_popdown_strings( GTK_COMBO( CBChannel4 ),Items );
 gtk_combo_set_popdown_strings( GTK_COMBO( CBChannel5 ),Items );
 gtk_combo_set_popdown_strings( GTK_COMBO( CBChannel6 ),Items );

 g_list_free( Items );

 gtk_entry_set_text( GTK_ENTRY( CEChannel1 ),gtkEquChannel1 ); gtk_entry_set_editable( GTK_ENTRY( CEChannel1 ),FALSE );
 gtk_entry_set_text( GTK_ENTRY( CEChannel2 ),gtkEquChannel2 ); gtk_entry_set_editable( GTK_ENTRY( CEChannel2 ),FALSE );
 gtk_entry_set_text( GTK_ENTRY( CEChannel3 ),gtkEquChannel3 ); gtk_entry_set_editable( GTK_ENTRY( CEChannel3 ),FALSE );
 gtk_entry_set_text( GTK_ENTRY( CEChannel4 ),gtkEquChannel4 ); gtk_entry_set_editable( GTK_ENTRY( CEChannel4 ),FALSE );
 gtk_entry_set_text( GTK_ENTRY( CEChannel5 ),gtkEquChannel5 ); gtk_entry_set_editable( GTK_ENTRY( CEChannel5 ),FALSE );
 gtk_entry_set_text( GTK_ENTRY( CEChannel6 ),gtkEquChannel6 ); gtk_entry_set_editable( GTK_ENTRY( CEChannel6 ),FALSE );

 gtk_widget_show( EquConfig );
 gtkSetLayer( EquConfig );
}
예제 #23
0
static void
set_dsn_combos (GtkWidget * check, gpointer widget)
{
  GtkWidget **combos = (GtkWidget **) widget;
  ServerDSN *dsn = SERVER_DSN (check);
  if (dsn->dsn_info.dsns)
    {
      int inx;
      for (inx = 0; inx < 9; inx++)
	gtk_combo_set_popdown_strings (GTK_COMBO (combos[inx]),
	    dsn->dsn_info.dsns);
    }
}
예제 #24
0
파일: combo.c 프로젝트: amery/clip-angelo
int
clip_GTK_COMBOSETPOPDOWNSTRINGS(ClipMachine * ClipMachineMemory)
{
   C_widget *ccmb = _fetch_cw_arg(ClipMachineMemory);

   ClipArrVar *astr = (ClipArrVar *) _clip_vptr(_clip_spar(ClipMachineMemory, 2));

   GList    *str_list = NULL;

   gchar    *text_utf;

   ClipStrVar *s;

   int       i;

   CHECKCWID(ccmb, GTK_IS_COMBO);
   CHECKOPT(2, ARRAY_type_of_ClipVarType);

   for (i = 0; i < astr->count; i++)
    {
       if (astr->items[i].t.ClipVartype_type_of_ClipType != CHARACTER_type_of_ClipVarType)
	  continue;
       s = (ClipStrVar *) _clip_vptr(&astr->items[i]);
       text_utf = _clip_locale_to_utf8(s->str.buf);
       if (ccmb->objtype == GTK_WIDGET_COMBO_SIMPLE)
	{
	   str_list = g_list_append(str_list, gtk_list_item_new_with_label(text_utf));
	   g_free(text_utf);
	}
       else
	  str_list = g_list_append(str_list, text_utf);
    }
   if (ccmb->objtype == GTK_WIDGET_COMBO_SIMPLE)
    {
       gtk_list_clear_items(GTK_LIST(GTK_COMBO(ccmb->widget)->list), 0, -1);
       gtk_list_append_items(GTK_LIST(GTK_COMBO(ccmb->widget)->list), str_list);
    }
   else
      gtk_combo_set_popdown_strings(GTK_COMBO(ccmb->widget), str_list);

/*
	while (str_list)
	{
		g_free(str_list->data);
		str_list = g_list_next(str_list);
	}
*/
   return 0;
 err:
   return 1;
}
예제 #25
0
파일: update.c 프로젝트: rlaager/gbonds-pkg
/*--------------------------------------------------------------------------*/
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");
}
예제 #26
0
gchar *input_dialog_combo(const gchar *title, const gchar *message,
			  const gchar *default_string, GList *list,
			  gboolean case_sensitive)
{
	if (dialog)
		return NULL;

	input_dialog_create(INPUT_DIALOG_COMBO);

	if (!list) {
		GList empty_list;

		empty_list.data = (gpointer)"";
		empty_list.next = NULL;
		empty_list.prev = NULL;
		gtk_combo_set_popdown_strings(GTK_COMBO(combo), &empty_list);
	} else
		gtk_combo_set_popdown_strings(GTK_COMBO(combo), list);

	gtk_combo_set_case_sensitive(GTK_COMBO(combo), case_sensitive);

	return input_dialog_open(title, message, default_string);
}
예제 #27
0
void SetGListToCombo(const char *combo_widget, GList *glist, const gchar *curr_name)
{
	GtkWidget *entry = NULL, *combo = NULL;

	combo = glade_xml_get_widget(g_cngplp_xml,combo_widget);
	if(combo != NULL){
		entry = GTK_COMBO(combo)->entry;
	}

	if((glist != NULL) || (curr_name != NULL)){
		gtk_combo_set_popdown_strings(GTK_COMBO(combo), glist);
		gtk_entry_set_text(GTK_ENTRY(entry), curr_name);
	}
}
예제 #28
0
파일: combo.c 프로젝트: magnush/mhwaveedit
void combo_set_items(Combo *combo, GList *item_strings, int default_index)
{
     updating_flag = TRUE;
     gtk_combo_set_popdown_strings(GTK_COMBO(combo),item_strings);
     if (default_index < g_list_length(item_strings) && default_index >= 0) {
	  gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry),
			     (gchar *)g_list_nth_data(item_strings,
						      default_index));
	  combo->chosen_index = default_index;
     } else
	  combo->chosen_index = 0;
     updating_flag = FALSE;
     gtk_signal_emit(GTK_OBJECT(combo),combo_signals[CHANGED_SIGNAL]);
}
예제 #29
0
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);
}
예제 #30
0
void
on_menu_options_preferences_activate   (GtkMenuItem    *menuitem,
                                        gpointer        user_data)
{
    GtkToggleButton *button;
    GtkCombo        *combo;
    GtkRange        *range;
    GtkSpinButton   *spinner;
    GList           *items;
    int i;
    vo_driver_t const *drivers;
    
    items = NULL;

    if( !preferences_window ) {
        preferences_window = create_preferences_window();
    }

        /* set the combo box up with the correct values. */
        combo = GTK_COMBO(lookup_widget(GTK_WIDGET(preferences_window), "video_output_driver_combo" ));
        gchar * vidpref = NULL;
        drivers = vo_drivers();
        for( i = 0; drivers[i].name; i++ ) {
            items = g_list_append(items, drivers[i].name);

            // while looking through the list of available video drivers,
            // the prefered driver is xv2, followed by xv, and finally x11.
            // If the user hasn't selected one, this one will be used.
            if ( !strcmp(drivers[i].name,"xv2") ||
                 (!vidpref && !strcmp(drivers[i].name,"xv"))) {
                if (vidpref) free(vidpref);
                vidpref=g_strdup(drivers[i].name);
            }
        }
        if (!vidpref) vidpref=g_strdup("x11");

        gtk_combo_set_popdown_strings(combo, items);

        if( !options.video_driver_ptr ) options.video_driver_ptr = vidpref;
        else                            if (vidpref) free(vidpref);

        gtk_entry_set_text(GTK_ENTRY(combo->entry),
                           (const gchar*)options.video_driver_ptr);

    handle_simple_preferences(true);

    gtk_widget_show(preferences_window);
}