Example #1
0
bool wxCheckBox::GetValue() const
{
    wxCHECK_MSG( m_widgetCheckbox != NULL, false, wxT("invalid checkbox") );

    return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_widgetCheckbox)) != 0;
}
Example #2
0
VALUE shoes_native_check_get(SHOES_CONTROL_REF ref) {
    return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ref)) ? Qtrue : Qfalse;
}
Example #3
0
static gint show_dialog_find_file(gchar *utf8_path, gchar **pattern, gboolean *case_sensitive, gboolean *is_full_path)
{
	gint res;
	GtkWidget *entry;
	gchar *selection;
	GtkSizeGroup *size_group;

	if (!s_fif_dialog.widget)
	{
		GtkWidget *label, *vbox, *ebox;

		s_fif_dialog.widget = gtk_dialog_new_with_buttons(
			_("Find File"), GTK_WINDOW(geany->main_widgets->window),
			GTK_DIALOG_DESTROY_WITH_PARENT,
			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
		gtk_dialog_add_button(GTK_DIALOG(s_fif_dialog.widget), "gtk-find", GTK_RESPONSE_ACCEPT);
		gtk_dialog_set_default_response(GTK_DIALOG(s_fif_dialog.widget), GTK_RESPONSE_ACCEPT);

		vbox = ui_dialog_vbox_new(GTK_DIALOG(s_fif_dialog.widget));
		gtk_box_set_spacing(GTK_BOX(vbox), 6);

		size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);

		label = gtk_label_new(_("Search for:"));
		gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
		gtk_size_group_add_widget(size_group, label);
		s_fif_dialog.combo = gtk_combo_box_text_new_with_entry();
		entry = gtk_bin_get_child(GTK_BIN(s_fif_dialog.combo));
		gtk_entry_set_width_chars(GTK_ENTRY(entry), 40);
		gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
		ui_entry_add_clear_icon(GTK_ENTRY(entry));
		gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);

		ebox = gtk_hbox_new(FALSE, 6);
		gtk_box_pack_start(GTK_BOX(ebox), label, FALSE, FALSE, 0);
		gtk_box_pack_start(GTK_BOX(ebox), s_fif_dialog.combo, TRUE, TRUE, 0);

		gtk_box_pack_start(GTK_BOX(vbox), ebox, TRUE, FALSE, 0);

		label = gtk_label_new(_("Search inside:"));
		gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
		gtk_size_group_add_widget(size_group, label);
		s_fif_dialog.dir_label = gtk_label_new("");
		gtk_misc_set_alignment(GTK_MISC(s_fif_dialog.dir_label), 0, 0.5);

		ebox = gtk_hbox_new(FALSE, 6);
		gtk_box_pack_start(GTK_BOX(ebox), label, FALSE, FALSE, 0);
		gtk_box_pack_start(GTK_BOX(ebox), s_fif_dialog.dir_label, TRUE, TRUE, 0);

		gtk_box_pack_start(GTK_BOX(vbox), ebox, TRUE, FALSE, 0);

		s_fif_dialog.case_sensitive = gtk_check_button_new_with_mnemonic(_("C_ase sensitive"));
		gtk_button_set_focus_on_click(GTK_BUTTON(s_fif_dialog.case_sensitive), FALSE);

		s_fif_dialog.full_path = gtk_check_button_new_with_mnemonic(_("Search in full path"));
		gtk_button_set_focus_on_click(GTK_BUTTON(s_fif_dialog.full_path), FALSE);

		gtk_box_pack_start(GTK_BOX(vbox), s_fif_dialog.case_sensitive, TRUE, FALSE, 0);
		gtk_box_pack_start(GTK_BOX(vbox), s_fif_dialog.full_path, TRUE, FALSE, 0);
		gtk_widget_show_all(vbox);
	}

	if (utf8_path)
		gtk_label_set_text(GTK_LABEL(s_fif_dialog.dir_label), utf8_path);
	else
		gtk_label_set_text(GTK_LABEL(s_fif_dialog.dir_label), _("project or external directory"));
	entry = gtk_bin_get_child(GTK_BIN(s_fif_dialog.combo));
	selection = get_selection();
	if (selection)
		gtk_entry_set_text(GTK_ENTRY(entry), selection);
	g_free(selection);
	gtk_widget_grab_focus(entry);

	res = gtk_dialog_run(GTK_DIALOG(s_fif_dialog.widget));

	if (res == GTK_RESPONSE_ACCEPT)
	{
		const gchar *str;

		str = gtk_entry_get_text(GTK_ENTRY(entry));
		*pattern = g_strconcat("*", str, "*", NULL);
		*case_sensitive = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(s_fif_dialog.case_sensitive));
		*is_full_path = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(s_fif_dialog.full_path));
		ui_combo_box_add_to_history(GTK_COMBO_BOX_TEXT(s_fif_dialog.combo), str, 0);
	}

	gtk_widget_hide(s_fif_dialog.widget);

	return res;
}
Example #4
0
static void
change_show_arrow (GtkWidget *button, GtkWidget *toolbar)
{
  gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar),
		gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)));
}
Example #5
0
static void toggle_cb (GtkToggleButton * toggle, bool_t * setting)
{
    * setting = gtk_toggle_button_get_active (toggle);
}
Example #6
0
static void
do_extract_changed(LevelGrainsControls *controls)
{
    controls->args->do_extract
        = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(controls->do_extract));
}
Example #7
0
void
add_item_cb (GtkToggleButton *togglebutton, gpointer user_data) {

    config.add_edit = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (togglebutton));
}
Example #8
0
static void display_all_workspaces_toggled(GtkToggleButton* button, TasklistData* tasklist)
{
	g_settings_set_boolean(tasklist->settings, "display-all-workspaces", gtk_toggle_button_get_active(button));
}
inline gboolean
get_active (GtkWidget* toggle)
{
    return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle));
}
G_MODULE_EXPORT void cb_soft_ROI_mean2_editable_changed( GtkEditable *editable, gpointer   data )
{
  if((gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(camera_params.objects->soft_display_mean_roi2))==TRUE)||
     (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(camera_params.objects->soft_compute_mean_roi2))==TRUE))
    update_soft_val(&camera_params);
}
Example #11
0
static void move_minimized_toggled(GtkToggleButton* button, TasklistData* tasklist)
{
	g_settings_set_boolean(tasklist->settings, "move-unminimized-windows", gtk_toggle_button_get_active(button));
}
G_MODULE_EXPORT void cb_soft_ROI_editable_changed( GtkEditable *editable, gpointer   data )
{
  if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(camera_params.objects->soft_cut_img))==TRUE)
    update_soft_val(&camera_params);
}
Example #13
0
// bool GetValue() const
// Get the value of the toggle button.
bool wxBitmapToggleButton::GetValue() const
{
    wxCHECK_MSG(m_widget != NULL, false, wxT("invalid toggle button"));

    return gtk_toggle_button_get_active((GtkToggleButton*)m_widget);
}
Example #14
0
gint dbgdata_display_dbox(gint *mode, gint *type, uint32_t *start, uint32_t *stop)
{
	GtkWidget *dbox;
	GtkWidget *data;
	gint result;

	G_CONST_RETURN gchar *sc_start, *sc_stop;
	gchar *s_start, *s_stop;
	
	xml = glade_xml_new
		(tilp_paths_build_glade("dbg_data-2.glade"), "dbgdata_dbox",
		 PACKAGE);
	if (!xml)
		g_error(_("%s: GUI loading failed!\n"), __FILE__);
	glade_xml_signal_autoconnect(xml);
	
	dbox = glade_xml_get_widget(xml, "dbgdata_dbox");
	gtk_dialog_set_alternative_button_order(GTK_DIALOG(dbox), GTK_RESPONSE_OK,
	                                        GTK_RESPONSE_CANCEL,-1);

	data = glade_xml_get_widget(xml, "radiobutton20");
	g_signal_emit_by_name(G_OBJECT(data), "toggled");

	// set type
	if(*type == -1)
	{
		// skip box preset step
	}
	else 
	{
		data = glade_xml_get_widget(xml, "radiobutton10");
		if(*mode & BK_READ)
			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE);

		data = glade_xml_get_widget(xml, "radiobutton11");
		if(*mode & BK_WRITE)
			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE);

		data = glade_xml_get_widget(xml, "radiobutton12");
		if((*mode & BK_READ) && (*mode & BK_WRITE))
			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE);

		if(*type == BK_TYPE_ACCESS)
		{
			data = glade_xml_get_widget(xml, "radiobutton20");
			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE);

			data = glade_xml_get_widget(xml, "comboboxentry1");
			if(*mode & BK_BYTE)
				gtk_combo_box_set_active(GTK_COMBO_BOX(data), 0);
			else if(*mode & BK_WORD)
				gtk_combo_box_set_active(GTK_COMBO_BOX(data), 1);
			else if(*mode & BK_LONG)
				gtk_combo_box_set_active(GTK_COMBO_BOX(data), 2);

			data = glade_xml_get_widget(xml, "entry3");
			s_start = g_strdup_printf("0x%06x", *start);
			gtk_entry_set_text(GTK_ENTRY(data), s_start);
			g_free(s_start);
		}
		else if(*type == BK_TYPE_RANGE)
		{
			data = glade_xml_get_widget(xml, "radiobutton21");
			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE);

			data = glade_xml_get_widget(xml, "entry1");
			s_start = g_strdup_printf("0x%06x", *start);
			gtk_entry_set_text(GTK_ENTRY(data), s_start);
			g_free(s_start);

			data = glade_xml_get_widget(xml, "entry2");
			s_stop = g_strdup_printf("0x%06x", *stop);
			gtk_entry_set_text(GTK_ENTRY(data), s_stop);
			g_free(s_stop);
		}
	}

