static void
gail_toggle_button_real_notify_gtk (GObject *obj,
GParamSpec *pspec)
{
GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (obj);
AtkObject *atk_obj;
atk_obj = gtk_widget_get_accessible (GTK_WIDGET (toggle_button));
if (strcmp (pspec->name, "inconsistent") == 0)
atk_object_notify_state_change (atk_obj, ATK_STATE_ENABLED,
(gtk_widget_get_sensitive (GTK_WIDGET (toggle_button)) &&
!gtk_toggle_button_get_inconsistent (toggle_button)));
else if (strcmp (pspec->name, "sensitive") == 0)
{
/* Need to override gailwidget behavior of notifying for ENABLED */
gboolean sensitive;
gboolean enabled;
sensitive = gtk_widget_get_sensitive (GTK_WIDGET (toggle_button));
enabled = sensitive &&
!gtk_toggle_button_get_inconsistent (toggle_button);
atk_object_notify_state_change (atk_obj, ATK_STATE_SENSITIVE, sensitive);
atk_object_notify_state_change (atk_obj, ATK_STATE_ENABLED, enabled);
}
else
GAIL_WIDGET_CLASS (gail_toggle_button_parent_class)->notify_gtk (obj, pspec);
}
static AtkStateSet*
gail_toggle_button_ref_state_set (AtkObject *accessible)
{
AtkStateSet *state_set;
GtkToggleButton *toggle_button;
GtkWidget *widget;
state_set = ATK_OBJECT_CLASS (gail_toggle_button_parent_class)->ref_state_set (accessible);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
if (widget == NULL)
return state_set;
toggle_button = GTK_TOGGLE_BUTTON (widget);
if (gtk_toggle_button_get_active (toggle_button))
atk_state_set_add_state (state_set, ATK_STATE_CHECKED);
if (gtk_toggle_button_get_inconsistent (toggle_button))
{
atk_state_set_remove_state (state_set, ATK_STATE_ENABLED);
atk_state_set_add_state (state_set, ATK_STATE_INDETERMINATE);
}
return state_set;
}
static void
gtk_toggle_button_accessible_notify_gtk (GObject *obj,
GParamSpec *pspec)
{
GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (obj);
AtkObject *atk_obj;
gboolean sensitive;
gboolean inconsistent;
atk_obj = gtk_widget_get_accessible (GTK_WIDGET (toggle_button));
sensitive = gtk_widget_get_sensitive (GTK_WIDGET (toggle_button));
inconsistent = gtk_toggle_button_get_inconsistent (toggle_button);
if (strcmp (pspec->name, "inconsistent") == 0)
{
atk_object_notify_state_change (atk_obj, ATK_STATE_INDETERMINATE, inconsistent);
atk_object_notify_state_change (atk_obj, ATK_STATE_ENABLED, (sensitive && !inconsistent));
}
else if (strcmp (pspec->name, "sensitive") == 0)
{
/* Need to override gailwidget behavior of notifying for ENABLED */
atk_object_notify_state_change (atk_obj, ATK_STATE_SENSITIVE, sensitive);
atk_object_notify_state_change (atk_obj, ATK_STATE_ENABLED, (sensitive && !inconsistent));
}
else
GTK_WIDGET_ACCESSIBLE_CLASS (gtk_toggle_button_accessible_parent_class)->notify_gtk (obj, pspec);
}
static gboolean
panel_toggle_button_draw (GtkWidget *widget, cairo_t *cr)
{
GtkWidget *child = gtk_bin_get_child (GTK_BIN (widget));
GtkStateType state_type;
GtkShadowType shadow_type;
GtkAllocation allocation;
GtkStyleContext *context = gtk_widget_get_style_context (widget);
GtkStateFlags flags = 0;
state_type = gtk_widget_get_state (widget);
/* FIXME: someone make this layout work nicely for all themes
* Currently I'm trying to imitate the volume applet's widget */
if (gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (widget))) {
if (state_type == GTK_STATE_ACTIVE)
state_type = GTK_STATE_NORMAL;
shadow_type = GTK_SHADOW_ETCHED_IN;
} else {
shadow_type = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)) ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
}
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
state_type = GTK_STATE_SELECTED;
/* FIXME: better detail? */
gtk_widget_get_allocation (widget, &allocation);
gtk_style_context_add_class (context, "togglebutton");
switch (state_type)
{
case GTK_STATE_PRELIGHT:
flags |= GTK_STATE_FLAG_PRELIGHT;
break;
case GTK_STATE_SELECTED:
flags |= GTK_STATE_FLAG_SELECTED;
break;
case GTK_STATE_INSENSITIVE:
flags |= GTK_STATE_FLAG_INSENSITIVE;
break;
case GTK_STATE_ACTIVE:
flags |= GTK_STATE_FLAG_ACTIVE;
break;
case GTK_STATE_FOCUSED:
flags |= GTK_STATE_FLAG_FOCUSED;
break;
case GTK_STATE_NORMAL:
case GTK_STATE_INCONSISTENT:
default:
break;
}
gtk_style_context_set_state (context, flags);
gtk_render_background (context, cr, (gdouble) allocation.x, (gdouble) allocation.y,
(gdouble) allocation.width, (gdouble) allocation.height);
(void) shadow_type;
if (child)
gtk_container_propagate_draw (GTK_CONTAINER (widget), child, cr);
return FALSE;
}
static int gtkToggleGetCheck(Ihandle* ih)
{
if (gtk_toggle_button_get_inconsistent((GtkToggleButton*)ih->handle))
return -1;
if (gtk_toggle_button_get_active((GtkToggleButton*)ih->handle))
return 1;
else
return 0;
}
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);
}
wxCheckBoxState wxCheckBox::DoGet3StateValue() const
{
if (gtk_toggle_button_get_inconsistent(GTK_TOGGLE_BUTTON(m_widgetCheckbox)))
{
return wxCHK_UNDETERMINED;
}
else
{
return GetValue() ? wxCHK_CHECKED : wxCHK_UNCHECKED;
}
}
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
gail_toggle_button_real_notify_gtk (GObject *obj,
GParamSpec *pspec)
{
GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (obj);
AtkObject *atk_obj;
atk_obj = gtk_widget_get_accessible (GTK_WIDGET (toggle_button));
if (strcmp (pspec->name, "inconsistent") == 0)
atk_object_notify_state_change (atk_obj, ATK_STATE_ENABLED,
!gtk_toggle_button_get_inconsistent (toggle_button));
else
GAIL_WIDGET_CLASS (gail_toggle_button_parent_class)->notify_gtk (obj, pspec);
}
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);
}
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 );
}
void
on_dlg_response ( GtkDialog *dialog,
gint response_id,
gpointer user_data )
{
FilePropertiesDialogData * data;
PtkFileTask* task;
gboolean mod_change;
uid_t uid = -1;
gid_t gid = -1;
const char* owner_name;
const char* group_name;
int i;
GList* l;
GList* file_list;
char* file_path;
GtkWidget* ask_recursive;
VFSFileInfo* file;
GtkAllocation allocation;
gtk_widget_get_allocation ( GTK_WIDGET( dialog ), &allocation );
int width = allocation.width;
int height = allocation.height;
if ( width && height )
{
char* str = g_strdup_printf( "%d", width );
xset_set( "app_dlg", "s", str );
g_free( str );
str = g_strdup_printf( "%d", height );
xset_set( "app_dlg", "z", str );
g_free( str );
}
data = ( FilePropertiesDialogData* ) g_object_get_data( G_OBJECT( dialog ),
"DialogData" );
if ( data )
{
if ( data->update_label_timer )
g_source_remove( data->update_label_timer );
data->cancel = TRUE;
if ( data->calc_size_thread )
g_thread_join( data->calc_size_thread );
if ( response_id == GTK_RESPONSE_OK )
{
GtkWidget* open_with;
/* Set default action for mimetype */
if( ( open_with = (GtkWidget*)g_object_get_data( G_OBJECT(dialog), "open_with" ) ) )
{
GtkTreeModel* model = gtk_combo_box_get_model( GTK_COMBO_BOX(open_with) );
GtkTreeIter it;
if( model && gtk_combo_box_get_active_iter( GTK_COMBO_BOX(open_with), &it ) )
{
char* action;
gtk_tree_model_get( model, &it, 2, &action, -1 );
if( action )
{
file = ( VFSFileInfo* ) data->file_list->data;
VFSMimeType* mime = vfs_file_info_get_mime_type( file );
vfs_mime_type_set_default_action( mime, action );
vfs_mime_type_unref( mime );
g_free( action );
}
}
}
/* Check if we need chown */
owner_name = gtk_entry_get_text( data->owner );
if ( owner_name && *owner_name &&
(!data->owner_name || strcmp( owner_name, data->owner_name ) ) )
{
uid = uid_from_name( owner_name );
if ( uid == -1 )
{
ptk_show_error( GTK_WINDOW( dialog ), _("Error"), _( "Invalid User" ) );
return ;
}
}
group_name = gtk_entry_get_text( data->group );
if ( group_name && *group_name &&
(!data->group_name || strcmp( group_name, data->group_name ) ) )
{
gid = gid_from_name( group_name );
if ( gid == -1 )
{
ptk_show_error( GTK_WINDOW( dialog ), _("Error"), _( "Invalid Group" ) );
return ;
}
}
for ( i = 0; i < N_CHMOD_ACTIONS; ++i )
{
if ( gtk_toggle_button_get_inconsistent( data->chmod_btns[ i ] ) )
{
data->chmod_states[ i ] = 2; /* Don't touch this bit */
}
else if ( data->chmod_states[ i ] != gtk_toggle_button_get_active( data->chmod_btns[ i ] ) )
{
mod_change = TRUE;
data->chmod_states[ i ] = gtk_toggle_button_get_active( data->chmod_btns[ i ] );
}
else /* Don't change this bit */
{
data->chmod_states[ i ] = 2;
}
}
if ( uid != -1 || gid != -1 || mod_change )
{
file_list = NULL;
for ( l = data->file_list; l; l = l->next )
{
file = ( VFSFileInfo* ) l->data;
file_path = g_build_filename( data->dir_path,
vfs_file_info_get_name( file ), NULL );
file_list = g_list_prepend( file_list, file_path );
}
task = ptk_file_task_new( VFS_FILE_TASK_CHMOD_CHOWN,
file_list,
NULL,
GTK_WINDOW(gtk_widget_get_parent( GTK_WIDGET( dialog ) )),
NULL );
//MOD
ptk_file_task_set_recursive( task,
gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON( data->recurse ) ) );
/*
for ( l = data->file_list; l; l = l->next )
{
file = ( VFSFileInfo* ) l->data;
if ( vfs_file_info_is_dir( file ) )
{
ask_recursive = gtk_message_dialog_new(
GTK_WINDOW( data->dlg ),
GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
_( "Do you want to recursively apply these changes to all files and sub-folders?" ) );
ptk_file_task_set_recursive( task,
( GTK_RESPONSE_YES == gtk_dialog_run( GTK_DIALOG( ask_recursive ) ) ) );
gtk_widget_destroy( ask_recursive );
break;
}
}
*/
if ( mod_change )
{
/* If the permissions of file has been changed by the user */
ptk_file_task_set_chmod( task, data->chmod_states );
}
/* For chown */
ptk_file_task_set_chown( task, uid, gid );
ptk_file_task_run( task );
/*
* This file list will be freed by file operation, so we don't
* need to do this. Just set the pointer to NULL.
*/
data->file_list = NULL;
}
}
g_free( data->owner_name );
g_free( data->group_name );
/*
*NOTE: File operation chmod/chown will free the list when it's done,
*and we only need to free it when there is no file operation applyed.
*/
g_slice_free( FilePropertiesDialogData, data );
}
gtk_widget_destroy( GTK_WIDGET( dialog ) );
}
static int
extract_cb (GtkWidget *w,
DialogData *data)
{
FrWindow *window = data->window;
gboolean do_not_extract = FALSE;
char *extract_to_dir;
gboolean overwrite;
gboolean skip_newer;
gboolean selected_files;
gboolean pattern_files;
gboolean junk_paths;
GList *file_list;
char *base_dir = NULL;
GError *error = NULL;
data->extract_clicked = TRUE;
/* collect extraction options. */
extract_to_dir = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (data->dialog));
/* check directory existence. */
if (! uri_is_dir (extract_to_dir)) {
if (! ForceDirectoryCreation) {
GtkWidget *d;
int r;
char *folder_name;
char *msg;
folder_name = g_filename_display_name (extract_to_dir);
msg = g_strdup_printf (_("Destination folder \"%s\" does not exist.\n\nDo you want to create it?"), folder_name);
g_free (folder_name);
d = _gtk_message_dialog_new (GTK_WINDOW (data->dialog),
GTK_DIALOG_MODAL,
GTK_STOCK_DIALOG_QUESTION,
msg,
NULL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("Create _Folder"), GTK_RESPONSE_YES,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_YES);
r = gtk_dialog_run (GTK_DIALOG (d));
gtk_widget_destroy (GTK_WIDGET (d));
g_free (msg);
if (r != GTK_RESPONSE_YES)
do_not_extract = TRUE;
}
if (! do_not_extract && ! ensure_dir_exists (extract_to_dir, 0755, &error)) {
GtkWidget *d;
d = _gtk_error_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
NULL,
_("Extraction not performed"),
_("Could not create the destination folder: %s."),
error->message);
gtk_dialog_run (GTK_DIALOG (d));
gtk_widget_destroy (GTK_WIDGET (d));
g_error_free (error);
return FALSE;
}
}
if (do_not_extract) {
GtkWidget *d;
d = _gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_DIALOG_WARNING,
_("Extraction not performed"),
NULL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_OK);
gtk_dialog_run (GTK_DIALOG (d));
gtk_widget_destroy (GTK_WIDGET (d));
if (fr_window_is_batch_mode (data->window))
gtk_widget_destroy (data->dialog);
return FALSE;
}
/* check extraction directory permissions. */
if (uri_is_dir (extract_to_dir)
&& ! check_permissions (extract_to_dir, R_OK | W_OK))
{
GtkWidget *d;
char *utf8_path;
utf8_path = g_filename_display_name (extract_to_dir);
d = _gtk_error_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
NULL,
_("Extraction not performed"),
_("You don't have the right permissions to extract archives in the folder \"%s\""),
utf8_path);
gtk_dialog_run (GTK_DIALOG (d));
gtk_widget_destroy (GTK_WIDGET (d));
g_free (utf8_path);
g_free (extract_to_dir);
return FALSE;
}
fr_window_set_extract_default_dir (window, extract_to_dir, TRUE);
overwrite = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_overwrite_checkbutton));
skip_newer = ! gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton)) && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton));
junk_paths = ! gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_recreate_dir_checkbutton));
g_settings_set_boolean (data->settings, PREF_EXTRACT_OVERWRITE, overwrite);
if (! gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton)))
g_settings_set_boolean (data->settings, PREF_EXTRACT_SKIP_NEWER, skip_newer);
g_settings_set_boolean (data->settings, PREF_EXTRACT_RECREATE_FOLDERS, ! junk_paths);
selected_files = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_selected_radiobutton));
pattern_files = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_files_radiobutton));
/* create the file list. */
file_list = NULL;
if (selected_files) {
file_list = data->selected_files;
data->selected_files = NULL; /* do not the list when destroying the dialog. */
}
else if (pattern_files) {
const char *pattern;
pattern = gtk_entry_get_text (GTK_ENTRY (data->e_files_entry));
file_list = fr_window_get_file_list_pattern (window, pattern);
if (file_list == NULL) {
gtk_widget_destroy (data->dialog);
g_free (extract_to_dir);
return FALSE;
}
}
if (selected_files) {
base_dir = data->base_dir_for_selection;
data->base_dir_for_selection = NULL;
}
else
base_dir = NULL;
/* close the dialog. */
gtk_widget_destroy (data->dialog);
/* extract ! */
fr_window_archive_extract (window,
file_list,
extract_to_dir,
base_dir,
skip_newer,
overwrite ? FR_OVERWRITE_YES : FR_OVERWRITE_NO,
junk_paths,
TRUE);
path_list_free (file_list);
g_free (extract_to_dir);
g_free (base_dir);
return TRUE;
}
static void
hildon_font_selection_dialog_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
gint i;
GdkColor color;
HildonFontSelectionDialogPrivate *priv =
HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE(object);
g_assert (priv);
switch (prop_id)
{
case PROP_FAMILY:
i = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->cbx_font_type));
if(i >= 0 && i < priv->n_families)
g_value_set_string(value,
pango_font_family_get_name (priv->families[i]));
else
g_value_set_string (value, "Sans");
/* FIXME Bad hardcoding here */
break;
case PROP_FAMILY_SET:
i = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->cbx_font_type));
if(i >= 0 && i < priv->n_families)
g_value_set_boolean (value, TRUE);
else
g_value_set_boolean (value, FALSE);
break;
case PROP_SIZE:
i = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->cbx_font_size));
if(i >= 0 && i < G_N_ELEMENTS (font_sizes))
g_value_set_int (value, font_sizes[i]);
else
g_value_set_int (value, 16);
break;
case PROP_SIZE_SET:
i = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->cbx_font_size));
if(i >= 0 && i < G_N_ELEMENTS (font_sizes))
g_value_set_boolean (value, TRUE);
else
g_value_set_boolean (value, FALSE);
break;
case PROP_COLOR:
hildon_color_button_get_color
(HILDON_COLOR_BUTTON (priv->font_color_button), &color);
g_value_set_boxed (value, (gconstpointer) &color);
break;
case PROP_COLOR_SET:
g_value_set_boolean (value, priv->color_set);
break;
case PROP_BOLD:
g_value_set_boolean (value,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->chk_bold)));
break;
case PROP_BOLD_SET:
g_value_set_boolean (value,
! gtk_toggle_button_get_inconsistent
(GTK_TOGGLE_BUTTON (priv->chk_bold)));
break;
case PROP_ITALIC:
g_value_set_boolean (value,
gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (priv->chk_italic)));
break;
case PROP_ITALIC_SET:
g_value_set_boolean (value,
! gtk_toggle_button_get_inconsistent
(GTK_TOGGLE_BUTTON (priv->chk_italic)));
break;
case PROP_UNDERLINE:
g_value_set_boolean (value,
gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (priv->chk_underline)));
break;
case PROP_UNDERLINE_SET:
g_value_set_boolean (value,
! gtk_toggle_button_get_inconsistent
(GTK_TOGGLE_BUTTON (priv->chk_underline)));
break;
case PROP_STRIKETHROUGH:
g_value_set_boolean(value,
gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (priv->chk_strikethrough)));
break;
case PROP_STRIKETHROUGH_SET:
g_value_set_boolean(value,
! gtk_toggle_button_get_inconsistent
(GTK_TOGGLE_BUTTON (priv->chk_strikethrough)));
break;
case PROP_POSITION:
i = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->cbx_positioning));
if(i == 1) /* super */
g_value_set_int (value, 1);
else if(i == 2)/* sub */
g_value_set_int (value, -1);
else
g_value_set_int (value, 0);
break;
case PROP_FONT_SCALING:
g_value_set_double (value, priv->font_scaling);
break;
case PROP_POSITION_SET:
i = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->cbx_positioning));
if(i >= 0 && i < 3)
g_value_set_boolean (value, TRUE);
else
g_value_set_boolean (value, FALSE);
break;
case PROP_PREVIEW_TEXT:
g_value_set_string (value,
hildon_font_selection_dialog_get_preview_text (HILDON_FONT_SELECTION_DIALOG (object)));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
GValue*
ghb_widget_value(GtkWidget *widget)
{
GValue *value = NULL;
const gchar *name;
GType type;
if (widget == NULL)
{
g_debug("NULL widget\n");
return NULL;
}
type = G_OBJECT_TYPE(widget);
name = ghb_get_setting_key(widget);
g_debug("ghb_widget_value widget (%s)\n", name);
if (type == GTK_TYPE_ENTRY)
{
const gchar *str = gtk_entry_get_text(GTK_ENTRY(widget));
value = ghb_string_value_new(str);
}
else if (type == GTK_TYPE_RADIO_BUTTON)
{
g_debug("\tradio_button");
gboolean bval;
bval = gtk_toggle_button_get_inconsistent(GTK_TOGGLE_BUTTON(widget));
if (bval)
{
value = ghb_boolean_value_new(FALSE);
}
else
{
bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
value = ghb_boolean_value_new(bval);
}
}
else if (type == GTK_TYPE_CHECK_BUTTON)
{
g_debug("\tcheck_button");
gboolean bval;
bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
value = ghb_boolean_value_new(bval);
}
else if (type == GTK_TYPE_TOGGLE_TOOL_BUTTON)
{
g_debug("\ttoggle_tool_button");
gboolean bval;
bval = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(widget));
value = ghb_boolean_value_new(bval);
}
else if (type == GTK_TYPE_TOGGLE_BUTTON)
{
g_debug("\ttoggle_button");
gboolean bval;
bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
value = ghb_boolean_value_new(bval);
}
else if (type == GTK_TYPE_CHECK_MENU_ITEM)
{
g_debug("\tcheck_menu_item");
gboolean bval;
bval = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
value = ghb_boolean_value_new(bval);
}
else if (type == GTK_TYPE_COMBO_BOX)
{
g_debug("\tcombo_box");
GtkTreeModel *store;
GtkTreeIter iter;
gchar *shortOpt;
store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter))
{
gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
value = ghb_string_value_new(shortOpt);
g_free(shortOpt);
}
else if (gtk_combo_box_get_has_entry(GTK_COMBO_BOX(widget)))
{
const gchar *str;
str = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(widget))));
if (str == NULL) str = "";
value = ghb_string_value_new(str);
}
else
{
value = ghb_string_value_new("");
}
}
else if (type == GTK_TYPE_SPIN_BUTTON)
{
gint ival;
ival = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
value = ghb_int64_value_new(ival);
}
else if (type == GTK_TYPE_SCALE)
{
gdouble dval;
gint digits;
digits = gtk_scale_get_digits(GTK_SCALE(widget));
dval = gtk_range_get_value(GTK_RANGE(widget));
if (digits)
{
value = ghb_double_value_new(dval);
}
else
{
value = ghb_int_value_new(dval);
}
}
else if (type == GTK_TYPE_SCALE_BUTTON)
{
gdouble dval;
dval = gtk_scale_button_get_value(GTK_SCALE_BUTTON(widget));
value = ghb_double_value_new(dval);
}
else if (type == GTK_TYPE_TEXT_VIEW)
{
GtkTextBuffer *buffer;
GtkTextIter start, end;
gchar *str;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
gtk_text_buffer_get_bounds(buffer, &start, &end);
str = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
value = ghb_string_value_new(str);
g_free(str);
}
else if (type == GTK_TYPE_LABEL)
{
const gchar *str;
str = gtk_label_get_text (GTK_LABEL(widget));
value = ghb_string_value_new(str);
}
else if (type == GTK_TYPE_FILE_CHOOSER_BUTTON)
{
gchar *str = NULL;
str = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(widget));
if (str == NULL)
{
str = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(widget));
}
value = ghb_string_value_new(str);
if (str != NULL)
g_free(str);
}
else
{
g_debug("Attempt to set unknown widget type: %s\n", name);
g_free(value);
value = NULL;
}
return value;
}
static void on_response (GtkDialog *dlg, int response, FmFilePropData *data)
{
if ( response == GTK_RESPONSE_OK )
{
int sel;
const char *new_owner = gtk_entry_get_text (GTK_ENTRY (data->owner));
const char *new_group = gtk_entry_get_text (GTK_ENTRY (data->group));
guint32 uid = -1, gid = -1;
mode_t new_mode = 0, new_mode_mask = 0;
if (!ensure_valid_owner (data) || !ensure_valid_group (data))
{
g_signal_stop_emission_by_name (dlg, "response");
return;
}
/* FIXME_pcm: if all files are native, it's possible to check
* if the names are legal user and group names on the local
* machine prior to chown. */
if (new_owner && *new_owner && g_strcmp0 (data->orig_owner, new_owner))
{
// change owner
g_debug ("change owner to: %d", data->uid);
}
else
data->uid = -1;
if (new_group && *new_group && g_strcmp0 (data->orig_group, new_group))
{
// change group
g_debug ("change group to: %d", data->gid);
}
else
data->gid = -1;
// check if chmod is needed here.
sel = gtk_combo_box_get_active (GTK_COMBO_BOX (data->owner_perm));
if ( sel != NO_CHANGE ) // need to change owner permission
{
if (data->owner_perm_sel != sel) // new value is different from original
{
new_mode_mask |= S_IRUSR|S_IWUSR;
data->owner_perm_sel = sel;
switch (sel)
{
case READ_WRITE:
new_mode |= S_IRUSR|S_IWUSR;
break;
case READ_ONLY:
new_mode |= S_IRUSR;
break;
case WRITE_ONLY:
new_mode |= S_IWUSR;
break;
}
}
else // otherwise, no change
data->owner_perm_sel = NO_CHANGE;
}
else
data->owner_perm_sel = NO_CHANGE;
sel = gtk_combo_box_get_active (GTK_COMBO_BOX (data->group_perm));
if ( sel != NO_CHANGE ) // need to change group permission
{
if (data->group_perm_sel != sel) // new value is different from original
{
new_mode_mask |= S_IRGRP|S_IWGRP;
data->group_perm_sel = sel;
switch (sel)
{
case READ_WRITE:
new_mode |= S_IRGRP|S_IWGRP;
break;
case READ_ONLY:
new_mode |= S_IRGRP;
break;
case WRITE_ONLY:
new_mode |= S_IWGRP;
break;
}
}
else // otherwise, no change
data->group_perm_sel = NO_CHANGE;
}
else
data->group_perm_sel = NO_CHANGE;
#if 0
sel = gtk_combo_box_get_active (GTK_COMBO_BOX (data->other_perm));
if ( sel != NO_CHANGE ) // need to change other permission
{
if (data->other_perm_sel != sel) // new value is different from original
{
new_mode_mask |= S_IROTH|S_IWOTH;
switch (sel)
{
case READ_WRITE:
new_mode |= S_IROTH|S_IWOTH;
break;
case READ_ONLY:
new_mode |= S_IROTH;
break;
case WRITE_ONLY:
new_mode |= S_IWOTH;
break;
}
data->other_perm_sel = sel;
}
else // otherwise, no change
data->other_perm_sel = NO_CHANGE;
}
else
data->other_perm_sel = NO_CHANGE;
if (!data->has_dir
&& !gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (data->exec))
&& gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->exec)) != data->exec_state)
{
new_mode_mask |= (S_IXUSR|S_IXGRP|S_IXOTH);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->exec)))
new_mode |= (S_IXUSR|S_IXGRP|S_IXOTH);
}
if (new_mode_mask || data->uid != -1 || data->gid != -1)
{
FmPathList *paths = fm_path_list_new_from_file_info_list (data->files);
FmFileOpsJob *job = (FmFileOpsJob*) fm_file_ops_job_new (FM_FILE_OP_CHANGE_ATTR, paths);
// need to chown
if (data->uid != -1 || data->gid != -1)
fm_file_ops_job_set_chown (job, data->uid, data->gid);
// need to do chmod
if (new_mode_mask)
fm_file_ops_job_set_chmod (job, new_mode, new_mode_mask);
if (data->has_dir)
{
if (fm_yes_no (GTK_WINDOW (data->dlg), NULL, _( "Do you want to recursively apply these changes to all files and sub-folders?" ), TRUE))
fm_file_ops_job_set_recursive (job, TRUE);
}
// show progress dialog
fm_file_ops_job_run_with_progress (GTK_WINDOW (data->dlg), job);
fm_list_unref (paths);
}
// change default application for the mime-type if needed
if (data->mime_type && fm_mime_type_get_type (data->mime_type) && data->open_with)
{
GAppInfo *app;
gboolean default_app_changed = FALSE;
GError *err = NULL;
app = fm_app_chooser_combo_box_get_selected (GTK_COMBO_BOX (data->open_with), &default_app_changed);
if (app)
{
if (default_app_changed)
{
g_app_info_set_as_default_for_type (app, fm_mime_type_get_type (data->mime_type), &err);
if (err)
{
fm_show_error (GTK_WINDOW (dlg), NULL, err->message);
g_error_free (err);
}
}
g_object_unref (app);
}
}
if (data->single_file) // when only one file is shown
{
// if the user has changed its name
if ( g_strcmp0 (data->file_info->disp_name, gtk_entry_get_text (GTK_ENTRY (data->name))) )
{
// FIXME_pcm: rename the file or set display name for it.
}
}
#endif
}
gtk_widget_destroy (GTK_WIDGET (dlg));
}