static void thunar_folder_monitor (ThunarVfsMonitor *monitor, ThunarVfsMonitorHandle *handle, ThunarVfsMonitorEvent event, ThunarVfsPath *handle_path, ThunarVfsPath *event_path, gpointer user_data) { ThunarFolder *folder = THUNAR_FOLDER (user_data); ThunarFile *file; GList *lp; GList list; _thunar_return_if_fail (THUNAR_VFS_IS_MONITOR (monitor)); _thunar_return_if_fail (THUNAR_IS_FOLDER (folder)); _thunar_return_if_fail (folder->monitor == monitor); _thunar_return_if_fail (folder->handle == handle); _thunar_return_if_fail (folder->job == NULL); /* check on which file the event occurred */ if (!thunar_vfs_path_equal (event_path, thunar_file_get_path (folder->corresponding_file))) { /* check if we already ship the file */ for (lp = folder->files; lp != NULL; lp = lp->next) if (thunar_vfs_path_equal (event_path, thunar_file_get_path (lp->data))) break; /* if we don't have it, add it if the event is not an "deleted" event */ if (G_UNLIKELY (lp == NULL && event != THUNAR_VFS_MONITOR_EVENT_DELETED)) { /* allocate a file for the path */ file = thunar_file_get_for_path (event_path, NULL); if (G_UNLIKELY (file == NULL)) return; /* prepend it to our internal list */ folder->files = g_list_prepend (folder->files, file); /* tell others about the new file */ list.data = file; list.next = list.prev = NULL; g_signal_emit (G_OBJECT (folder), folder_signals[FILES_ADDED], 0, &list); } else if (lp != NULL) { /* update/destroy the file */ if (event == THUNAR_VFS_MONITOR_EVENT_DELETED) thunar_file_destroy (lp->data); else thunar_file_reload (lp->data); } } else { /* update/destroy the corresponding file */ if (event == THUNAR_VFS_MONITOR_EVENT_DELETED) thunar_file_destroy (folder->corresponding_file); else thunar_file_reload (folder->corresponding_file); } }
static void thunar_history_go_forward (ThunarHistory *history, guint n) { _thunar_return_if_fail (THUNAR_IS_HISTORY (history)); _thunar_return_if_fail (n > 0); /* go forward up to n steps */ for (; n > 0 && history->forward_list != NULL; --n) { /* prepend the previous current directory to the "back" list */ if (G_LIKELY (history->current_directory != NULL)) history->back_list = g_list_prepend (history->back_list, history->current_directory); /* remove the first directory from the "forward" list and make it the current directory */ history->current_directory = history->forward_list->data; history->forward_list = g_list_delete_link (history->forward_list, history->forward_list); } /* tell the other modules to change the current directory */ if (G_LIKELY (history->current_directory != NULL)) thunar_navigator_change_directory (THUNAR_NAVIGATOR (history), history->current_directory); /* update the sensitivity of the actions */ gtk_action_set_sensitive (history->action_back, (history->back_list != NULL)); gtk_action_set_sensitive (history->action_forward, (history->forward_list != NULL)); }
static void thunar_location_entry_activate (GtkWidget *path_entry, ThunarLocationEntry *location_entry) { ThunarFile *file; GError *error = NULL; _thunar_return_if_fail (THUNAR_IS_LOCATION_ENTRY (location_entry)); _thunar_return_if_fail (location_entry->path_entry == path_entry); /* determine the current file from the path entry */ file = thunar_path_entry_get_current_file (THUNAR_PATH_ENTRY (path_entry)); if (G_LIKELY (file != NULL)) { /* check if we have a new directory or a file to launch */ if (thunar_file_is_directory (file)) { /* open the new directory */ thunar_navigator_change_directory (THUNAR_NAVIGATOR (location_entry), file); } else { /* try to launch the selected file */ if (!thunar_file_launch (file, path_entry, &error)) { thunar_dialogs_show_error (path_entry, error, _("Failed to launch \"%s\""), thunar_file_get_display_name (file)); g_error_free (error); } /* be sure to reset the current file of the path entry */ if (G_LIKELY (location_entry->current_directory != NULL)) thunar_path_entry_set_current_file (THUNAR_PATH_ENTRY (path_entry), location_entry->current_directory); } } }
/** * thunar_history_set_action_group: * @history : a #ThunarHistory. * @action_group : a #GtkActionGroup or %NULL. * * Attaches @history to the specified @action_group, * and thereby registers the actions "back" and * "forward" provided by @history on the given * @action_group. **/ void thunar_history_set_action_group (ThunarHistory *history, GtkActionGroup *action_group) { _thunar_return_if_fail (THUNAR_IS_HISTORY (history)); _thunar_return_if_fail (action_group == NULL || GTK_IS_ACTION_GROUP (action_group)); /* verify that we don't already use that action group */ if (G_UNLIKELY (history->action_group == action_group)) return; /* disconnect from the previous action group */ if (G_UNLIKELY (history->action_group != NULL)) { gtk_action_group_remove_action (history->action_group, history->action_back); gtk_action_group_remove_action (history->action_group, history->action_forward); g_object_unref (G_OBJECT (history->action_group)); } /* activate the new action group */ history->action_group = action_group; /* connect to the new action group */ if (G_LIKELY (action_group != NULL)) { g_object_ref (G_OBJECT (action_group)); gtk_action_group_add_action_with_accel (action_group, history->action_back, "<alt>Left"); gtk_action_group_add_action_with_accel (action_group, history->action_forward, "<alt>Right"); } /* notify listeners */ g_object_notify (G_OBJECT (history), "action-group"); }
static void thunar_column_model_notify_visible_columns (ThunarPreferences *preferences, GParamSpec *pspec, ThunarColumnModel *column_model) { GtkTreePath *path; GtkTreeIter iter; gint n; _thunar_return_if_fail (THUNAR_IS_COLUMN_MODEL (column_model)); _thunar_return_if_fail (THUNAR_IS_PREFERENCES (preferences)); /* load the new list of visible columns */ thunar_column_model_load_visible_columns (column_model); /* emit "row-changed" for all rows */ for (n = 0; n < THUNAR_N_VISIBLE_COLUMNS; ++n) { path = gtk_tree_path_new_from_indices (n, -1); if (gtk_tree_model_get_iter (GTK_TREE_MODEL (column_model), &iter, path)) gtk_tree_model_row_changed (GTK_TREE_MODEL (column_model), path, &iter); gtk_tree_path_free (path); } /* emit "columns-changed" */ g_signal_emit (G_OBJECT (column_model), column_model_signals[COLUMNS_CHANGED], 0); }
void thunar_util_load_bookmarks (GFile *bookmarks_file, ThunarBookmarksFunc foreach_func, gpointer user_data) { gchar *bookmarks_path; gchar line[1024]; const gchar *name; gchar *space; FILE *fp; gint row_num = 1; GFile *file; _thunar_return_if_fail (G_IS_FILE (bookmarks_file)); _thunar_return_if_fail (g_file_is_native (bookmarks_file)); _thunar_return_if_fail (foreach_func != NULL); /* determine the path to the GTK+ bookmarks file */ bookmarks_path = g_file_get_path (bookmarks_file); /* append the GTK+ bookmarks (if any) */ fp = fopen (bookmarks_path, "r"); if (G_LIKELY (fp != NULL)) { while (fgets (line, sizeof (line), fp) != NULL) { /* remove trailing spaces */ g_strchomp (line); /* skip over empty lines */ if (*line == '\0' || *line == ' ') continue; /* check if there is a custom name in the line */ name = NULL; space = strchr (line, ' '); if (space != NULL) { /* break line */ *space++ = '\0'; /* get the custom name */ if (G_LIKELY (*space != '\0')) name = space; } file = g_file_new_for_uri (line); /* callback */ foreach_func (file, name, row_num++, user_data); g_object_unref (G_OBJECT (file)); } fclose (fp); } g_free (bookmarks_path); }
/** * thunar_component_set_ui_manager: * @component : a #ThunarComponent instance. * @ui_manager : a #GtkUIManager or %NULL. * * Installs a new #GtkUIManager for @component or resets the ::ui-manager * property. * * Implementations of the #ThunarComponent interface must first disconnect * from any previously set #GtkUIManager and then connect to the * @ui_manager if not %NULL. **/ void thunar_component_set_ui_manager (ThunarComponent *component, GtkUIManager *ui_manager) { _thunar_return_if_fail (THUNAR_IS_COMPONENT (component)); _thunar_return_if_fail (ui_manager == NULL || GTK_IS_UI_MANAGER (ui_manager)); (*THUNAR_COMPONENT_GET_IFACE (component)->set_ui_manager) (component, ui_manager); }
/** * thunar_location_dialog_set_selected_file: * @location_dialog : a #ThunarLocationDialog. * @selected_file : a #ThunarFile or %NULL. * * Sets the file for @location_dialog to @selected_file. **/ void thunar_location_dialog_set_selected_file (ThunarLocationDialog *location_dialog, ThunarFile *selected_file) { _thunar_return_if_fail (THUNAR_IS_LOCATION_DIALOG (location_dialog)); _thunar_return_if_fail (selected_file == NULL || THUNAR_IS_FILE (selected_file)); thunar_path_entry_set_current_file (THUNAR_PATH_ENTRY (location_dialog->entry), selected_file); }
/** * thunar_navigator_set_current_directory: * @navigator : a #ThunarNavigator instance. * @current_directory : the new directory to display or %NULL. * * Sets a new current directory that should be displayed by * the @navigator. **/ void thunar_navigator_set_current_directory (ThunarNavigator *navigator, ThunarFile *current_directory) { _thunar_return_if_fail (THUNAR_IS_NAVIGATOR (navigator)); _thunar_return_if_fail (current_directory == NULL || THUNAR_IS_FILE (current_directory)); THUNAR_NAVIGATOR_GET_IFACE (navigator)->set_current_directory (navigator, current_directory); }
static void thunar_chooser_button_file_changed (ThunarChooserButton *chooser_button, ThunarFile *file) { ThunarVfsMimeApplication *application; ThunarVfsMimeInfo *info; ThunarIconFactory *icon_factory; GtkIconTheme *icon_theme; const gchar *icon_name; GdkPixbuf *icon = NULL; gint icon_size; _thunar_return_if_fail (THUNAR_IS_CHOOSER_BUTTON (chooser_button)); _thunar_return_if_fail (chooser_button->file == file); _thunar_return_if_fail (THUNAR_IS_FILE (file)); /* determine the mime info for the file */ info = thunar_file_get_mime_info (file); /* determine the default application for that mime info */ application = thunar_vfs_mime_database_get_default_application (chooser_button->database, info); if (G_LIKELY (application != NULL)) { /* determine the icon size for menus */ gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_size, &icon_size); /* setup the image for the application */ icon_factory = thunar_icon_factory_get_default (); icon_theme = thunar_icon_factory_get_icon_theme (icon_factory); icon_name = thunar_vfs_mime_handler_lookup_icon_name (THUNAR_VFS_MIME_HANDLER (application), icon_theme); if (G_LIKELY (icon_name != NULL)) icon = thunar_icon_factory_load_icon (icon_factory, icon_name, icon_size, NULL, FALSE); gtk_image_set_from_pixbuf (GTK_IMAGE (chooser_button->image), icon); g_object_unref (G_OBJECT (icon_factory)); if (G_LIKELY (icon != NULL)) g_object_unref (G_OBJECT (icon)); /* setup the label for the application */ gtk_label_set_attributes (GTK_LABEL (chooser_button->label), NULL); gtk_label_set_text (GTK_LABEL (chooser_button->label), thunar_vfs_mime_handler_get_name (THUNAR_VFS_MIME_HANDLER (application))); /* cleanup */ g_object_unref (G_OBJECT (application)); } else { /* no default application specified */ gtk_label_set_attributes (GTK_LABEL (chooser_button->label), thunar_pango_attr_list_italic ()); gtk_label_set_text (GTK_LABEL (chooser_button->label), _("No application selected")); gtk_image_set_from_pixbuf (GTK_IMAGE (chooser_button->image), NULL); } /* setup a useful tooltip for the button */ thunar_gtk_widget_set_tooltip (chooser_button->button, _("The selected application is used to open " "this and other files of type \"%s\"."), thunar_vfs_mime_info_get_comment (info)); }
void thunar_progress_dialog_add_job (ThunarProgressDialog *dialog, ThunarJob *job, const gchar *icon_name, const gchar *title) { GtkWidget *viewport; GtkWidget *view; _thunar_return_if_fail (THUNAR_IS_PROGRESS_DIALOG (dialog)); _thunar_return_if_fail (THUNAR_IS_JOB (job)); _thunar_return_if_fail (g_utf8_validate (title, -1, NULL)); view = thunar_progress_view_new_with_job (job); thunar_progress_view_set_icon_name (THUNAR_PROGRESS_VIEW (view), icon_name); thunar_progress_view_set_title (THUNAR_PROGRESS_VIEW (view), title); gtk_box_pack_start (GTK_BOX (dialog->content_box), view, FALSE, TRUE, 0); gtk_widget_show (view); /* use the first job's icon-name for the dialog */ if (dialog->views == NULL) gtk_window_set_icon_name (GTK_WINDOW (dialog), icon_name); /* add the view to the list of known views */ dialog->views = g_list_prepend (dialog->views, view); /* check if we need to wrap the views in a scroll window (starting * at SCROLLVIEW_THRESHOLD parallel operations */ if (g_list_length (dialog->views) == SCROLLVIEW_THRESHOLD) { /* create a scrolled window and add it to the dialog */ dialog->scrollwin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (dialog->vbox), dialog->scrollwin); gtk_widget_show (dialog->scrollwin); /* create a viewport for the content box */ viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (dialog->scrollwin)), gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (dialog->scrollwin))); gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_NONE); gtk_container_add (GTK_CONTAINER (dialog->scrollwin), viewport); gtk_widget_show (viewport); /* move the content box into the viewport */ gtk_widget_reparent (dialog->content_box, viewport); } g_signal_connect_swapped (view, "need-attention", G_CALLBACK (thunar_progress_dialog_view_needs_attention), dialog); g_signal_connect_swapped (view, "finished", G_CALLBACK (thunar_progress_dialog_job_finished), dialog); if (dialog->status_icon != NULL) thunar_progress_dialog_update_status_icon (dialog); }
/** * thunar_location_dialog_set_working_directory: * @location_dialog : a #ThunarLocationDialog. * @directory : a #ThunarFile or %NULL. * * Sets the working directory of @location_dialog to @directory. **/ void thunar_location_dialog_set_working_directory (ThunarLocationDialog *location_dialog, ThunarFile *directory) { _thunar_return_if_fail (THUNAR_IS_LOCATION_DIALOG (location_dialog)); _thunar_return_if_fail (directory == NULL || THUNAR_IS_FILE (directory)); thunar_path_entry_set_working_directory (THUNAR_PATH_ENTRY (location_dialog->entry), directory); }
/** * thunar_navigator_change_directory: * @navigator : a #ThunarNavigator instance. * @directory : a #ThunarFile referring to a directory. * * Emits the "change-directory" signal on @navigator with * the specified @directory. * * Derived classes should invoke this method whenever the user * selects a new directory from within @navigator. The derived * class should not perform any directory changing operations * itself, but leave it up to the surrounding module (usually * a #ThunarWindow instance) to change the directory. * * It should never ever be called from outside a #ThunarNavigator * implementation, as that may led to unexpected results! **/ void thunar_navigator_change_directory (ThunarNavigator *navigator, ThunarFile *directory) { _thunar_return_if_fail (THUNAR_IS_NAVIGATOR (navigator)); _thunar_return_if_fail (THUNAR_IS_FILE (directory)); _thunar_return_if_fail (thunar_file_is_directory (directory)); g_signal_emit (G_OBJECT (navigator), navigator_signals[CHANGE_DIRECTORY], 0, directory); }
void thunar_navigator_open_new_tab (ThunarNavigator *navigator, ThunarFile *directory) { _thunar_return_if_fail (THUNAR_IS_NAVIGATOR (navigator)); _thunar_return_if_fail (THUNAR_IS_FILE (directory)); _thunar_return_if_fail (thunar_file_is_directory (directory)); g_signal_emit (G_OBJECT (navigator), navigator_signals[OPEN_NEW_TAB], 0, directory); }
static void thunar_history_action_forward (GtkAction *action, ThunarHistory *history) { _thunar_return_if_fail (GTK_IS_ACTION (action)); _thunar_return_if_fail (THUNAR_IS_HISTORY (history)); /* go forward one step */ thunar_history_go_forward (history, 1); }
static void thunar_column_model_notify_column_widths (ThunarPreferences *preferences, GParamSpec *pspec, ThunarColumnModel *column_model) { _thunar_return_if_fail (THUNAR_IS_COLUMN_MODEL (column_model)); _thunar_return_if_fail (THUNAR_IS_PREFERENCES (preferences)); /* load the new column widths */ thunar_column_model_load_column_widths (column_model); }
static void thunar_progress_dialog_view_needs_attention (ThunarProgressDialog *dialog, ThunarProgressView *view) { _thunar_return_if_fail (THUNAR_IS_PROGRESS_DIALOG (dialog)); _thunar_return_if_fail (THUNAR_IS_PROGRESS_VIEW (view)); /* TODO scroll to the view */ /* raise the dialog */ gtk_window_present (GTK_WINDOW (dialog)); }
static void thunar_folder_error (ThunarVfsJob *job, GError *error, ThunarFolder *folder) { _thunar_return_if_fail (THUNAR_IS_FOLDER (folder)); _thunar_return_if_fail (THUNAR_VFS_IS_JOB (job)); _thunar_return_if_fail (folder->job == job); /* tell the consumer about the problem */ g_signal_emit (G_OBJECT (folder), folder_signals[ERROR], 0, error); }
static void thunar_image_file_changed (ThunarFileMonitor *monitor, ThunarFile *file, ThunarImage *image) { _thunar_return_if_fail (THUNAR_IS_FILE_MONITOR (monitor)); _thunar_return_if_fail (THUNAR_IS_FILE (file)); _thunar_return_if_fail (THUNAR_IS_IMAGE (image)); if (file == image->priv->file) thunar_image_update (image); }
static void thunar_history_action_forward_nth (GtkWidget *item, ThunarHistory *history) { guint n; _thunar_return_if_fail (GTK_IS_MENU_ITEM (item)); _thunar_return_if_fail (THUNAR_IS_HISTORY (history)); n = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (item), "thunar-history-index")); if (G_LIKELY (n > 0)) thunar_history_go_forward (history, n); }
/** * thunar_dialogs_show_job_error: * @parent : the parent #GtkWindow or %NULL. * @error : the #GError provided by the #ThunarJob. * * Utility function to display a message dialog for the * ThunarJob::error signal. **/ void thunar_dialogs_show_job_error (GtkWindow *parent, GError *error) { const gchar *separator; GtkWidget *message; GString *secondary = g_string_sized_new (256); GString *primary = g_string_sized_new (256); _thunar_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent)); _thunar_return_if_fail (error != NULL && error->message != NULL); /* try to separate the message into primary and secondary parts */ separator = strstr (error->message, ": "); if (G_LIKELY (separator > error->message)) { /* primary is everything before the colon, plus a dot */ g_string_append_len (primary, error->message, separator - error->message); g_string_append_c (primary, '.'); /* secondary is everything after the colon (plus a dot) */ do ++separator; while (g_ascii_isspace (*separator)); g_string_append (secondary, separator); if (separator[strlen (separator - 1)] != '.') g_string_append_c (secondary, '.'); } else { /* primary is everything, secondary is empty */ g_string_append (primary, error->message); } /* allocate and display the error message dialog */ message = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_NONE, "%s", primary->str); if (G_LIKELY (*secondary->str != '\0')) gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message), "%s", secondary->str); gtk_dialog_add_button (GTK_DIALOG (message), GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL); gtk_dialog_run (GTK_DIALOG (message)); gtk_widget_destroy (message); /* cleanup */ g_string_free (secondary, TRUE); g_string_free (primary, TRUE); }
static void thunar_progress_dialog_job_finished (ThunarProgressDialog *dialog, ThunarProgressView *view) { guint n_views; _thunar_return_if_fail (THUNAR_IS_PROGRESS_DIALOG (dialog)); _thunar_return_if_fail (THUNAR_IS_PROGRESS_VIEW (view)); /* remove the view from the list */ dialog->views = g_list_remove (dialog->views, view); /* destroy the widget */ gtk_widget_destroy (GTK_WIDGET (view)); /* determine the number of views left */ n_views = g_list_length (dialog->views); /* check if we've just removed the 4th view and are now left with * SCROLLVIEW_THRESHOLD-1 of them, in which case we drop the scroll window */ if (n_views == SCROLLVIEW_THRESHOLD-1) { /* reparent the content box */ gtk_widget_reparent (dialog->content_box, dialog->vbox); /* destroy the scroll win */ gtk_widget_destroy (dialog->scrollwin); } /* check if we have less than SCROLLVIEW_THRESHOLD views * and need to shrink the window */ if (n_views < SCROLLVIEW_THRESHOLD) { /* try to shrink the window */ gtk_window_resize (GTK_WINDOW (dialog), 450, 10); } /* check if we still have at least one view */ if (dialog->views != NULL) { /* update the status icon */ if (dialog->status_icon != NULL) thunar_progress_dialog_update_status_icon (dialog); } else { /* destroy the dialog as there are no views left */ gtk_widget_destroy (GTK_WIDGET (dialog)); } }
/** * thunar_folder_reload: * @folder : a #ThunarFolder instance. * * Tells the @folder object to reread the directory * contents from the underlying media. **/ void thunar_folder_reload (ThunarFolder *folder) { _thunar_return_if_fail (THUNAR_IS_FOLDER (folder)); /* check if we are currently connect to a job */ if (G_UNLIKELY (folder->job != NULL)) { /* disconnect from the job */ g_signal_handlers_disconnect_matched (folder->job, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, folder); thunar_vfs_job_cancel (THUNAR_VFS_JOB (folder->job)); g_object_unref (G_OBJECT (folder->job)); } /* disconnect from the file alteration monitor */ if (G_UNLIKELY (folder->handle != NULL)) { thunar_vfs_monitor_remove (folder->monitor, folder->handle); folder->handle = NULL; } /* reset the new_files list */ thunar_file_list_free (folder->new_files); folder->new_files = NULL; /* start a new job */ folder->job = thunar_vfs_listdir (thunar_file_get_path (folder->corresponding_file), NULL); g_signal_connect (folder->job, "error", G_CALLBACK (thunar_folder_error), folder); g_signal_connect (folder->job, "finished", G_CALLBACK (thunar_folder_finished), folder); g_signal_connect (folder->job, "infos-ready", G_CALLBACK (thunar_folder_infos_ready), folder); /* tell all consumers that we're loading */ g_object_notify (G_OBJECT (folder), "loading"); }
static void thunar_folder_file_changed (ThunarFileMonitor *file_monitor, ThunarFile *file, ThunarFolder *folder) { _thunar_return_if_fail (THUNAR_IS_FILE (file)); _thunar_return_if_fail (THUNAR_IS_FOLDER (folder)); _thunar_return_if_fail (THUNAR_IS_FILE_MONITOR (file_monitor)); /* check if the corresponding file changed... */ if (G_UNLIKELY (folder->corresponding_file == file)) { /* ...and if so, reload the folder */ thunar_folder_reload (folder); } }
/** * thunar_component_set_selected_files: * @component : a #ThunarComponent instance. * @selected_files : a #GList of #ThunarFile<!---->s. * * Sets the selected files for @component to @selected_files. * Check the description of the :selected-files property for * details. **/ void thunar_component_set_selected_files (ThunarComponent *component, GList *selected_files) { _thunar_return_if_fail (THUNAR_IS_COMPONENT (component)); (*THUNAR_COMPONENT_GET_IFACE (component)->set_selected_files) (component, selected_files); }
/** * thunar_side_pane_set_show_hidden: * @side_pane : a #ThunarSidePane. * @show_hidden : %TRUE to display hidden folders. * * If @show_hidden is %TRUE, hidden folders will be * shown in the @side_pane. **/ void thunar_side_pane_set_show_hidden (ThunarSidePane *side_pane, gboolean show_hidden) { _thunar_return_if_fail (THUNAR_IS_SIDE_PANE (side_pane)); (*THUNAR_SIDE_PANE_GET_IFACE (side_pane)->set_show_hidden) (side_pane, show_hidden); }
/** * thunar_column_model_set_column_visible: * @column_model : a #ThunarColumnModel. * @column : a #ThunarColumn. * @visible : %TRUE to make @column visible. * * Changes the visibility of the @column to @visible in * @column_model. **/ void thunar_column_model_set_column_visible (ThunarColumnModel *column_model, ThunarColumn column, gboolean visible) { GtkTreePath *path; GtkTreeIter iter; gint n; _thunar_return_if_fail (THUNAR_IS_COLUMN_MODEL (column_model)); _thunar_return_if_fail (column < THUNAR_N_VISIBLE_COLUMNS); _thunar_return_if_fail (column >= 0); /* cannot change the visibility of the name column */ if (G_UNLIKELY (column == THUNAR_COLUMN_NAME)) return; /* normalize the value */ visible = !!visible; /* check if we have a new value */ if (G_LIKELY (column_model->visible[column] != visible)) { /* apply the new value */ column_model->visible[column] = visible; /* reverse lookup the real column */ for (n = 0; n < THUNAR_N_VISIBLE_COLUMNS; ++n) if (column_model->order[n] == column) { column = n; break; } /* emit "row-changed" */ path = gtk_tree_path_new_from_indices (column, -1); if (gtk_tree_model_get_iter (GTK_TREE_MODEL (column_model), &iter, path)) gtk_tree_model_row_changed (GTK_TREE_MODEL (column_model), path, &iter); gtk_tree_path_free (path); /* emit "columns-changed" */ g_signal_emit (G_OBJECT (column_model), column_model_signals[COLUMNS_CHANGED], 0); /* save the list of visible columns */ thunar_column_model_save_visible_columns (column_model); } }
static void thunar_preferences_monitor (ThunarVfsMonitor *monitor, ThunarVfsMonitorHandle *handle, ThunarVfsMonitorEvent event, ThunarVfsPath *handle_path, ThunarVfsPath *event_path, gpointer user_data) { ThunarPreferences *preferences = THUNAR_PREFERENCES (user_data); _thunar_return_if_fail (THUNAR_IS_PREFERENCES (preferences)); _thunar_return_if_fail (THUNAR_VFS_IS_MONITOR (monitor)); _thunar_return_if_fail (preferences->monitor == monitor); _thunar_return_if_fail (preferences->handle == handle); /* schedule a reload whenever the file is created/changed */ if (event == THUNAR_VFS_MONITOR_EVENT_CHANGED || event == THUNAR_VFS_MONITOR_EVENT_CREATED) thunar_preferences_queue_load (preferences); }
/** * thunar_column_model_set_column_width: * @column_model : a #ThunarColumnModel. * @column : a #ThunarColumn. * @width : the new fixed width for @column. * * Sets the fixed width for @column in @column_model * to @width. **/ void thunar_column_model_set_column_width (ThunarColumnModel *column_model, ThunarColumn column, gint width) { _thunar_return_if_fail (THUNAR_IS_COLUMN_MODEL (column_model)); _thunar_return_if_fail (column < THUNAR_N_VISIBLE_COLUMNS); _thunar_return_if_fail (column >= 0); _thunar_return_if_fail (width >= 0); /* check if we have a new width */ if (G_LIKELY (column_model->width[column] != width)) { /* apply the new value */ column_model->width[column] = width; /* store the settings */ thunar_column_model_save_column_widths (column_model); } }
static void thunar_column_model_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, gint index, GValue *value) { ThunarColumnModel *column_model = THUNAR_COLUMN_MODEL (tree_model); ThunarColumn column; _thunar_return_if_fail (THUNAR_IS_COLUMN_MODEL (column_model)); _thunar_return_if_fail (index < THUNAR_COLUMN_MODEL_N_COLUMNS); _thunar_return_if_fail (iter->stamp == column_model->stamp); /* determine the column from the iterator */ column = GPOINTER_TO_INT (iter->user_data); /* resolve the column according to the order */ column = column_model->order[column]; switch (index) { case THUNAR_COLUMN_MODEL_COLUMN_NAME: g_value_init (value, G_TYPE_STRING); g_value_set_static_string (value, thunar_column_model_get_column_name (column_model, column)); break; case THUNAR_COLUMN_MODEL_COLUMN_MUTABLE: g_value_init (value, G_TYPE_BOOLEAN); g_value_set_boolean (value, (column != THUNAR_COLUMN_NAME)); break; case THUNAR_COLUMN_MODEL_COLUMN_VISIBLE: g_value_init (value, G_TYPE_BOOLEAN); g_value_set_boolean (value, thunar_column_model_get_column_visible (column_model, column)); break; default: _thunar_assert_not_reached (); break; } }