loop:
	result = gtk_dialog_run(GTK_DIALOG(dbox));
	switch (result) {
	case GTK_RESPONSE_OK:
		sc_start = sc_stop = "";

		// Retrieve settings from fields
		data = glade_xml_get_widget(xml, "radiobutton10");
		if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
			*mode = BK_READ;
		data = glade_xml_get_widget(xml, "radiobutton11");
		if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
			*mode = BK_WRITE;
		data = glade_xml_get_widget(xml, "radiobutton12");
		if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
			*mode = BK_READ | BK_WRITE;

		data = glade_xml_get_widget(xml, "radiobutton20");
		if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
			*type = BK_TYPE_ACCESS;

		data = glade_xml_get_widget(xml, "radiobutton21");
		if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
			*type = BK_TYPE_RANGE;
	
		if(*type == BK_TYPE_ACCESS)
		{
			data = glade_xml_get_widget(xml, "comboboxentry1");
			switch(gtk_combo_box_get_active(GTK_COMBO_BOX(data)))
			{
			case 0: *mode |= BK_BYTE; break;
			case 1: *mode |= BK_WORD; break;
			case 2: *mode |= BK_LONG; break;
			}

			data = glade_xml_get_widget(xml, "entry3");
			sc_start = sc_stop = gtk_entry_get_text(GTK_ENTRY(data));
		} 
		else if(*type == BK_TYPE_RANGE)
		{
			data = glade_xml_get_widget(xml, "entry1");
			sc_start = gtk_entry_get_text(GTK_ENTRY(data));

			data = glade_xml_get_widget(xml, "entry2");
			sc_stop = gtk_entry_get_text(GTK_ENTRY(data));			
		}

		// Convert values and check
		result = sscanf(sc_start, "%x", start);
		if(result < 1)
			goto loop;

		result = sscanf(sc_stop, "%x", stop);
		if((result < 1) && (*type == 2))
			goto loop;

		if((*start > *stop) && (*type == 2))
			goto loop;

		gtk_widget_destroy(dbox);
		return 0;
	default:
		gtk_widget_destroy(dbox);
		return -1;
	}	

	return 0;
}
Example #15
0
gboolean
seahorse_passphrase_prompt_checked (GtkDialog *dialog)
{
    GtkToggleButton *button = GTK_TOGGLE_BUTTON (g_object_get_data (G_OBJECT (dialog), "check-option"));
    return GTK_IS_TOGGLE_BUTTON (button) ? gtk_toggle_button_get_active (button) : FALSE;
}
Example #16
0
static void toggle_set_sensitive_cb(GtkToggleButton * w, gpointer data)
{
	gboolean set = gtk_toggle_button_get_active(w);
	gtk_widget_set_sensitive(GTK_WIDGET(data), set);
}
Example #17
0
int DoLoadPortalFileDialog( GtkWidget *parent ){
	GtkWidget *dialog, *vbox, *hbox, *button, *entry, *check2d, *check3d;
	GtkWidget *content_area, *ok_button, *cancel_button, *change_button;
	gint response_id;
	int ret;
	GtkSizeGroup *size_group;
	GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;

	dialog = gtk_dialog_new_with_buttons( _( "Load .prt" ), NULL, flags, NULL );
	gtk_window_set_transient_for( GTK_WINDOW( dialog ), GTK_WINDOW( parent ) );

	ok_button = gtk_dialog_add_button( GTK_DIALOG( dialog ), _( "OK" ), GTK_RESPONSE_OK );
	cancel_button = gtk_dialog_add_button( GTK_DIALOG( dialog ), _( "Cancel" ), GTK_RESPONSE_CANCEL );

	content_area = gtk_dialog_get_content_area( GTK_DIALOG( dialog ) );

	vbox = gtk_vbox_new( FALSE, 5 );
	gtk_container_add( GTK_CONTAINER( content_area ), vbox );
	gtk_container_set_border_width( GTK_CONTAINER( vbox ), 5 );
	gtk_widget_show( vbox );

	entry = gtk_entry_new();
	gtk_editable_set_editable( GTK_EDITABLE( entry ), FALSE );
	gtk_box_pack_start( GTK_BOX( vbox ), entry, FALSE, FALSE, 0 );
	gtk_widget_show( entry );

	hbox = gtk_hbox_new( FALSE, 5 );
	gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
	gtk_widget_show( hbox );

	check3d = gtk_check_button_new_with_label( _( "Show 3D" ) );
	gtk_box_pack_start( GTK_BOX( hbox ), check3d, FALSE, FALSE, 0 );
	gtk_widget_show( check3d );

	check2d = gtk_check_button_new_with_label( _( "Show 2D" ) );
	gtk_box_pack_start( GTK_BOX( hbox ), check2d, FALSE, FALSE, 0 );
	gtk_widget_show( check2d );

	change_button = button = gtk_button_new_with_label( _( "Change" ) );
	gtk_box_pack_end( GTK_BOX( hbox ), button, FALSE, FALSE, 0 );
	g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK( change_clicked ), parent );
	gtk_widget_show( button );

	size_group = gtk_size_group_new( GTK_SIZE_GROUP_BOTH );
	gtk_size_group_add_widget( size_group, ok_button );
	gtk_size_group_add_widget( size_group, cancel_button );
	gtk_size_group_add_widget( size_group, change_button );
	g_object_unref( size_group );

	char *fn = g_FuncTable.m_pfnGetMapName();
	strcpy( portals.fn, fn );
	fn = strrchr( portals.fn, '.' );
	if ( fn != NULL ) {
		*fn = '\0';
		strcat( portals.fn, ".prt" );
	}

	gtk_entry_set_text( GTK_ENTRY( entry ), portals.fn );
	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( check2d ), portals.show_2d );
	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( check3d ), portals.show_3d );


	response_id = gtk_dialog_run( GTK_DIALOG( dialog ) );

	if( response_id == GTK_RESPONSE_OK ) {

		portals.Purge();

		portals.show_3d = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( check3d ) ) ? true : false;
		portals.show_2d = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( check2d ) ) ? true : false;

		ret = IDOK;
	} else {
		ret = IDCANCEL;
	}

	gtk_widget_destroy( dialog );

	return ret;
}
Example #18
0
static void cache_icons_check_toggled_cb(GtkToggleButton *button, gpointer data)
{
	gtk_widget_set_sensitive(libravatarprefs_page.cache_interval_spin,
				 gtk_toggle_button_get_active(button));
}
static void
on_operations_icon_draw (GtkWidget       *widget,
                         cairo_t         *cr,
                         NautilusToolbar *self)
{
        gfloat elapsed_progress = 0;
        gint remaining_progress = 0;
        gint total_progress;
        gdouble ratio;
        GList *progress_infos;
        GList *l;
        guint width;
        guint height;
        gboolean all_cancelled;
        GdkRGBA background = {.red = 0, .green = 0, .blue = 0, .alpha = 0.2 };
        GdkRGBA foreground = {.red = 0, .green = 0, .blue = 0, .alpha = 0.7 };

        all_cancelled = TRUE;
        progress_infos = nautilus_progress_info_manager_get_all_infos (self->priv->progress_manager);
        for (l = progress_infos; l != NULL; l = l->next) {
                if (!nautilus_progress_info_get_is_cancelled (l->data)) {
                        all_cancelled = FALSE;
                        remaining_progress += nautilus_progress_info_get_remaining_time (l->data);
                        elapsed_progress += nautilus_progress_info_get_elapsed_time (l->data);
                }
        }

        total_progress = remaining_progress + elapsed_progress;

        if (all_cancelled) {
                ratio = 1.0;
        } else {
                if (total_progress > 0) {
                        ratio = MAX (0.05, elapsed_progress / total_progress);
                } else {
                        ratio = 0.05;
                }
        }


        width = gtk_widget_get_allocated_width (widget);
        height = gtk_widget_get_allocated_height (widget);

        gdk_cairo_set_source_rgba(cr, &background);
        cairo_arc (cr,
                   width / 2.0, height / 2.0,
                   MIN (width, height) / 2.0,
                   0, 2 *G_PI);
        cairo_fill (cr);
        cairo_move_to (cr, width / 2.0, height / 2.0);
        gdk_cairo_set_source_rgba (cr, &foreground);
        cairo_arc (cr,
                   width / 2.0, height / 2.0,
                   MIN (width, height) / 2.0,
                   -G_PI / 2.0, ratio * 2 * G_PI - G_PI / 2.0);

        cairo_fill (cr);
}

