static void update_sensitivity_for_mime_type (DialogData *data, const char *mime_type) { int i; if (mime_type == NULL) { gtk_widget_set_sensitive (data->a_password_entry, FALSE); gtk_widget_set_sensitive (data->a_password_label, FALSE); gtk_widget_set_sensitive (data->a_encrypt_header_checkbutton, FALSE); gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (data->a_encrypt_header_checkbutton), TRUE); gtk_widget_set_sensitive (data->a_volume_box, FALSE); return; } for (i = 0; mime_type_desc[i].mime_type != NULL; i++) { if (strcmp (mime_type_desc[i].mime_type, mime_type) == 0) { gboolean sensitive; sensitive = mime_type_desc[i].capabilities & FR_COMMAND_CAN_ENCRYPT; gtk_widget_set_sensitive (data->a_password_entry, sensitive); gtk_widget_set_sensitive (data->a_password_label, sensitive); sensitive = mime_type_desc[i].capabilities & FR_COMMAND_CAN_ENCRYPT_HEADER; gtk_widget_set_sensitive (data->a_encrypt_header_checkbutton, sensitive); gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (data->a_encrypt_header_checkbutton), ! sensitive); sensitive = mime_type_desc[i].capabilities & FR_COMMAND_CAN_CREATE_VOLUMES; gtk_widget_set_sensitive (data->a_volume_box, sensitive); break; } } }
static int gtkToggleUpdate3StateCheck(Ihandle *ih, int keyb) { int check = gtkToggleGetCheck(ih); if (check == 1) /* GOTO check == -1 */ { gtk_toggle_button_set_inconsistent((GtkToggleButton*)ih->handle, TRUE); gtkToggleToggled((GtkToggleButton*)ih->handle, ih); return TRUE; /* ignore message to avoid change toggle state */ } else if (check == -1) /* GOTO check == 0 */ { gtk_toggle_button_set_inconsistent((GtkToggleButton*)ih->handle, FALSE); if (keyb) { gtk_toggle_button_set_active((GtkToggleButton*)ih->handle, FALSE); return TRUE; /* ignore message to avoid change toggle state */ } } else /* (check == 0) GOTO check == 1 */ { gtk_toggle_button_set_inconsistent((GtkToggleButton*)ih->handle, FALSE); if (keyb) { gtk_toggle_button_set_active((GtkToggleButton*)ih->handle, TRUE); return TRUE; /* ignore message to avoid change toggle state */ } } return FALSE; }
void reset_general_controls() { GtkWidget * widget = NULL; if ((!toplevel) || (!gauge)) return; hold_handlers = TRUE; widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"cw_button")); gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(widget),TRUE); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"ccw_button")); gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(widget),TRUE); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"antialiased_check")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),TRUE); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"tattletale_check")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),TRUE); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"tattletale_alpha_spin")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_width_spin")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_tail_spin")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"start_angle_spin")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"sweep_angle_spin")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"lbound_spin")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"ubound_spin")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"background_color_button")); gtk_color_button_set_color(GTK_COLOR_BUTTON(widget),&black); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_color_button")); gtk_color_button_set_color(GTK_COLOR_BUTTON(widget),&white); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"gradient_begin_color_button")); gtk_color_button_set_color(GTK_COLOR_BUTTON(widget),&white); widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"gradient_end_color_button")); gtk_color_button_set_color(GTK_COLOR_BUTTON(widget),&black); hold_handlers = FALSE; }
static void gtk_checkbox_toggled_callback(GtkWidget *widget, wxCheckBox *cb) { if (!cb->m_hasVMT) return; if (g_blockEventsOnDrag) return; // Transitions for 3state checkbox must be done manually, GTK's checkbox // is 2state with additional "undetermined state" flag which isn't // changed automatically: if (cb->Is3State()) { GtkToggleButton *toggle = GTK_TOGGLE_BUTTON(widget); if (cb->Is3rdStateAllowedForUser()) { // The 3 states cycle like this when clicked: // checked -> undetermined -> unchecked -> checked -> ... bool active = gtk_toggle_button_get_active(toggle) != 0; bool inconsistent = gtk_toggle_button_get_inconsistent(toggle) != 0; cb->GTKDisableEvents(); if (!active && !inconsistent) { // checked -> undetermined gtk_toggle_button_set_active(toggle, true); gtk_toggle_button_set_inconsistent(toggle, true); } else if (!active && inconsistent) { // undetermined -> unchecked gtk_toggle_button_set_inconsistent(toggle, false); } else if (active && !inconsistent) { // unchecked -> checked // nothing to do } else { wxFAIL_MSG(wxT("3state wxCheckBox in unexpected state!")); } cb->GTKEnableEvents(); } else { // user's action unsets undetermined state: gtk_toggle_button_set_inconsistent(toggle, false); } } wxCommandEvent event(wxEVT_COMMAND_CHECKBOX_CLICKED, cb->GetId()); event.SetInt(cb->Get3StateValue()); event.SetEventObject(cb); cb->HandleWindowEvent(event); }
static int gtkToggleSetValueAttrib(Ihandle* ih, const char* value) { if (iupStrEqualNoCase(value,"NOTDEF")) gtk_toggle_button_set_inconsistent((GtkToggleButton*)ih->handle, TRUE); else { int check; Ihandle* last_ih = NULL; Ihandle* radio = iupRadioFindToggleParent(ih); gtk_toggle_button_set_inconsistent((GtkToggleButton*)ih->handle, FALSE); /* This action causes the toggled signal to be emitted. */ iupAttribSet(ih, "_IUPGTK_IGNORE_TOGGLE", "1"); if (radio) { last_ih = (Ihandle*)IupGetAttribute(radio, "VALUE_HANDLE"); if (last_ih) iupAttribSet(last_ih, "_IUPGTK_IGNORE_TOGGLE", "1"); } if (iupStrEqualNoCase(value,"TOGGLE")) { if (gtk_toggle_button_get_active((GtkToggleButton*)ih->handle)) check = 0; else check = 1; } else check = iupStrBoolean(value); if (check) gtk_toggle_button_set_active((GtkToggleButton*)ih->handle, TRUE); else { gtk_toggle_button_set_active((GtkToggleButton*)ih->handle, FALSE); if (ih->data->type == IUP_TOGGLE_IMAGE && ih->data->flat) gtk_button_set_relief((GtkButton*)ih->handle, GTK_RELIEF_NONE); } if (ih->data->type == IUP_TOGGLE_IMAGE) gtkToggleUpdateImage(ih, iupdrvIsActive(ih), gtkToggleGetCheck(ih)); iupAttribSet(ih, "_IUPGTK_IGNORE_TOGGLE", NULL); if (last_ih) iupAttribSet(last_ih, "_IUPGTK_IGNORE_TOGGLE", NULL); } return 0; }
static void font_render_load (GSettings *settings) { Antialiasing antialiasing; Hinting hinting; gboolean inconsistent = TRUE; GSList *tmp_list; antialiasing = g_settings_get_enum (settings, FONT_ANTIALIASING_KEY); hinting = g_settings_get_enum (settings, FONT_HINTING_KEY); in_change = TRUE; for (tmp_list = font_pairs; tmp_list; tmp_list = tmp_list->next) { FontPair *pair = tmp_list->data; if (antialiasing == pair->antialiasing && hinting == pair->hinting) { gtk_toggle_button_set_active (pair->radio, TRUE); inconsistent = FALSE; break; } } for (tmp_list = font_pairs; tmp_list; tmp_list = tmp_list->next) { FontPair *pair = tmp_list->data; gtk_toggle_button_set_inconsistent (pair->radio, inconsistent); } in_change = FALSE; }
static void update_visibility(adapter_data *adapter) { gboolean inconsistent, enabled; block_signals(adapter); /* Switch off a few widgets */ gtk_widget_set_sensitive (adapter->button_discoverable, adapter->powered); gtk_widget_set_sensitive (adapter->devices_table, adapter->powered); gtk_widget_set_sensitive (adapter->name_vbox, adapter->powered); if (adapter->discoverable != FALSE && adapter->timeout_value == 0) { inconsistent = FALSE; enabled = TRUE; } else if (adapter->discoverable == FALSE) { inconsistent = enabled = FALSE; } else { inconsistent = enabled = TRUE; } gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (adapter->button_discoverable), inconsistent); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (adapter->button_discoverable), enabled); unblock_signals(adapter); }
static void font_render_load (MateConfClient *client) { Antialiasing antialiasing; Hinting hinting; gboolean inconsistent = TRUE; GSList *tmp_list; font_render_get_mateconf (client, &antialiasing, &hinting); in_change = TRUE; for (tmp_list = font_pairs; tmp_list; tmp_list = tmp_list->next) { FontPair *pair = tmp_list->data; if (antialiasing == pair->antialiasing && hinting == pair->hinting) { gtk_toggle_button_set_active (pair->radio, TRUE); inconsistent = FALSE; break; } } for (tmp_list = font_pairs; tmp_list; tmp_list = tmp_list->next) { FontPair *pair = tmp_list->data; gtk_toggle_button_set_inconsistent (pair->radio, inconsistent); } in_change = FALSE; }
static void update_ui (CcWacomMappingPanel *self) { if (self->priv->device == NULL) { gtk_widget_set_sensitive (GTK_WIDGET(self->priv->checkbutton), FALSE); gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON(self->priv->checkbutton), TRUE); } else { gboolean is_screen_tablet; is_screen_tablet = gsd_wacom_device_is_screen_tablet (self->priv->device); gtk_widget_set_sensitive (GTK_WIDGET(self->priv->checkbutton), !is_screen_tablet); gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON(self->priv->checkbutton), FALSE); } update_monitor_chooser (self); }
static void discoverable_changed_cb(GtkWidget *button, gpointer user_data) { /* Note that this would be broken if we showed more than * one adapter, but we don't care */ gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), FALSE); bluetooth_client_set_discoverable (client, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))); }
static void set_alt_click_value (const MateWMSettings *settings) { gboolean match_found = FALSE; int i; /* We look for a matching modifier and set it. */ if (settings->mouse_move_modifier != NULL) { for (i = 0; i < n_mouse_modifiers; i ++) if (strcmp (mouse_modifiers[i].value, settings->mouse_move_modifier) == 0) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mouse_modifiers[i].radio), TRUE); match_found = TRUE; break; } } /* No matching modifier was found; we set all the toggle buttons to be * insensitive. */ for (i = 0; i < n_mouse_modifiers; i++) { gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (mouse_modifiers[i].radio), ! match_found); } }
static void set_alt_click_value () { gboolean match_found = FALSE; gchar *mouse_move_modifier; gchar *value; int i; mouse_move_modifier = g_settings_get_string (marco_settings, MARCO_MOUSE_MODIFIER_KEY); /* We look for a matching modifier and set it. */ if (mouse_move_modifier != NULL) { for (i = 0; i < n_mouse_modifiers; i ++) { value = g_strdup_printf ("<%s>", mouse_modifiers[i].value); if (strcmp (value, mouse_move_modifier) == 0) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mouse_modifiers[i].radio), TRUE); match_found = TRUE; break; } g_free (value); } g_free (mouse_move_modifier); } /* No matching modifier was found; we set all the toggle buttons to be * insensitive. */ for (i = 0; i < n_mouse_modifiers; i++) { gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (mouse_modifiers[i].radio), ! match_found); } }
static void overwrite_toggled_cb (GtkToggleButton *button, DialogData *data) { gboolean active = gtk_toggle_button_get_active (button); gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton), !active); gtk_widget_set_sensitive (data->e_not_newer_checkbutton, active); }
static void add_array_button(RyosconfigLayerIlluminationDialog *layer_illumination_dialog, GtkTable *table, gchar const *title, guint8 *data, guint left_attach, guint top_attach) { GtkWidget *button; button = gtk_check_button_new_with_label(title); gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(button), TRUE); g_object_set_data(G_OBJECT(button), array_key, data); g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(array_button_toggled_cb), layer_illumination_dialog); gtk_table_attach(table, button, left_attach, left_attach + 1, top_attach, top_attach + 1, GTK_EXPAND, GTK_EXPAND, 0, 0); }
static void silent_mode_cb(GtkToggleButton * widget, G_GNUC_UNUSED gpointer user_data) { GtkToggleButton *announce_button = user_data; gboolean silent_mode = gtk_toggle_button_get_active(widget); config_set_int("settings/silent_mode", silent_mode); set_silent_mode(silent_mode); gtk_toggle_button_set_inconsistent(announce_button, silent_mode); gtk_widget_set_sensitive(GTK_WIDGET(announce_button), !silent_mode); }
static int gtkToggleSetValueAttrib(Ihandle* ih, const char* value) { if (iupStrEqualNoCase(value,"NOTDEF")) gtk_toggle_button_set_inconsistent((GtkToggleButton*)ih->handle, TRUE); else { gtk_toggle_button_set_inconsistent((GtkToggleButton*)ih->handle, FALSE); /* This action causes the toggled signal to be emitted. */ iupAttribSetStr(ih, "_IUPGTK_IGNORE_TOGGLE", "1"); if (iupStrBoolean(value)) gtk_toggle_button_set_active((GtkToggleButton*)ih->handle, TRUE); else gtk_toggle_button_set_active((GtkToggleButton*)ih->handle, FALSE); iupAttribSetStr(ih, "_IUPGTK_IGNORE_TOGGLE", NULL); } return 0; }
static void toggle_clicked (GtkButton *button, gpointer unused) { GtkToggleButton *t_b = GTK_TOGGLE_BUTTON (button); /* we have to remove the inconsistent state ourselves */ if (gtk_toggle_button_get_inconsistent (t_b)) { gtk_toggle_button_set_inconsistent (t_b, FALSE); gtk_toggle_button_set_active (t_b, FALSE); } }
static void on_exec_toggled (GtkToggleButton *btn, FmFilePropData *data) { // Bypass the default handler g_signal_stop_emission_by_name ( btn, "toggled" ); /* Block this handler while we are changing the state of buttons, or this handler will be called recursively. */ g_signal_handlers_block_matched ( btn, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, on_exec_toggled, NULL ); if ( gtk_toggle_button_get_inconsistent ( btn ) ) { gtk_toggle_button_set_inconsistent ( btn, FALSE ); gtk_toggle_button_set_active ( btn, TRUE ); } else if ( gtk_toggle_button_get_active ( btn ) ) { gtk_toggle_button_set_inconsistent ( btn, TRUE ); } g_signal_handlers_unblock_matched ( btn, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, on_exec_toggled, NULL ); }
static void array_button_toggled_cb(GtkToggleButton *togglebutton, gpointer user_data) { RyosconfigLayerIlluminationDialog *dialog = RYOSCONFIG_LAYER_ILLUMINATION_DIALOG(user_data); RyosconfigLayerIlluminationDialogPrivate *priv = dialog->priv; guint8 value; guint8 *data; if (gtk_toggle_button_get_inconsistent(togglebutton)) { gtk_toggle_button_set_inconsistent(togglebutton, FALSE); gtk_toggle_button_set_active(togglebutton, TRUE); } value = key_state(dialog, gtk_toggle_button_get_active(togglebutton)); data = g_object_get_data(G_OBJECT(togglebutton), array_key); ryos_custom_lights_set_from_array(priv->light_layer, data, value); ryosconfig_layer_send(dialog); }
void Boolean3OptionView::setState(ZLBoolean3 state) { if (myState != state) { myState = state; bool active = false; bool inconsistent = false; switch (myState) { case B3_TRUE: active = true; break; case B3_FALSE: break; case B3_UNDEFINED: inconsistent = true; break; } gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(myCheckBox), inconsistent); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(myCheckBox), active); } }
/* * 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_toggle_button_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gboolean state, inconsistent; gb_button_set_standard_properties (widget, data, StockButton, Label, Icon, Relief, FocusOnClick); state = gb_widget_input_bool (data, State); if (data->apply) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), state); if (state) data->widget_data->flags |= GLADE_ACTIVE; else data->widget_data->flags &= ~GLADE_ACTIVE; } inconsistent = gb_widget_input_bool (data, Inconsistent); if (data->apply) gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (widget), inconsistent); }
static void paintToggle(RenderThemeGtk* theme, RenderObject* renderObject, const PaintInfo& info, const IntRect& rect, GtkWidget* widget) { // We do not call gtk_toggle_button_set_active here, because some themes begin a series of // animation frames in a "toggled" signal handler. This puts some checkboxes in a half-way // checked state. Every GTK+ theme I tested merely looks at the shadow type (and not the // 'active' property) to determine whether or not to draw the check. gtk_widget_set_sensitive(widget, theme->isEnabled(renderObject) && !theme->isReadOnlyControl(renderObject)); gtk_widget_set_direction(widget, gtkTextDirection(renderObject->style().direction())); bool indeterminate = theme->isIndeterminate(renderObject); gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(widget), indeterminate); GtkShadowType shadowType = GTK_SHADOW_OUT; if (indeterminate) // This originates from the Mozilla code. shadowType = GTK_SHADOW_ETCHED_IN; else if (theme->isChecked(renderObject)) shadowType = GTK_SHADOW_IN; WidgetRenderingContext widgetContext(info.context, rect); IntRect buttonRect(IntPoint(), rect.size()); GtkStateType toggleState = getGtkStateType(theme, renderObject); const char* detail = 0; if (GTK_IS_RADIO_BUTTON(widget)) { detail = "radiobutton"; widgetContext.gtkPaintOption(buttonRect, widget, toggleState, shadowType, detail); } else { detail = "checkbutton"; widgetContext.gtkPaintCheck(buttonRect, widget, toggleState, shadowType, detail); } if (theme->isFocused(renderObject)) { IntRect focusRect(buttonRect); adjustRectForFocus(widget, focusRect, true); widgetContext.gtkPaintFocus(focusRect, widget, toggleState, detail); } }
GtkWidget* file_properties_dlg_new( GtkWindow* parent, const char* dir_path, GList* sel_files, int page ) { GtkBuilder* builder = _gtk_builder_new_from_file( PACKAGE_UI_DIR "/file_properties.ui", NULL ); GtkWidget * dlg = (GtkWidget*)gtk_builder_get_object( builder, "dlg" ); GtkNotebook* notebook = (GtkNotebook*)gtk_builder_get_object( builder, "notebook" ); FilePropertiesDialogData* data; gboolean need_calc_size = TRUE; VFSFileInfo *file, *file2; VFSMimeType* mime; const char* multiple_files = _( "( multiple files )" ); const char* calculating; GtkWidget* name = (GtkWidget*)gtk_builder_get_object( builder, "file_name" ); GtkWidget* location = (GtkWidget*)gtk_builder_get_object( builder, "location" ); gtk_editable_set_editable ( GTK_EDITABLE( location ), FALSE ); GtkWidget* mime_type = (GtkWidget*)gtk_builder_get_object( builder, "mime_type" ); GtkWidget* open_with = (GtkWidget*)gtk_builder_get_object( builder, "open_with" ); GtkWidget* mtime = (GtkWidget*)gtk_builder_get_object( builder, "mtime" ); GtkWidget* atime = (GtkWidget*)gtk_builder_get_object( builder, "atime" ); char buf[ 64 ]; char buf2[ 32 ]; const char* time_format = "%Y-%m-%d %H:%M"; gchar* disp_path; gchar* file_type; int i; GList* l; gboolean same_type = TRUE; gboolean is_dirs = FALSE; char *owner_group, *tmp; gtk_dialog_set_alternative_button_order( GTK_DIALOG(dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 ); ptk_dialog_fit_small_screen( GTK_DIALOG(dlg) ); int width = xset_get_int( "app_dlg", "s" ); int height = xset_get_int( "app_dlg", "z" ); if ( width && height ) gtk_window_set_default_size( GTK_WINDOW( dlg ), width, height ); data = g_slice_new0( FilePropertiesDialogData ); /* FIXME: When will the data be freed??? */ g_object_set_data( G_OBJECT( dlg ), "DialogData", data ); data->file_list = sel_files; data->dlg = dlg; data->dir_path = g_strdup( dir_path ); disp_path = g_filename_display_name( dir_path ); //gtk_label_set_text( GTK_LABEL( location ), disp_path ); gtk_entry_set_text( GTK_ENTRY( location ), disp_path ); g_free( disp_path ); data->total_size_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "total_size" ) ); data->size_on_disk_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "size_on_disk" ) ); data->count_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "count" ) ); data->owner = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "owner" ) ); data->group = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "group" ) ); for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { data->chmod_btns[ i ] = GTK_TOGGLE_BUTTON( (GtkWidget*)gtk_builder_get_object( builder, chmod_names[ i ] ) ); } //MOD VFSMimeType* type; VFSMimeType* type2 = NULL; for ( l = sel_files; l ; l = l->next ) { file = ( VFSFileInfo* ) l->data; type = vfs_file_info_get_mime_type( file ); if ( !type2 ) type2 = vfs_file_info_get_mime_type( file ); if ( vfs_file_info_is_dir( file ) ) is_dirs = TRUE; if ( type != type2 ) same_type = FALSE; vfs_mime_type_unref( type ); if ( is_dirs && !same_type ) break; } if ( type2 ) vfs_mime_type_unref( type2 ); data->recurse = (GtkWidget*)gtk_builder_get_object( builder, "recursive" ); gtk_widget_set_sensitive( data->recurse, is_dirs ); /* //MOD for ( l = sel_files; l && l->next; l = l->next ) { VFSMimeType *type, *type2; file = ( VFSFileInfo* ) l->data; file2 = ( VFSFileInfo* ) l->next->data; type = vfs_file_info_get_mime_type( file ); type2 = vfs_file_info_get_mime_type( file2 ); if ( type != type2 ) { vfs_mime_type_unref( type ); vfs_mime_type_unref( type2 ); same_type = FALSE; break; } vfs_mime_type_unref( type ); vfs_mime_type_unref( type2 ); } */ file = ( VFSFileInfo* ) sel_files->data; if ( same_type ) { mime = vfs_file_info_get_mime_type( file ); file_type = g_strdup_printf( "%s ( %s )", vfs_mime_type_get_description( mime ), vfs_mime_type_get_type( mime ) ); gtk_label_set_text( GTK_LABEL( mime_type ), file_type ); g_free( file_type ); vfs_mime_type_unref( mime ); } else { gtk_label_set_text( GTK_LABEL( mime_type ), _( "( multiple types )" ) ); } /* Open with... * Don't show this option menu if files of different types are selected, * ,the selected file is a folder, or its type is unknown. */ if( ! same_type || vfs_file_info_is_dir( file ) || vfs_file_info_is_desktop_entry( file ) || vfs_file_info_is_unknown_type( file ) || vfs_file_info_is_executable( file, NULL ) ) { /* if open with shouldn't show, destroy it. */ gtk_widget_destroy( open_with ); open_with = NULL; gtk_widget_destroy( (GtkWidget*)gtk_builder_get_object( builder, "open_with_label" ) ); } else /* Add available actions to the option menu */ { GtkTreeIter it; char **action, **actions; mime = vfs_file_info_get_mime_type( file ); actions = vfs_mime_type_get_actions( mime ); GtkCellRenderer* renderer; GtkListStore* model; gtk_cell_layout_clear( GTK_CELL_LAYOUT(open_with) ); renderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, FALSE); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with), renderer, "pixbuf", 0, NULL ); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, TRUE); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with),renderer, "text", 1, NULL ); model = gtk_list_store_new( 3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); if( actions ) { for( action = actions; *action; ++action ) { VFSAppDesktop* desktop; GdkPixbuf* icon; desktop = vfs_app_desktop_new( *action ); gtk_list_store_append( model, &it ); icon = vfs_app_desktop_get_icon(desktop, 20, TRUE); gtk_list_store_set( model, &it, 0, icon, 1, vfs_app_desktop_get_disp_name(desktop), 2, *action, -1 ); if( icon ) g_object_unref( icon ); vfs_app_desktop_unref( desktop ); } } else { g_object_set_data( G_OBJECT(open_with), "prev_sel", GINT_TO_POINTER(-1) ); } /* separator */ gtk_list_store_append( model, &it ); gtk_list_store_append( model, &it ); gtk_list_store_set( model, &it, 0, NULL, 1, _("Choose..."), -1 ); gtk_combo_box_set_model( GTK_COMBO_BOX(open_with), GTK_TREE_MODEL(model) ); gtk_combo_box_set_row_separator_func( GTK_COMBO_BOX(open_with), combo_sep, NULL, NULL ); gtk_combo_box_set_active(GTK_COMBO_BOX(open_with), 0); g_signal_connect( open_with, "changed", G_CALLBACK(on_combo_change), mime ); /* vfs_mime_type_unref( mime ); */ /* We can unref mime when combo box gets destroyed */ g_object_weak_ref( G_OBJECT(open_with), (GWeakNotify)vfs_mime_type_unref, mime ); } g_object_set_data( G_OBJECT(dlg), "open_with", open_with ); /* Multiple files are selected */ if ( sel_files && sel_files->next ) { gtk_widget_set_sensitive( name, FALSE ); gtk_entry_set_text( GTK_ENTRY( name ), multiple_files ); gtk_label_set_text( GTK_LABEL( mtime ), "-" ); gtk_label_set_text( GTK_LABEL( atime ), "-" ); for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { gtk_toggle_button_set_inconsistent ( data->chmod_btns[ i ], TRUE ); data->chmod_states[ i ] = 2; /* Don't touch this bit */ g_signal_connect( G_OBJECT( data->chmod_btns[ i ] ), "toggled", G_CALLBACK( on_chmod_btn_toggled ), data ); } } else { /* special processing for files with special display names */ if( vfs_file_info_is_desktop_entry( file ) ) { char* disp_name = g_filename_display_name( file->name ); gtk_entry_set_text( GTK_ENTRY( name ), disp_name ); g_free( disp_name ); } else gtk_entry_set_text( GTK_ENTRY( name ), vfs_file_info_get_disp_name( file ) ); gtk_editable_set_editable ( GTK_EDITABLE( name ), FALSE ); if ( ! vfs_file_info_is_dir( file ) ) { /* Only single "file" is selected, so we don't need to caculate total file size */ need_calc_size = FALSE; sprintf( buf, _("%s ( %llu bytes )"), vfs_file_info_get_disp_size( file ), ( guint64 ) vfs_file_info_get_size( file ) ); gtk_label_set_text( data->total_size_label, buf ); vfs_file_size_to_string( buf2, vfs_file_info_get_blocks( file ) * 512 ); sprintf( buf, _("%s ( %llu bytes )"), buf2, ( guint64 ) vfs_file_info_get_blocks( file ) * 512 ); gtk_label_set_text( data->size_on_disk_label, buf ); gtk_label_set_text( data->count_label, _("1 file") ); } gtk_label_set_text( GTK_LABEL( mtime ), vfs_file_info_get_disp_mtime( file ) ); strftime( buf, sizeof( buf ), time_format, localtime( vfs_file_info_get_atime( file ) ) ); gtk_label_set_text( GTK_LABEL( atime ), buf ); owner_group = (char *) vfs_file_info_get_disp_owner( file ); tmp = strchr( owner_group, ':' ); data->owner_name = g_strndup( owner_group, tmp - owner_group ); gtk_entry_set_text( GTK_ENTRY( data->owner ), data->owner_name ); data->group_name = g_strdup( tmp + 1 ); gtk_entry_set_text( GTK_ENTRY( data->group ), data->group_name ); for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { if ( data->chmod_states[ i ] != 2 ) /* allow to touch this bit */ { data->chmod_states[ i ] = ( vfs_file_info_get_mode( file ) & chmod_flags[ i ] ? 1 : 0 ); gtk_toggle_button_set_active( data->chmod_btns[ i ], data->chmod_states[ i ] ); } } } if ( need_calc_size ) { /* The total file size displayed in "File Properties" is not completely calculated yet. So "Calculating..." is displayed. */ calculating = _( "Calculating..." ); gtk_label_set_text( data->total_size_label, calculating ); gtk_label_set_text( data->size_on_disk_label, calculating ); g_object_set_data( G_OBJECT( dlg ), "calc_size", data ); data->calc_size_thread = g_thread_create ( ( GThreadFunc ) calc_size, data, TRUE, NULL ); data->update_label_timer = g_timeout_add( 250, ( GSourceFunc ) on_update_labels, data ); } g_signal_connect( dlg, "response", G_CALLBACK(on_dlg_response), dlg ); g_signal_connect_swapped( gtk_builder_get_object(builder, "ok_button"), "clicked", G_CALLBACK(gtk_widget_destroy), dlg ); g_signal_connect_swapped( gtk_builder_get_object(builder, "cancel_button"), "clicked", G_CALLBACK(gtk_widget_destroy), dlg ); g_object_unref( builder ); gtk_notebook_set_current_page( notebook, page ); gtk_window_set_transient_for( GTK_WINDOW( dlg ), parent ); return dlg; }
static void dlg_extract__common (FrWindow *window, GList *selected_files, char *base_dir_for_selection) { DialogData *data; GtkWidget *file_sel; data = g_new0 (DialogData, 1); data->settings = g_settings_new (EXRED_SCHEMA_EXTRACT); data->window = window; data->selected_files = selected_files; data->base_dir_for_selection = base_dir_for_selection; data->extract_clicked = FALSE; data->dialog = file_sel = gtk_file_chooser_dialog_new (_("Extract"), GTK_WINDOW (data->window), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, FR_STOCK_EXTRACT, GTK_RESPONSE_OK, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_window_set_default_size (GTK_WINDOW (file_sel), 530, 510); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (file_sel), FALSE); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE); gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK); gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_sel), create_extra_widget (data)); /* Set widgets data. */ gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (file_sel), fr_window_get_extract_default_dir (window)); if (data->selected_files != NULL) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_selected_radiobutton), TRUE); else { gtk_widget_set_sensitive (data->e_selected_radiobutton, FALSE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_all_radiobutton), TRUE); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_overwrite_checkbutton), g_settings_get_boolean (data->settings, PREF_EXTRACT_OVERWRITE)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton), g_settings_get_boolean (data->settings, PREF_EXTRACT_SKIP_NEWER)); if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_overwrite_checkbutton))) { gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton), TRUE); gtk_widget_set_sensitive (data->e_not_newer_checkbutton, FALSE); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_recreate_dir_checkbutton), g_settings_get_boolean (data->settings, PREF_EXTRACT_RECREATE_FOLDERS)); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "destroy", G_CALLBACK (destroy_cb), data); g_signal_connect (G_OBJECT (file_sel), "response", G_CALLBACK (file_sel_response_cb), data); g_signal_connect (G_OBJECT (data->e_overwrite_checkbutton), "toggled", G_CALLBACK (overwrite_toggled_cb), data); g_signal_connect (G_OBJECT (data->e_files_entry), "changed", G_CALLBACK (files_entry_changed_cb), data); /* Run dialog. */ gtk_window_set_modal (GTK_WINDOW (file_sel),TRUE); gtk_widget_show (file_sel); }
static void create_adapter(adapter_data *adapter) { GHashTable *hash = NULL; GValue *value; DBusGProxy *default_proxy; const gchar *name; gboolean powered, discoverable; guint timeout; GtkWidget *mainbox; GtkWidget *vbox; GtkWidget *alignment; GtkWidget *table; GtkWidget *label; GtkWidget *image; GtkWidget *button; GtkWidget *entry; GtkWidget *buttonbox; int page_num; dbus_g_proxy_call(adapter->proxy, "GetProperties", NULL, G_TYPE_INVALID, dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &hash, G_TYPE_INVALID); if (hash != NULL) { value = g_hash_table_lookup(hash, "Name"); name = value ? g_value_get_string(value) : NULL; value = g_hash_table_lookup(hash, "Powered"); powered = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "Discoverable"); discoverable = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "DiscoverableTimeout"); timeout = value ? g_value_get_uint(value) : 0; } else { name = NULL; powered = FALSE; discoverable = FALSE; timeout = 0; } adapter->powered = powered; adapter->discoverable = discoverable; adapter->timeout_value = timeout; default_proxy = bluetooth_client_get_default_adapter (client); if (default_proxy != NULL) { adapter->is_default = g_str_equal (dbus_g_proxy_get_path (default_proxy), dbus_g_proxy_get_path (adapter->proxy)); g_object_unref (default_proxy); } mainbox = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(mainbox), 12); page_num = gtk_notebook_prepend_page(GTK_NOTEBOOK(adapter->notebook), mainbox, NULL); adapter->child = mainbox; vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, TRUE, 0); /* The discoverable checkbox */ button = gtk_check_button_new_with_mnemonic (_("Make computer _visible")); if (powered == FALSE) discoverable = FALSE; if (discoverable != FALSE && timeout == 0) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); else if (discoverable == FALSE) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE); else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE); } gtk_widget_set_sensitive (button, adapter->powered); adapter->button_discoverable = button; adapter->signal_discoverable = g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(discoverable_changed_cb), adapter); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); /* The friendly name */ vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0); label = create_label(_("Friendly name")); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_box_pack_start (GTK_BOX (vbox), alignment, TRUE, TRUE, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(entry), 248); gtk_widget_set_size_request(entry, 240, -1); gtk_container_add (GTK_CONTAINER (alignment), entry); if (name != NULL) gtk_entry_set_text(GTK_ENTRY(entry), name); adapter->entry = entry; adapter->name_vbox = vbox; g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(name_callback), adapter); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(focus_callback), adapter); gtk_widget_set_sensitive (adapter->name_vbox, adapter->powered); /* The known devices */ table = gtk_table_new(2, 2, FALSE); gtk_box_pack_start(GTK_BOX(mainbox), table, TRUE, TRUE, 0); label = create_label(_("Devices")); gtk_table_attach(GTK_TABLE(table), label, 0, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 6); /* Note that this will only ever show the devices on the default * adapter, this is on purpose */ adapter->chooser = bluetooth_chooser_new (NULL); g_object_set (adapter->chooser, "show-searching", FALSE, "show-device-type", FALSE, "show-device-category", FALSE, "show-pairing", TRUE, "show-connected", TRUE, "device-category-filter", BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED, NULL); g_signal_connect (adapter->chooser, "notify::device-selected", G_CALLBACK(device_selected_cb), adapter); gtk_table_attach(GTK_TABLE(table), adapter->chooser, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); adapter->devices_table = table; buttonbox = gtk_vbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_START); gtk_box_set_spacing(GTK_BOX(buttonbox), 6); gtk_box_set_homogeneous(GTK_BOX(buttonbox), FALSE); gtk_table_attach(GTK_TABLE(table), buttonbox, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 6, 6); button = gtk_button_new_with_mnemonic(_("Set up _new device...")); image = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(wizard_callback), adapter); button = gtk_button_new_with_label(_("Disconnect")); image = gtk_image_new_from_stock(GTK_STOCK_DISCONNECT, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(disconnect_callback), adapter); adapter->button_disconnect = button; button = gtk_button_new_with_mnemonic(_("_Remove")); image = gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remove_callback), adapter); adapter->button_delete = button; gtk_widget_set_sensitive (adapter->devices_table, adapter->powered); g_object_set_data(G_OBJECT(mainbox), "adapter", adapter); gtk_widget_show_all(mainbox); if (adapter->is_default != FALSE) gtk_notebook_set_current_page (GTK_NOTEBOOK (adapter->notebook), page_num); }
void wxCheckBox::DoSet3StateValue(wxCheckBoxState state) { SetValue(state != wxCHK_UNCHECKED); gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(m_widgetCheckbox), state == wxCHK_UNDETERMINED); }
// FIXME_pcm: this is too dirty. Need some refactor later. static void update_permissions (FmFilePropData *data) { FmFileInfo *file_info = (FmFileInfo*)fm_list_peek_head (data->files); GList *l; int sel; char *tmp; mode_t owner_perm = (file_info->mode & S_IRWXU); mode_t group_perm = (file_info->mode & S_IRWXG); mode_t other_perm = (file_info->mode & S_IRWXO); mode_t exec_perm = (file_info->mode & (S_IXUSR|S_IXGRP|S_IXOTH)); uid_t uid = file_info->uid; gid_t gid = file_info->gid; struct group *grp = NULL; struct passwd *pw = NULL; data->all_native = fm_path_is_native (fm_file_info_get_path (file_info)); data->has_dir = S_ISDIR (file_info->mode) != FALSE; for (l=fm_list_peek_head_link (data->files)->next; l; l=l->next) { FmFileInfo *file_info = (FmFileInfo*)l->data; if ( !fm_path_is_native (fm_file_info_get_path (file_info)) ) data->all_native = FALSE; if (S_ISDIR (file_info->mode)) data->has_dir = TRUE; if ( uid != file_info->uid ) uid = -1; if ( gid != file_info->gid ) gid = -1; if ( owner_perm != -1 && owner_perm != (file_info->mode & S_IRWXU) ) owner_perm = -1; if ( group_perm != -1 && group_perm != (file_info->mode & S_IRWXG) ) group_perm = -1; if ( other_perm != -1 && other_perm != (file_info->mode & S_IRWXO) ) other_perm = -1; if ( exec_perm != (file_info->mode & (S_IXUSR|S_IXGRP|S_IXOTH)) ) exec_perm = -1; } if ( data->all_native ) { if ( uid >= 0 ) { pw = getpwuid (uid); if (pw) gtk_entry_set_text (GTK_ENTRY (data->owner), pw->pw_name); } if ( gid >= 0 ) { grp = getgrgid (gid); if (grp) gtk_entry_set_text (GTK_ENTRY (data->group), grp->gr_name); } } if ( uid >=0 && !pw ) { tmp = g_strdup_printf ("%u", uid); gtk_entry_set_text (GTK_ENTRY (data->owner), tmp); g_free (tmp); } if ( gid >=0 && !grp ) { tmp = g_strdup_printf ("%u", gid); gtk_entry_set_text (GTK_ENTRY (data->group), tmp); g_free (tmp); } data->orig_owner = g_strdup (gtk_entry_get_text (GTK_ENTRY (data->owner))); data->orig_group = g_strdup (gtk_entry_get_text (GTK_ENTRY (data->group))); // on local filesystems, only root can do chown. if ( data->all_native && geteuid () != 0 ) { gtk_editable_set_editable (GTK_EDITABLE (data->owner), FALSE); gtk_editable_set_editable (GTK_EDITABLE (data->group), FALSE); } sel = NO_CHANGE; if (owner_perm != -1) { if ( (owner_perm & (S_IRUSR|S_IWUSR)) == (S_IRUSR|S_IWUSR) ) sel = READ_WRITE; else if ( (owner_perm & (S_IRUSR|S_IWUSR)) == S_IRUSR ) sel = READ_ONLY; else if ( (owner_perm & (S_IRUSR|S_IWUSR)) == S_IWUSR ) sel = WRITE_ONLY; else sel = NONE; } gtk_combo_box_set_active (GTK_COMBO_BOX (data->owner_perm), sel); data->owner_perm_sel = sel; sel = NO_CHANGE; if (group_perm != -1) { if ( (group_perm & (S_IRGRP|S_IWGRP)) == (S_IRGRP|S_IWGRP) ) sel = READ_WRITE; else if ( (group_perm & (S_IRGRP|S_IWGRP)) == S_IRGRP ) sel = READ_ONLY; else if ( (group_perm & (S_IRGRP|S_IWGRP)) == S_IWGRP ) sel = WRITE_ONLY; else sel = NONE; } gtk_combo_box_set_active (GTK_COMBO_BOX (data->group_perm), sel); data->group_perm_sel = sel; sel = NO_CHANGE; if (other_perm != -1) { if ( (other_perm & (S_IROTH|S_IWOTH)) == (S_IROTH|S_IWOTH) ) sel = READ_WRITE; else if ( (other_perm & (S_IROTH|S_IWOTH)) == S_IROTH ) sel = READ_ONLY; else if ( (other_perm & (S_IROTH|S_IWOTH)) == S_IWOTH ) sel = WRITE_ONLY; else sel = NONE; } gtk_combo_box_set_active (GTK_COMBO_BOX (data->other_perm), sel); data->other_perm_sel = sel; if (data->has_dir) gtk_widget_hide ( data->exec ); if ( exec_perm != -1 ) { gboolean xusr = (exec_perm & S_IXUSR) != 0; gboolean xgrp = (exec_perm & S_IXGRP) != 0; gboolean xoth = (exec_perm & S_IXOTH) != 0; if ( xusr == xgrp && xusr == xoth ) // executable { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->exec), xusr); data->exec_state = xusr; } else // inconsistent { gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (data->exec), TRUE); g_signal_connect (data->exec, "toggled", G_CALLBACK (on_exec_toggled), data); data->exec_state = -1; } } else // inconsistent { gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (data->exec), TRUE); g_signal_connect (data->exec, "toggled", G_CALLBACK (on_exec_toggled), data); data->exec_state = -1; } }
void dlg_password (GtkWidget *widget, gpointer callback_data) { FrWindow *window = callback_data; DialogData *data; GtkWidget *content_area; char *basename; char *title; data = g_new0 (DialogData, 1); data->window = window; data->builder = _gtk_builder_new_from_resource ("password.ui"); if (data->builder == NULL) { g_free (data); return; } /* Set widgets data. */ data->dialog = g_object_new (GTK_TYPE_DIALOG, "transient-for", GTK_WINDOW (window), "modal", TRUE, "use-header-bar", _gtk_settings_get_dialogs_use_header (), NULL); content_area = gtk_dialog_get_content_area (GTK_DIALOG (data->dialog)); gtk_container_add (GTK_CONTAINER (content_area), GET_WIDGET ("password_vbox")); gtk_dialog_add_buttons (GTK_DIALOG (data->dialog), _GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL, _GTK_LABEL_SAVE, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK); gtk_style_context_add_class (gtk_widget_get_style_context (gtk_dialog_get_widget_for_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK)), GTK_STYLE_CLASS_SUGGESTED_ACTION); basename = _g_file_get_display_basename (fr_archive_get_file (window->archive)); title = g_strdup_printf (_("Enter a password for “%s”"), basename); gtk_label_set_text (GTK_LABEL (GET_WIDGET ("title_label")), title); g_free (title); g_free (basename); _gtk_entry_use_as_password_entry (GTK_ENTRY (GET_WIDGET ("password_entry"))); _gtk_entry_set_locale_text (GTK_ENTRY (GET_WIDGET ("password_entry")), fr_window_get_password (window)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("encrypt_header_checkbutton")), fr_window_get_encrypt_header (window)); if (! fr_archive_is_capable_of (window->archive, FR_ARCHIVE_CAN_ENCRYPT_HEADER)) { gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (GET_WIDGET ("encrypt_header_checkbutton")), TRUE); gtk_widget_set_sensitive (GET_WIDGET ("encrypt_header_checkbutton"), FALSE); } /* Set the signals handlers. */ g_signal_connect ((data->dialog), "destroy", G_CALLBACK (destroy_cb), data); g_signal_connect ((data->dialog), "response", G_CALLBACK (response_cb), data); /* Run dialog. */ gtk_widget_grab_focus (GET_WIDGET ("password_entry")); gtk_widget_show (data->dialog); }
static void hildon_font_selection_dialog_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { gint i, size; const gchar *family; gboolean b; GdkColor *color = NULL; GdkColor black; HildonFontSelectionDialogPrivate *priv = HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE (object); g_assert (priv); black.red = black.green = black.blue = 0; switch (prop_id) { case PROP_FAMILY: family = g_value_get_string (value); g_return_if_fail (family != NULL); for(i = 0; i < priv->n_families; i++) { if (strcmp (family, pango_font_family_get_name (priv->families[i])) == 0) { gtk_combo_box_set_active (GTK_COMBO_BOX (priv->cbx_font_type), i); break; } } break; case PROP_FAMILY_SET: b = g_value_get_boolean (value); if(!b) gtk_combo_box_set_active (GTK_COMBO_BOX (priv->cbx_font_type), -1); break; case PROP_SIZE: size = g_value_get_int (value); for(i = 0; i < G_N_ELEMENTS (font_sizes); i++) { if(size == font_sizes[i]) { gtk_combo_box_set_active (GTK_COMBO_BOX (priv->cbx_font_size), i); break; } } break; case PROP_SIZE_SET: b = g_value_get_boolean (value); if(!b) gtk_combo_box_set_active (GTK_COMBO_BOX (priv->cbx_font_size), -1); break; case PROP_COLOR: color = (GdkColor *) g_value_get_boxed (value); if(color != NULL) hildon_color_button_set_color (HILDON_COLOR_BUTTON (priv->font_color_button), color); else hildon_color_button_set_color (HILDON_COLOR_BUTTON (priv->font_color_button), &black); break; case PROP_COLOR_SET: priv->color_set = g_value_get_boolean (value); if(! priv->color_set) { /* set color to black, but block our signal handler */ g_signal_handler_block ((gpointer) priv->font_color_button, priv->color_modified_signal_handler); hildon_color_button_set_color (HILDON_COLOR_BUTTON (priv->font_color_button), &black); g_signal_handler_unblock ((gpointer) priv->font_color_button, priv->color_modified_signal_handler); } break; case PROP_BOLD: /* this call will make sure that we dont get extra clicked signal */ gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON(priv->chk_bold), FALSE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(priv->chk_bold), g_value_get_boolean (value)); break; case PROP_BOLD_SET: gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (priv->chk_bold),! g_value_get_boolean(value)); break; case PROP_ITALIC: gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(priv->chk_italic), FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->chk_italic), g_value_get_boolean(value)); break; case PROP_ITALIC_SET: gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(priv->chk_italic), !g_value_get_boolean(value)); break; case PROP_UNDERLINE: gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON (priv->chk_underline), FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->chk_underline), g_value_get_boolean(value)); break; case PROP_UNDERLINE_SET: gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(priv->chk_underline), !g_value_get_boolean(value)); break; case PROP_STRIKETHROUGH: gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON (priv->chk_strikethrough), FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->chk_strikethrough), g_value_get_boolean(value)); break; case PROP_STRIKETHROUGH_SET: gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON (priv->chk_strikethrough), !g_value_get_boolean(value)); break; case PROP_POSITION: i = g_value_get_int(value); if( i == 1 ) gtk_combo_box_set_active(GTK_COMBO_BOX(priv->cbx_positioning), 1); else if(i == -1) gtk_combo_box_set_active(GTK_COMBO_BOX(priv->cbx_positioning), 2); else gtk_combo_box_set_active(GTK_COMBO_BOX(priv->cbx_positioning), 0); break; case PROP_FONT_SCALING: priv->font_scaling = g_value_get_double(value); break; case PROP_POSITION_SET: b = g_value_get_boolean(value); if(!b) gtk_combo_box_set_active(GTK_COMBO_BOX(priv->cbx_positioning), -1); break; case PROP_PREVIEW_TEXT: hildon_font_selection_dialog_set_preview_text( HILDON_FONT_SELECTION_DIALOG(object), g_value_get_string(value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static gint moz_gtk_toggle_paint(GdkDrawable* drawable, GdkRectangle* rect, GdkRectangle* cliprect, GtkWidgetState* state, gboolean selected, gboolean inconsistent, gboolean isradio, GtkTextDirection direction) { GtkStateType state_type = ConvertGtkState(state); GtkShadowType shadow_type = (selected)?GTK_SHADOW_IN:GTK_SHADOW_OUT; gint indicator_size, indicator_spacing; gint x, y, width, height; gint focus_x, focus_y, focus_width, focus_height; GtkWidget *w; GtkStyle *style; if (isradio) { moz_gtk_radio_get_metrics(&indicator_size, &indicator_spacing); w = gParts->radiobuttonWidget; } else { moz_gtk_checkbox_get_metrics(&indicator_size, &indicator_spacing); w = gParts->checkboxWidget; } // "GetMinimumWidgetSize was ignored" // FIXME: This assert causes a build failure in WebKitGTK+ debug // builds, because it uses 'false' in its definition. We may want // to force this file to be built with g++, by renaming it. // ASSERT(rect->width == indicator_size); /* * vertically center in the box, since XUL sometimes ignores our * GetMinimumWidgetSize in the vertical dimension */ x = rect->x; y = rect->y + (rect->height - indicator_size) / 2; width = indicator_size; height = indicator_size; focus_x = x - indicator_spacing; focus_y = y - indicator_spacing; focus_width = width + 2 * indicator_spacing; focus_height = height + 2 * indicator_spacing; style = gtk_widget_get_style(w); TSOffsetStyleGCs(style, x, y); gtk_widget_set_sensitive(w, !state->disabled); gtk_widget_set_direction(w, direction); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), selected); if (isradio) { gtk_paint_option(style, drawable, state_type, shadow_type, cliprect, gParts->radiobuttonWidget, "radiobutton", x, y, width, height); if (state->focused) { gtk_paint_focus(style, drawable, GTK_STATE_ACTIVE, cliprect, gParts->radiobuttonWidget, "radiobutton", focus_x, focus_y, focus_width, focus_height); } } else { /* * 'indeterminate' type on checkboxes. In GTK, the shadow type * must also be changed for the state to be drawn. */ if (inconsistent) { gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(gParts->checkboxWidget), TRUE); shadow_type = GTK_SHADOW_ETCHED_IN; } else { gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(gParts->checkboxWidget), FALSE); } gtk_paint_check(style, drawable, state_type, shadow_type, cliprect, gParts->checkboxWidget, "checkbutton", x, y, width, height); if (state->focused) { gtk_paint_focus(style, drawable, GTK_STATE_ACTIVE, cliprect, gParts->checkboxWidget, "checkbutton", focus_x, focus_y, focus_width, focus_height); } } return MOZ_GTK_SUCCESS; }