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;
}