static void
on_operations_button_toggled (NautilusToolbar *self)
{
        unschedule_remove_finished_operations (self);
        if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->priv->operations_button))) {
                schedule_remove_finished_operations (self);
        } else {
                update_operations (self);
        }
}

static void
nautilus_toolbar_init (NautilusToolbar *self)
{
	GtkBuilder *builder;

	self->priv = nautilus_toolbar_get_instance_private (self);
	gtk_widget_init_template (GTK_WIDGET (self));

	self->priv->path_bar = g_object_new (NAUTILUS_TYPE_PATH_BAR, NULL);
	gtk_container_add (GTK_CONTAINER (self->priv->path_bar_container),
					  self->priv->path_bar);

	self->priv->location_entry = nautilus_location_entry_new ();
	gtk_container_add (GTK_CONTAINER (self->priv->location_entry_container),
					  self->priv->location_entry);

	builder = gtk_builder_new_from_resource ("/org/gnome/nautilus/nautilus-toolbar-view-menu.xml");
	self->priv->view_menu_widget =  GTK_WIDGET (gtk_builder_get_object (builder, "view_menu_widget"));
	self->priv->zoom_level_scale = GTK_WIDGET (gtk_builder_get_object (builder, "zoom_level_scale"));
	self->priv->zoom_adjustment = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "zoom_adjustment"));

	self->priv->sort_menu =  GTK_WIDGET (gtk_builder_get_object (builder, "sort_menu"));
	self->priv->sort_trash_time =  GTK_WIDGET (gtk_builder_get_object (builder, "sort_trash_time"));
	self->priv->sort_search_relevance =  GTK_WIDGET (gtk_builder_get_object (builder, "sort_search_relevance"));
	self->priv->visible_columns =  GTK_WIDGET (gtk_builder_get_object (builder, "visible_columns"));
	self->priv->reload =  GTK_WIDGET (gtk_builder_get_object (builder, "reload"));
	self->priv->stop =  GTK_WIDGET (gtk_builder_get_object (builder, "stop"));

	g_signal_connect (self->priv->view_menu_widget, "closed",
			  G_CALLBACK (view_menu_popover_closed), self);
	gtk_menu_button_set_popover (GTK_MENU_BUTTON (self->priv->view_button),
				     self->priv->view_menu_widget);
	g_object_unref (builder);

	builder = gtk_builder_new_from_resource ("/org/gnome/nautilus/nautilus-toolbar-action-menu.xml");
	self->priv->action_menu = G_MENU (gtk_builder_get_object (builder, "action-menu"));
	gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (self->priv->action_button),
					G_MENU_MODEL (self->priv->action_menu));
	g_object_unref (builder);

        self->priv->progress_manager = nautilus_progress_info_manager_dup_singleton ();
	g_signal_connect (self->priv->progress_manager, "new-progress-info",
			  G_CALLBACK (on_new_progress_info), self);
        update_operations (self);

	g_object_set_data (G_OBJECT (self->priv->back_button), "nav-direction",
			   GUINT_TO_POINTER (NAUTILUS_NAVIGATION_DIRECTION_BACK));
	g_object_set_data (G_OBJECT (self->priv->forward_button), "nav-direction",
			   GUINT_TO_POINTER (NAUTILUS_NAVIGATION_DIRECTION_FORWARD));
	g_signal_connect (self->priv->back_button, "button-press-event",
			  G_CALLBACK (navigation_button_press_cb), self);
	g_signal_connect (self->priv->back_button, "button-release-event",
			  G_CALLBACK (navigation_button_release_cb), self);
	g_signal_connect (self->priv->forward_button, "button-press-event",
			  G_CALLBACK (navigation_button_press_cb), self);
	g_signal_connect (self->priv->forward_button, "button-release-event",
			  G_CALLBACK (navigation_button_release_cb), self);
	g_signal_connect (self->priv->zoom_level_scale, "value-changed",
			  G_CALLBACK (zoom_level_changed), self);

	gtk_widget_show_all (GTK_WIDGET (self));
	toolbar_update_appearance (self);
}
Example #20
0
static void CALOPEN(GtkWidget *widget, GTKwrapper *state){
  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(state->MOD[1]))){
    calOpen(gpibHANDLE);
  }
}
Example #21
0
void
remember_category_cb (GtkToggleButton *togglebutton, gpointer user_data) {

    config.remember_category_in_tasks = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (togglebutton));
}
Example #22
0
static void CALSHOR(GtkWidget *widget, GTKwrapper *state){
  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(state->MOD[2]))){
    calShort(gpibHANDLE);
  }
}
Example #23
0
File: srv-prop.c Project: IR4T4/xqf
static void set_new_properties (GtkWidget *widget, struct server *s) {
	struct server_props *props;
	char *customcfg;
	char *srvpwd;
	char *spectpwd;
	char *rconpwd;
	int   reserved;
	int   sucks;
	char* comment = NULL;

	customcfg = strdup_strip (gtk_entry_get_text (GTK_ENTRY (GTK_COMBO (customcfg_combo)->entry)));

	srvpwd = strdup_strip (gtk_entry_get_text (GTK_ENTRY (password_entry)));
	spectpwd = strdup_strip (gtk_entry_get_text (GTK_ENTRY (spectator_entry)));
	rconpwd = strdup_strip (gtk_entry_get_text (GTK_ENTRY (rcon_entry)));
	reserved = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner));
	sucks = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (sucks_check_button));
	comment = gtk_editable_get_chars (GTK_EDITABLE (comment_text), 0, -1);

	props = properties (s);

	if (props) {
		if (customcfg || srvpwd || spectpwd || rconpwd || reserved || sucks || comment) {
			g_free (props->custom_cfg);
			props->custom_cfg = customcfg;

			g_free (props->server_password);
			props->server_password = srvpwd;

			g_free (props->spectator_password);
			props->spectator_password = spectpwd;

			g_free (props->rcon_password);
			props->rcon_password = rconpwd;

			props->reserved_slots = reserved;

			props->sucks = sucks;

			g_free(props->comment);
			props->comment = comment;
		}
		else {
			props_list = g_slist_remove (props_list, props);
			props_free (props);
		}
	}
	else {
		if (customcfg || srvpwd || spectpwd || rconpwd || reserved || sucks || comment) {
			props = properties_new (s->host, s->port);
			props->custom_cfg = customcfg;
			props->server_password = srvpwd;
			props->spectator_password = spectpwd;
			props->rcon_password = rconpwd;
			props->reserved_slots = reserved;
			props->sucks = sucks;
			props->comment = comment;
		}
	}

	props_save ();
}
gboolean
stm_new_transfer_window_get_auto_start (StmNewTransferWindow *self)
{
	StmNewTransferWindowPrivate *priv = self->priv;
	return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->auto_start));
}
Example #25
0
static void run_tuxnes(GtkWidget *w, gpointer data)
{
	int i = 0;
	gchar **options;
	GError *err;

	options = g_malloc0_n(NUM_OF_TOGGLES + 3, sizeof (gchar *));

	options[i++] = g_strdup("tuxnes");

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[JOYREMAP]))) {
		options[i++] = g_strconcat("-J",
			gtk_entry_get_text(GTK_ENTRY(widgets[JOYREMAP])),
			NULL);
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[DISPLAY]))) {
		options[i++] = g_strconcat("--display=",
			gtk_entry_get_text(GTK_ENTRY(widgets[DISPLAY])),
			NULL);
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[NTSC]))) {
		correct_ntsc_value(widgets[NTSCHUE], NULL);
		correct_ntsc_value(widgets[NTSCTINT], NULL);

		options[i++] = g_strconcat("-N",
			gtk_entry_get_text(GTK_ENTRY(widgets[NTSCHUE])),
			",",
			gtk_entry_get_text(GTK_ENTRY(widgets[NTSCTINT])),
			NULL);
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[GEOMETRY]))) {
		options[i++] = g_strconcat("-G",
			gtk_entry_get_text(GTK_ENTRY(widgets[GEOMETRY])),
			NULL);
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[SCANLINES]))) {
		options[i++] = g_strconcat("-L",
			gtk_entry_get_text(GTK_ENTRY(widgets[SCANLINES])),
			NULL);
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[PALFILE]))) {
		gchar *temp = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widgets[PALFILE]));
		if (temp != NULL) {
			options[i++] = g_strconcat("-p", temp, NULL);
			g_free(temp);
		}
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[BLTINPAL]))) {
		int active = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets[BLTINPAL]));
		const char *temp = bltinpal_from_index(active);
		if (temp != NULL) {
			options[i++] = g_strconcat("-P", temp, NULL);
		}
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[MIRROR]))) {
		int active = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets[MIRROR]));
		const char *temp = mirror_from_index(active);
		if (temp != NULL) {
			options[i++] = g_strconcat("-m", temp, NULL);
		}
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[RENDERER]))) {
		int active = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets[RENDERER]));
		const char *temp = renderer_from_index(active);
		if (temp != NULL) {
			options[i++] = g_strconcat("-r", temp, NULL);
		}
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[MUTESOUND]))) {
		options[i++] = g_strdup("-smute");
	} else {
		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[SNDDEV]))) {
			gchar *temp = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widgets[SNDDEV]));
			if (temp != NULL) {
				options[i++] = g_strconcat("-s", temp, NULL);
				g_free(temp);
			}
		}
		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[SNDFORMAT]))) {
			int active = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets[SNDFORMAT]));
			const gchar *temp = sndformat_from_index(active);
			if (temp != NULL) {
				options[i++] = g_strconcat("-F", temp, NULL);
			}
		}
		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[SNDDELAY]))) {
			options[i++] = g_strconcat("-D",
				gtk_entry_get_text(GTK_ENTRY(widgets[SNDDELAY])),
				NULL);
		}
		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[SNDRATE]))) {
			int active = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets[SNDRATE]));
			const char *temp = sndrate_from_index(active);
			if (temp != NULL) {
				options[i++] = g_strconcat("-R", temp, NULL);
			}
		}
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[MAPPER]))) {
		options[i++] = g_strconcat("-M",
			gtk_entry_get_text(GTK_ENTRY(widgets[MAPPER])),
			NULL);
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[GAMEGENIE]))) {
		options[i++] = g_strconcat("-g",
			gtk_entry_get_text(GTK_ENTRY(widgets[GAMEGENIE])),
			NULL);
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[STICKYKEYS]))) {
		options[i++] = g_strdup("-K");
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[SWAPINPUT]))) {
		options[i++] = g_strdup("-X");
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[JOY1]))) {
		gchar *temp = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widgets[JOY1]));
		if (temp != NULL) {
			options[i++] = g_strconcat("-1", temp, NULL);
			g_free(temp);
		}
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[JOY2]))) {
		gchar *temp = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widgets[JOY2]));
		if (temp != NULL) {
			options[i++] = g_strconcat("-2", temp, NULL);
			g_free(temp);
		}
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[IGNOREINST]))) {
		options[i++] = g_strdup("-i");
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[DISPINROOT]))) {
		options[i++] = g_strdup("-I");
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[STATCOLOR]))) {
		options[i++] = g_strdup("-S");
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[GRAYSCALE]))) {
		options[i++] = g_strdup("-b");
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[ENLARGE]))) {
		options[i++] = g_strconcat("-E",
			gtk_entry_get_text(GTK_ENTRY(widgets[ENLARGE])),
			NULL);
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[VERBOSE]))) {
		options[i++] = g_strdup("-v");
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[FIXMAPPER]))) {
		options[i++] = g_strdup("-f");
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[SHOWHEADER]))) {
		options[i++] = g_strdup("-H");
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[DISASM]))) {
		options[i++] = g_strdup("-d");
	}
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggles[LINK]))) {
		options[i++] = g_strdup("-l");
	}
	{
		gchar *temp = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widgets[ROMNAME]));
		if (temp == NULL) {
			goto fail;
		}
		options[i++] = temp;
	}

	g_printerr("calling:");
	for (i = 0; options[i] != NULL; i++)
		g_printerr(" %s", options[i]);
	g_printerr("\n");

	err = NULL;
	g_spawn_async(NULL, options, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, &err);
	if (err != NULL) {
		g_printerr("%s\n", err->message);
		g_error_free(err);
	}

fail:
	g_strfreev(options);
}
Example #26
0
static void gtk_get_credentials(struct cli_credentials *credentials)
{
	const char *ret;
	GtkWidget *dialog;
	GtkWidget *label;
	GtkWidget *table;
	GtkWidget *entry_username;
	GtkWidget *dialog_action_area1;
	GtkWidget *cancelbutton1;
	GtkWidget *okbutton1;
#ifndef HAVE_GNOME_KEYRING
	GtkWidget *anonymous;
#endif
	const char *username;

	dialog = gtk_dialog_new ();
	gtk_window_set_title (GTK_WINDOW (dialog), "Credentials");
	gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
	gtk_window_set_type_hint (GTK_WINDOW (dialog), GDK_WINDOW_TYPE_HINT_DIALOG);

	table = gtk_table_new(4, 2, FALSE);
	gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), table);

	label = gtk_label_new ("Username:"******"Password:"******"_Anonymous");
	gtk_table_attach(GTK_TABLE(table),anonymous,0,2,4,5,GTK_FILL,0,0,0);
#endif

	dialog_action_area1 = GTK_DIALOG (dialog)->action_area;
	gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);

	cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
	gtk_dialog_add_action_widget (GTK_DIALOG (dialog), cancelbutton1, GTK_RESPONSE_CANCEL);
	gtk_widget_set_can_default(cancelbutton1, TRUE);

	okbutton1 = gtk_button_new_from_stock ("gtk-ok");
	gtk_dialog_add_action_widget (GTK_DIALOG (dialog), okbutton1, GTK_RESPONSE_OK);
	gtk_widget_set_can_default(okbutton1, TRUE);

	gtk_widget_show_all (dialog);

    switch (gtk_dialog_run (GTK_DIALOG (dialog))) {
	case GTK_RESPONSE_OK:
		cli_credentials_parse_string(credentials, gtk_entry_get_text(GTK_ENTRY(entry_username)), CRED_CALLBACK_RESULT);
#ifndef HAVE_GNOME_KEYRING
		cli_credentials_set_password(credentials, gtk_entry_get_text(GTK_ENTRY(entry_password)), CRED_CALLBACK_RESULT);

		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(anonymous))) {
			cli_credentials_set_anonymous(credentials);
		}
#endif
		break;
	default:
		ret = NULL;
		break;
	}

	gtk_widget_destroy (dialog);
}
Example #27
0
G_MODULE_EXPORT void on_check_run_in_vte_toggled(GtkToggleButton *togglebutton, GtkWidget *user_data)
{
    g_return_if_fail(GTK_IS_WIDGET(user_data));
    gtk_widget_set_sensitive(user_data, gtk_toggle_button_get_active(togglebutton));
}
Example #28
0
  void submit (Ekiga::FormBuilder &builder)
  {
    builder.boolean (name, description,
		     gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)),
		     advanced);
  }
Example #29
0
/*
** get widgets contents to the selected account
*/
static void defarchive_getlast(struct defarchive_data *data)
{
gchar *txt;
gboolean bool;
gdouble value;
gint active;
Archive *item;

	DB( g_print("(defarchive) getlast\n") );

	item = data->lastarcitem;
	
	if( item != NULL )
	{
		DB( g_print(" -> %s\n", item->wording) );

		txt = (gchar *)gtk_entry_get_text(GTK_ENTRY(data->ST_word));
		// ignore if entry is empty
		if (txt && *txt)
		{
			g_free(item->wording);
			item->wording = g_strdup(txt);
		}

		gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_arc));

		value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->ST_amount));
		item->amount = value;

		item->flags = 0;

		active = item->amount > 0 ? TRUE : FALSE;
		//active = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_amount));
		if(active == 1) item->flags |= OF_INCOME;

		bool = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_cheque));
		if(bool) item->flags |= OF_CHEQ2;

		bool = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_valid));
		if(bool) item->flags |= OF_VALID;

		bool = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_remind));
		if(bool == 1) item->flags |= OF_REMIND;

		item->paymode		= gtk_combo_box_get_active(GTK_COMBO_BOX(data->NU_mode));
		item->category		= ui_cat_comboboxentry_get_key_add_new(GTK_COMBO_BOX_ENTRY(data->PO_grp));
		item->payee			= ui_pay_comboboxentry_get_key_add_new(GTK_COMBO_BOX_ENTRY(data->PO_pay));
		item->account		= ui_acc_comboboxentry_get_key(GTK_COMBO_BOX_ENTRY(data->PO_acc));
		item->dst_account	= ui_acc_comboboxentry_get_key(GTK_COMBO_BOX_ENTRY(data->PO_accto));

		DB( g_print(" -> PO_acc %d\n", item->account) );
		DB( g_print(" -> PO_accto %d\n", item->dst_account) );

		bool = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_auto));
		if(bool) item->flags |= OF_AUTO;

		item->every   = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->NB_every));
		item->unit    = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_unit));
		item->nextdate	= gtk_dateentry_get_date(GTK_DATE_ENTRY(data->PO_next));

		bool = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_limit));
		if(bool) item->flags |= OF_LIMIT;

		item->limit   = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->NB_limit));

		data->change++;
	}
Example #30
0
// bool GetValue() const
// Get the value of the toggle button.
bool wxToggleButton::GetValue() const
{
    wxCHECK_MSG(m_widget != NULL, false, wxT("invalid toggle button"));

    return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_widget)) != 0;
}