return TRUE;

}

static CajaWindow *

create_window (CajaApplication *application,

GType window_type,

g_option_context_add_group (context, egg_sm_client_get_option_group ());

/* we need to do this here, as parsing the EggSMClient option context,

* unsets this variable.

*/

self->priv->autostart = TRUE;

}

argv = *arguments;

argc = g_strv_length (argv);

G_CALLBACK (queue_accel_map_save_callback), NULL);

}

static void

caja_application_startup (GApplication *app)

{

Author: David Zeuthen <[email protected]>

*/

#include <config.h>

#include <unistd.h>

#include <string.h>

* etc.)

*/

icon = g_mount_get_icon (mount);

icon_size = caja_get_icon_size_for_stock_size (GTK_ICON_SIZE_DIALOG);

icon_info = caja_icon_info_lookup (icon, icon_size,

return retval;

}

static void

caja_bookmark_list_class_init (CajaBookmarkListClass *class)

{

#include "caja-bookmarks-sidebar.h"

typedef struct

{

GtkScrolledWindowClass parent;

bookmarks_delete_bookmark ();

}

/* This is a bit of a kludge to get DnD to work. We check if the row in the

GtkListStore matches the one in the bookmark list. If it doesn't, we assume

the bookmark has just been dragged here and we insert it into the bookmark

g_free (entry_text);

}

static void

update_bookmark_from_text (void)

{

1, get_method_description (&(methods[i])),

-1);

if (methods[i].flags & DEFAULT_METHOD)

{

gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &iter);

GMountOperation *

caja_connect_server_operation_new (CajaConnectServerDialog *dialog);

#endif /* __CAJA_CONNECT_SERVER_OPERATION_H__ */

gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), label,

FALSE, FALSE, 8);

hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);

gtk_box_pack_start (GTK_BOX (hbox), image, TRUE, TRUE, 8);

gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox,

TRUE, TRUE, 8);

return dialog;

}

prelight_pixbuf = eel_create_spotlight_pixbuf (pixbuf);

gtk_drag_source_set (event_box, GDK_BUTTON1_MASK, drag_types,

G_N_ELEMENTS (drag_types),

GDK_ACTION_COPY | GDK_ACTION_MOVE);

gtk_drag_source_set_icon_pixbuf (event_box, pixbuf);

g_signal_connect (event_box, "button_press_event",

G_CALLBACK (caja_emblem_sidebar_button_press_cb),

emblem_sidebar);

emblem->name = g_strdup (text);

}

static void

destroy_emblem (Emblem *emblem, gpointer user_data)

{

g_return_if_fail (emblem != NULL);

if (emblem->pixbuf != NULL)

{

g_object_unref (emblem->pixbuf);

emblem_widget);

}

icons = caja_emblem_list_available ();

l = icons;

}

}

static void

caja_file_management_properties_dialog_response_cb (GtkDialog *parent,

int response_id,

gtk_tree_path_free (path);

}

static void

caja_file_management_properties_dialog_setup_media_page (GtkBuilder *builder)

{

gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (other_type_list_store),

1, GTK_SORT_ASCENDING);

content_types = g_content_types_get_registered ();

for (l = content_types; l != NULL; l = l->next)

G_CALLBACK(caja_file_management_properties_dialog_update_media_sensitivity),

builder);

/* UI callbacks */

dialog = GTK_WIDGET (gtk_builder_get_object (builder, "file_management_dialog"));

g_signal_connect_data (dialog, "response",

* Stefano Karapetsas <[email protected]>

*/

#ifndef __CAJA_FREEDESKTOP_DBUS_H__

#define __CAJA_FREEDESKTOP_DBUS_H__

GObjectClass parent;

} CajaHistorySidebarProviderClass;

enum

{

HISTORY_SIDEBAR_COLUMN_ICON,

GObjectClass parent;

} CajaImagePropertiesPageProviderClass;

static GType caja_image_properties_page_provider_get_type (void);

static void property_page_provider_iface_init (CajaPropertyPageProviderIface *iface);

iface->get_pages = get_property_pages;

}

static void

caja_image_properties_page_provider_init (CajaImagePropertiesPageProvider *sidebar)

{

GObjectClass parent;

} CajaInformationPanelProviderClass;

G_DEFINE_TYPE_WITH_CODE (CajaInformationPanel, caja_information_panel, EEL_TYPE_BACKGROUND_BOX,

G_ADD_PRIVATE (CajaInformationPanel)

G_IMPLEMENT_INTERFACE (CAJA_TYPE_SIDEBAR,

G_IMPLEMENT_INTERFACE (CAJA_TYPE_SIDEBAR_PROVIDER,

sidebar_provider_iface_init));

static const char *

caja_information_panel_get_sidebar_id (CajaSidebar *sidebar)

{

return retval;

}

static void schedule_refresh_go_menu (CajaNavigationWindow *window);

static void

action_close_all_windows_callback (GtkAction *action,

gpointer user_data)

G_GNUC_END_IGNORE_DEPRECATIONS;

}

static void

action_show_hide_sidebar_callback (GtkAction *action,

gpointer user_data)

caja_window_new_window (current_window);

}

static void

action_new_tab_callback (GtkAction *action,

gpointer user_data)

caja_navigation_window_update_split_view_actions_sensitivity (window);

}

/**

* caja_window_initialize_menus

*

caja_window_set_active_pane (pane->window, pane);

}

static void

search_bar_activate_callback (CajaSearchBar *bar,

CajaNavigationWindowPane *pane)

gtk_widget_set_size_request (pane->widget, 60, 60);

}

void

caja_navigation_window_pane_show_location_bar_temporarily (CajaNavigationWindowPane *pane)

{

caja_directory_unref (directory);

}

static void

caja_navigation_window_slot_update_query_editor (CajaWindowSlot *slot)

{

typedef struct CajaNavigationWindowSlot CajaNavigationWindowSlot;

typedef struct CajaNavigationWindowSlotClass CajaNavigationWindowSlotClass;

#define CAJA_TYPE_NAVIGATION_WINDOW_SLOT (caja_navigation_window_slot_get_type())

#define CAJA_NAVIGATION_WINDOW_SLOT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), CAJA_NAVIGATION_WINDOW_SLOT_CLASS, CajaNavigationWindowSlotClass))

#define CAJA_NAVIGATION_WINDOW_SLOT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CAJA_TYPE_NAVIGATION_WINDOW_SLOT, CajaNavigationWindowSlot))

static void use_extra_mouse_buttons_changed (gpointer callback_data);

static CajaWindowSlot *create_extra_pane (CajaNavigationWindow *window);

G_DEFINE_TYPE_WITH_PRIVATE (CajaNavigationWindow, caja_navigation_window, CAJA_TYPE_WINDOW)

#define parent_class caja_navigation_window_parent_class

return TRUE;

}

void

caja_navigation_window_hide_toolbar (CajaNavigationWindow *window)

{

typedef struct _CajaNavigationWindowClass CajaNavigationWindowClass;

typedef struct _CajaNavigationWindowPrivate CajaNavigationWindowPrivate;

struct _CajaNavigationWindow

{

CajaWindow parent_object;

GList *sidebar_panels;

};

struct _CajaNavigationWindowClass

{

CajaWindowClass parent_spot;

gtk_widget_add_events (widget, GDK_SCROLL_MASK);

}

void

caja_notebook_sync_loading (CajaNotebook *notebook,

CajaWindowSlot *slot)

caja_notebook_sync_tab_label (notebook, slot);

caja_notebook_sync_loading (notebook, slot);

/* FIXME gtk bug! */

/* FIXME: this should be fixed in gtk 2.12; check & remove this! */

/* The signal handler may have reordered the tabs */

GObjectClass parent;

} CajaNotesViewerProviderClass;

G_DEFINE_TYPE_WITH_CODE (CajaNotesViewer, caja_notes_viewer, GTK_TYPE_SCROLLED_WINDOW,

G_IMPLEMENT_INTERFACE (CAJA_TYPE_SIDEBAR,

caja_notes_viewer_sidebar_iface_init));

G_IMPLEMENT_INTERFACE (CAJA_TYPE_SIDEBAR_PROVIDER,

sidebar_provider_iface_init));

struct _CajaNotesViewerDetails

{

GtkWidget *note_text_field;

G_OBJECT_CLASS (caja_notes_viewer_parent_class)->finalize (object);

}

static void

caja_notes_viewer_class_init (CajaNotesViewerClass *class)

{

char *uri;

CajaNotesViewer *viewer;

/* Only show the property page if 1 file is selected */

if (!files || files->next != NULL)

{

GFile *file_path,

gboolean emit_signal);

static GtkWidget *

get_slider_button (CajaPathBar *path_bar,

const gchar *arrow_type)

}

}

static void

desktop_location_changed_callback (gpointer user_data)

{

gtk_container_class_handle_border_width (container_class);

}

static void

caja_path_bar_finalize (GObject *object)

{

&slider_width,

NULL);

if (path_bar->button_list) {

*minimum += (path_bar->spacing + slider_width) * 2;

*natural += (path_bar->spacing + slider_width) * 2;

return FALSE;

}

static void

caja_path_bar_add (GtkContainer *container,

GtkWidget *widget)

}

}

/* Changes the icons wherever it is needed */

static void

reload_icons (CajaPathBar *path_bar)

GINT_TO_POINTER (FALSE));

}

static CajaIconInfo *

get_type_icon_info (ButtonData *button_data)

{

typedef struct _CajaPathBar CajaPathBar;

typedef struct _CajaPathBarClass CajaPathBarClass;

#define CAJA_TYPE_PATH_BAR (caja_path_bar_get_type ())

#define CAJA_PATH_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CAJA_TYPE_PATH_BAR, CajaPathBar))

#define CAJA_PATH_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CAJA_TYPE_PATH_BAR, CajaPathBarClass))

location, mount_uri, last_uri,

&last_iter, &select_path);

/* XDG directories */

xdg_dirs = NULL;

for (index = 0; index < G_USER_N_DIRECTORIES; index++) {

}

g_list_free (mounts);

/* add bookmarks */

bookmark_count = caja_bookmark_list_length (sidebar->bookmarks);

}

}

g_free (uri);

}

g_object_unref (G_OBJECT (mount));

}

eel_remove_weak_pointer (&(sidebar->go_to_after_mount_slot));

}

return FALSE;

}

static void

bookmarks_edited (GtkCellRenderer *cell,

gchar *path_string,

#define CAJA_PLACES_SIDEBAR_GET_CLASS(obj) \

(G_TYPE_INSTANCE_GET_CLASS ((obj), CAJA_TYPE_PLACES_SIDEBAR, CajaPlacesSidebarClass))

GType caja_places_sidebar_get_type (void);

void caja_places_sidebar_register (void);

const char *color_spec,

gboolean trim_edges);

#define BROWSER_CATEGORIES_FILE_NAME "browser.xml"

#define PROPERTY_BROWSER_WIDTH 540

{ "text/uri-list", 0, PROPERTY_TYPE }

};

G_DEFINE_TYPE_WITH_PRIVATE (CajaPropertyBrowser, caja_property_browser, GTK_TYPE_WINDOW)

/* Destroy the three dialogs for adding patterns/colors/emblems if any of them

exist. */

static void

g_signal_connect_object (property_browser->details->add_button, "clicked",

G_CALLBACK (add_new_button_callback), property_browser, 0);

/* now create the actual content, with the category pane and the content frame */

/* the actual contents are created when necessary */

}

/* drag and drop data get handler */

static void

return pixbuf;

}

/* create a pixbuf and fill it with a color */

static GdkPixbuf*

return;

}

user_directory = caja_get_user_directory ();

/* copy the image file to the patterns directory */

g_object_unref (dest);

g_free (basename);

/* update the property browser's contents to show the new one */

caja_property_browser_update_contents (property_browser);

gtk_widget_show (GTK_WIDGET(property_browser->details->colors_dialog));

}

/* here's the routine to add a new color, by putting up a color selector */

static void

stripped_keyword = g_strstrip (g_strdup (new_keyword));

}

caja_emblem_install_custom_emblem (pixbuf,

stripped_keyword,

stripped_keyword,

blank = eel_image_table_add_empty_image (image_table);

labeled_image_configure (EEL_LABELED_IMAGE (blank));

num_images = eel_wrap_table_get_num_children (EEL_WRAP_TABLE (image_table));

g_assert (num_images > 0);

eel_wrap_table_reorder_child (EEL_WRAP_TABLE (image_table),

}

gtk_widget_show (property_browser->details->add_button);

if (property_browser->details->remove_mode)

{

caja_property_browser_update_contents (property_browser);

}

/* here is the routine that populates the property browser with the appropriate information

when the path changes */

caja_property_browser_update_contents (property_browser);

}

static void

emit_emblems_changed_signal (void)

{

void *data;

} CajaQueryEditorRow;

typedef struct

{

const char *name;

g_free (tags_str);

}

/* Type */

static gboolean

-1);

}

static void

type_combo_changed (GtkComboBox *combo_box, CajaQueryEditorRow *row)

{

}

g_list_free (mime_infos);

toplevel = gtk_widget_get_toplevel (GTK_WIDGET (combo_box));

dialog = gtk_dialog_new ();

selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));

gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);

renderer = gtk_cell_renderer_text_new ();

column = gtk_tree_view_column_new_with_attributes ("Name",

renderer,

return mime_types;

}

static void

type_add_rows_from_query (CajaQueryEditor *editor,

CajaQuery *query)

/* End of row types */

static GtkWidget *modtime_row_create_widgets(CajaQueryEditorRow *row)

{

GtkWidget *hbox = NULL;

{

}

static GtkWidget *size_row_create_widgets(CajaQueryEditorRow *row)

{

GtkWidget *hbox = NULL;

gboolean found;

GList *l;

for (type = 0; type < CAJA_QUERY_EDITOR_ROW_LAST; type++)

{

found = FALSE;

caja_search_bar,

GTK_TYPE_EVENT_BOX)

static void

finalize (GObject *object)

{

* check functions in Caja proper.

*/

#ifndef __CAJA_SELF_CHECK_FUNCTIONS_H__

#define __CAJA_SELF_CHECK_FUNCTIONS_H__

page_num);

}

static void

shortcut_clicked_callback (GtkWidget *button,

gpointer user_data)

setup_gc_with_fg (sidebar_title, LABEL_INFO_COLOR_ACTIVE,

eel_gdk_rgba_is_dark (&color) ? light_info_color : dark_info_color);

/* If EelBackground is not set in the widget, we can safely

* use the foreground color from the theme, because it will

* always be displayed against the gtk background */

CajaWindowClass parent_spot;

};

GType caja_spatial_window_get_type (void);

void caja_spatial_window_set_location_button (CajaSpatialWindow *window,

GFile *location);

PROP_WINDOW

};

static void

activate_nth_short_list_item (CajaWindow *window, guint index)

{

}

}

static void

connect_proxy (GtkAction *action,

GtkWidget *proxy)

user_data);

}

void

caja_window_slot_open_location_full (CajaWindowSlot *slot,

GFile *location,

flags, selection, NULL, NULL);

}

void

caja_window_slot_go_home (CajaWindowSlot *slot, gboolean new_tab)

{

g_free (message);

}

const char *

caja_window_slot_get_content_view_id (CajaWindowSlot *slot)

{

g_free (detail_message);

}

void

caja_window_slot_stop_loading (CajaWindowSlot *slot)

{

void caja_window_manage_views_close_slot (CajaWindowPane *pane,

CajaWindowSlot *slot);

/* CajaWindowInfo implementation: */

void caja_window_report_load_underway (CajaWindow *window,

CajaView *view);

g_signal_connect (proxy, "deselect",

G_CALLBACK (menu_item_deselect_cb), window);

/* This is a way to easily get surfaces into the menu items */

icon = g_object_get_data (G_OBJECT (action), "menu-icon");

if (icon != NULL)

G_TYPE_OBJECT)

#define parent_class caja_window_pane_parent_class

static inline CajaWindowSlot *

get_first_inactive_slot (CajaWindowPane *pane)

{

slot->location);

}

void

caja_window_pane_sync_location_widgets (CajaWindowPane *pane)

{

GType caja_window_pane_get_type (void);

CajaWindowPane *caja_window_pane_new (CajaWindow *window);

void caja_window_pane_show (CajaWindowPane *pane);

void caja_window_pane_zoom_in (CajaWindowPane *pane);

void caja_window_pane_zoom_to_level (CajaWindowPane *pane, CajaZoomLevel level);

void caja_window_pane_switch_to (CajaWindowPane *pane);

void caja_window_pane_grab_focus (CajaWindowPane *pane);

#endif /* CAJA_WINDOW_PANE_H */

GList * caja_get_history_list (void);

void caja_window_bookmarks_preference_changed_callback (gpointer user_data);

/* sync window GUI with current slot. Used when changing slots,

* and when updating the slot state.

*/

caja_directory_unref (directory);

}

static void

real_active (CajaWindowSlot *slot)

{

inactive, (slot));

}

static void

caja_window_slot_init (CajaWindowSlot *slot)

{

}

}

/* caja_window_slot_update_title:

*

* Re-calculate the slot title.

caja_navigation_window_activate_spinner (window);

}

static GList *

get_extension_toolbar_items (CajaNavigationWindow *window)

{

window->details->view_as_action_group = NULL;

}

refresh_stored_viewers (window);

merge_id = gtk_ui_manager_new_merge_id (window->details->ui_manager);

caja_window_sync_zoom_widgets (window);

}

/* These are called

* A) when switching the view within the active slot

* B) when switching the active slot

return next_pane;

}

void

caja_window_slot_set_viewed_file (CajaWindowSlot *slot,

CajaFile *file)

return g_list_copy_deep (history_list, caja_window_copy_history_item, NULL);

}

static CajaWindowType

caja_window_get_window_type (CajaWindow *window)

{

g_assert (CAJA_IS_WINDOW (window));

/* return NULL if there is only one pane */

if (window->details->panes == NULL ||

window->details->panes->next == NULL)

message = g_strdup_printf (_("The media has been detected as \"%s\"."), description);

}

gtk_label_set_text (GTK_LABEL (bar->priv->label), message);

gtk_widget_show (bar->priv->label);

bar->priv->mount = mount != NULL ? g_object_ref (mount) : NULL;

}

static void

caja_x_content_bar_set_property (GObject *object,

guint prop_id,

gboolean marking_menu_items;

};

static guint signals[LAST_SIGNAL] = { 0 };

static gpointer accessible_parent_class;

return TRUE;

}

static void

caja_zoom_control_class_init (CajaZoomControlClass *class)

{

widget_class = GTK_WIDGET_CLASS (class);

gtk_widget_class_set_accessible_type (widget_class,

caja_zoom_control_accessible_get_type ());

view);

G_GNUC_END_IGNORE_DEPRECATIONS;

gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);

g_object_unref (action_group); /* owned by ui manager */

PROP_WINDOW_SLOT

};

static guint signals[LAST_SIGNAL] = { 0 };

static GdkAtom copied_files_atom;

return g_list_reverse (res);

}

static GList *

file_and_directory_list_from_files (CajaDirectory *directory, GList *files)

{

g_free (fad);

}

static void

file_and_directory_list_free (GList *list)

{

return GPOINTER_TO_UINT (fad->file) ^ GPOINTER_TO_UINT (fad->directory);

}

static ScriptLaunchParameters *

script_launch_parameters_new (CajaFile *file,

FMDirectoryView *directory_view)

caja_file_list_free (selection);

}

static void

action_open_alternate_callback (GtkAction *action,

gpointer callback_data)

fm_directory_view_invert_selection (callback_data);

}

static void

pattern_select_response_cb (GtkWidget *dialog, int response, gpointer user_data)

{

fm_directory_view_reset_to_defaults (callback_data);

}

static void

hidden_files_mode_changed (CajaWindow *window,

gpointer callback_data)

gtk_widget_set_sensitive (button, sensitive);

}

static void

action_save_search_as_callback (GtkAction *action,

gpointer callback_data)

}

}

static void

action_empty_trash_callback (GtkAction *action,

gpointer callback_data)

caja_directory_unref (directory);

}

static void

add_directory_to_scripts_directory_list (FMDirectoryView *view,

CajaDirectory *directory)

}

}

void

fm_directory_view_init_view_iface (CajaViewIface *iface)

{

view->details->loading = FALSE;

}

typedef struct {

GHashTable *debuting_files;

GList *added_files;

return TRUE;

}

/* When this function is invoked, the file operation is over, but all

* the icons may not have been added to the directory view yet, so

* we can't select them yet.

}

}

*pending_list = g_list_concat (file_and_directory_list_from_files (directory, files),

*pending_list);

zoom_to_level, (view, zoom_level));

}

CajaZoomLevel

fm_directory_view_get_zoom_level (FMDirectoryView *view)

{

g_free (data);

}

static void

rename_file (FMDirectoryView *view, CajaFile *new_file)

{

GHashTable *added_locations;

} NewFolderData;

static void

track_newly_added_locations (FMDirectoryView *view, CajaFile *new_file,

CajaDirectory *directory, gpointer user_data)

screen = gtk_widget_get_screen (GTK_WIDGET (directory_view));

g_snprintf (screen_string, sizeof (screen_string), "%d", gdk_x11_screen_get_screen_number (screen));

file = caja_file_get (new_folder);

caja_file_set_metadata

(file, CAJA_METADATA_KEY_SCREEN,

g_free (data);

}

static NewFolderData *

new_folder_data_new (FMDirectoryView *directory_view)

{

return g_string_free (s, FALSE);

}

static void

add_submenu (GtkUIManager *ui_manager,

GtkActionGroup *action_group,

add_x_content_apps (view, CAJA_FILE (selection->data), &applications);

}

num_applications = g_list_length (applications);

if (file_list_all_are_folders (selection)) {

GtkAction *action;

} ExtensionActionCallbackData;

static void

extension_action_callback_data_free (ExtensionActionCallbackData *data)

{

g_setenv("CAJA_SCRIPT_CURRENT_URI", uri, TRUE);

g_setenv("NAUTILUS_SCRIPT_CURRENT_URI", uri, TRUE); // compatibilidad GNOME

g_free(uri);

geometry_string = eel_gtk_window_get_geometry_string(GTK_WINDOW (fm_directory_view_get_containing_window (view)));

return any_templates;

}

static void

update_templates_menu (FMDirectoryView *view)

{

g_free (templates_directory_uri);

}

static void

action_open_scripts_folder_callback (GtkAction *action,

gpointer callback_data)

view->details->templates_invalid = TRUE;

}

static gboolean

can_paste_into_file (CajaFile *file)

{

}

}

selection = fm_directory_view_get_selection (view);

count = g_list_length (selection);

}

gtk_action_set_sensitive (action, can_delete_files);

action = gtk_action_group_get_action (view->details->dir_action_group,

FM_ACTION_RESTORE_FROM_TRASH);

update_restore_from_trash_action (action, selection, FALSE);

FM_ACTION_SAVE_SEARCH_AS);

gtk_action_set_visible (action, show_save_search_as);

action = gtk_action_group_get_action (view->details->dir_action_group,

FM_ACTION_SELECT_ALL);

gtk_action_set_sensitive (action, !fm_directory_view_is_empty (view));

FM_ACTION_MOVE_TO_NEXT_PANE);

gtk_action_set_sensitive (action, can_delete_files && next_pane_is_writable);

action = gtk_action_group_get_action (view->details->dir_action_group,

FM_ACTION_COPY_TO_HOME);

gtk_action_set_sensitive (action, can_copy_files);

return;

}

EEL_CALL_METHOD

(FM_DIRECTORY_VIEW_CLASS, view,

update_menus, (view));

}

}

static GdkDragAction

ask_link_action (FMDirectoryView *view)

{

}

}

gboolean

fm_directory_view_handle_scroll_event (FMDirectoryView *directory_view,

GdkEventScroll *event)

return GTK_WIDGET_CLASS (parent_class)->scroll_event (widget, event);

}

static void

fm_directory_view_parent_set (GtkWidget *widget,

GtkWidget *old_parent)

entry = gtk_entry_new ();

gtk_widget_set_hexpand (entry, TRUE);

if (item_entry->localized)

{

val = g_key_file_get_locale_string (key_file,

gtk_widget_show_all (GTK_WIDGET (box));

}

static void

ditem_read_cb (GObject *source_object,

GAsyncResult *res,

g_message ("entire loading: %.3f, cumulative %.3f", elaps, cumu);

}

static void

fm_empty_view_begin_loading (FMDirectoryView *view)

{

{

}

static void

fm_empty_view_file_changed (FMDirectoryView *view, CajaFile *file, CajaDirectory *directory)

{

return NULL;

}

static GList *

fm_empty_view_get_selection_for_file_transfer (FMDirectoryView *view)

{

{

}

static int

fm_empty_view_compare_files (FMDirectoryView *view, CajaFile *file1, CajaFile *file2)

{

return FM_EMPTY_VIEW_ID;

}

static void

fm_empty_view_iface_init (CajaViewIface *iface)

{

iface->grab_focus = fm_empty_view_grab_focus;

}

static void

fm_empty_view_init (FMEmptyView *empty_view)

{

error->message);

}

eel_show_error_dialog (_("The group could not be changed."), message, parent_window);

g_free (file_name);

gulong clipboard_handler_id;

};

/* Note that the first item in this list is the default sort,

* and that the items show up in the menu in the order they

* appear in this list.

G_GNUC_END_IGNORE_DEPRECATIONS;

}

static gboolean

fm_icon_view_using_auto_layout (FMIconView *icon_view)

{

g_slist_free (file_list);

}

static gboolean

should_show_file_on_screen (FMDirectoryView *view, CajaFile *file)

{

G_GNUC_END_IGNORE_DEPRECATIONS;

}

static char *

fm_icon_view_get_directory_sort_by (FMIconView *icon_view,

CajaFile *file)

CajaFile *file)

{

return caja_file_get_boolean_metadata

(file, CAJA_METADATA_KEY_ICON_VIEW_AUTO_LAYOUT, TRUE);

}

fm_icon_view_reveal_selection (FM_DIRECTORY_VIEW (icon_view));

}

static void

action_reversed_order_callback (GtkAction *action,

gpointer user_data)

(get_icon_container (FM_ICON_VIEW (view)));

}

static void

fm_icon_view_set_selection (FMDirectoryView *view, GList *selection)

{

return FALSE;

}

static gboolean

should_preview_sound (CajaFile *file)

{

return fm_icon_view_compare_files ((FMIconView *)icon_view, a, b);

}

void

fm_icon_view_filter_by_screen (FMIconView *icon_view,

gboolean filter)

g_free (position_string);

}

g_ascii_dtostr (scale_string, sizeof (scale_string), position->scale);

caja_file_set_metadata

(file, CAJA_METADATA_KEY_ICON_SCALE,

set_columns_same_width (icon_view);

}

static void

fm_icon_view_sort_directories_first_changed (FMDirectoryView *directory_view)

{

}

}

static void

fm_icon_view_class_init (FMIconViewClass *klass)

{

view_info.startup_error_label = _(view_info.startup_error_label); \

view_info.display_location_label = _(view_info.display_location_label); \

static CajaViewInfo fm_icon_view =

{

.id = FM_ICON_VIEW_ID,

GSequenceIter *ptr;

FileEntry *file_entry;

model = (FMListModel *)tree_model;

g_return_val_if_fail (iter->stamp == model->details->stamp, NULL);

return ptr;

}

struct GetIters

{

FMListModel *model;

return res;

}

gboolean

fm_list_model_get_tree_iter_from_file (FMListModel *model, CajaFile *file,

CajaDirectory *directory,

}

}

file_entry->ptr = g_sequence_insert_sorted (files, file_entry,

fm_list_model_file_entry_compare_func, model);

return;

}

pos_before = g_sequence_iter_get_position (ptr);

g_sequence_sort_changed (ptr, fm_list_model_file_entry_compare_func, model);

file_entry->reverse_map = NULL;

}

void

fm_list_model_set_should_sort_directories_first (FMListModel *model, gboolean sort_directories_first)

{

CajaFile *file1,

CajaFile *file2);

int fm_list_model_add_column (FMListModel *model,

CajaColumn *column);

GError *error,

gpointer callback_data);

G_DEFINE_TYPE_WITH_CODE (FMListView, fm_list_view, FM_TYPE_DIRECTORY_VIEW,

G_IMPLEMENT_INTERFACE (CAJA_TYPE_VIEW,

fm_list_view_iface_init));

file_list = fm_list_view_get_selection (FM_DIRECTORY_VIEW (view));

if (view->details->renaming_file)

{

/* We're currently renaming a file, wait until the rename is

-1);

}

uri = caja_file_get_uri (file);

caja_debug_log (FALSE, CAJA_DEBUG_LOG_DOMAIN_USER,

"list view row collapsed window=%p: %s",

}

}

reversed_attr = (reversed ? "true" : "false");

caja_file_set_metadata (file, CAJA_METADATA_KEY_LIST_VIEW_SORT_REVERSED,

default_reversed_attr, reversed_attr);

gtk_widget_show (GTK_WIDGET (view->details->tree_view));

gtk_container_add (GTK_CONTAINER (view), GTK_WIDGET (view->details->tree_view));

atk_obj = gtk_widget_get_accessible (GTK_WIDGET (view->details->tree_view));

atk_object_set_name (atk_obj, _("List View"));

}

g_object_unref (view);

}

static void

fm_list_view_file_changed (FMDirectoryView *view, CajaFile *file, CajaDirectory *directory)

{

}

}

static GList *

fm_list_view_get_selection_for_file_transfer (FMDirectoryView *view)

{

return g_list_reverse (selection_data.list);

}

static guint

fm_list_view_get_item_count (FMDirectoryView *view)

{

}

}

}

static void

return FM_LIST_VIEW_ID;

}

static void

fm_list_view_iface_init (CajaViewIface *iface)

{

iface->get_title = NULL;

}

static void

fm_list_view_init (FMListView *list_view)

{

g_object_unref (icon);

}

static void

update_properties_window_icon (FMPropertiesWindow *window)

{

return TRUE;

}

static void

reset_icon (FMPropertiesWindow *properties_window)

{

}

}

static void

fm_properties_window_drag_data_received (GtkWidget *widget, GdkDragContext *context,

int x, int y,

uris = g_strsplit (gtk_selection_data_get_data (selection_data), "\r\n", 0);

exactly_one = uris[0] != NULL && (uris[1] == NULL || uris[1][0] == '\0');

if (!exactly_one) {

eel_show_error_dialog

(_("You cannot assign more than one custom icon at a time!"),

}

}

static gboolean

file_list_all_directories (GList *file_list)

{

return -1;

}

static void

synch_groups_combo_box (GtkComboBox *combo_box, CajaFile *file)

{

return attach_label (grid, NULL, title, FALSE, FALSE, TRUE);

}

#define INCONSISTENT_STATE_STRING \

"\xE2\x80\x92"

return FALSE;

}

return TRUE;

}

width = allocation.width;

height = allocation.height;

free = (double)window->details->volume_free / (double)window->details->volume_capacity;

used = 1.0 - free;

cairo_line_to (cr,xc,yc);

}

gdk_cairo_set_source_rgba (cr, &window->details->free_color);

cairo_fill_preserve(cr);

}

}

/* Copied from gtk/gtkstyle.c */

static void

b->alpha = a->alpha;

}

static GtkWidget*

create_pie_widget (FMPropertiesWindow *window)

{

}

if (!gtk_style_context_lookup_color (style, "chart_rgba_2", &window->details->free_color)) {

window->details->free_color.red = FREE_FILL_R;

window->details->free_color.green = FREE_FILL_G;

return FALSE;

}

static gboolean

files_has_file (FMPropertiesWindow *window)

{

return FALSE;

}

static void

create_emblems_page (FMPropertiesWindow *window)

{

sensitive |= window->details->has_recursive_apply;

}

g_signal_handlers_block_by_func (G_OBJECT (button),

G_CALLBACK (permission_button_toggled),

window);

return vfs_perm;

}

static PermissionValue

permission_from_vfs (PermissionType type, guint32 vfs_perm)

{

GTK_POS_RIGHT, 1, 1);

}

static GtkWidget *

append_special_execution_checkbox (FMPropertiesWindow *window,

GtkGrid *grid,

g_object_unref (window);

}

static void

apply_recursive_clicked (GtkWidget *recursive_button,

FMPropertiesWindow *window)

vbox, gtk_label_new (_("Open With")));

}

static FMPropertiesWindow *

create_properties_window (StartupData *startup_data)

{

}

}

void

fm_properties_window_present (GList *original_files,

GtkWidget *parent_widget)

return;

}

pending_key = get_pending_key (original_files);

/* Look to see if we're already waiting for a window for this file. */

_("Creating Properties window."),

parent_window == NULL ? NULL : GTK_WINDOW (parent_window));

for (l = startup_data->target_files; l != NULL; l = next) {

next = l->next;

caja_file_call_when_ready

iface->unref_node = fm_tree_model_unref_node;

}

GObjectClass parent;

} FMTreeViewProviderClass;

struct FMTreeViewDetails

{

CajaWindowInfo *window;

}

}

static gboolean

show_iter_for_file (FMTreeView *view, CajaFile *file, GtkTreeIter *iter)

{

return result;

}

static char *

get_root_uri_callback (CajaTreeViewDragDest *dest,

gpointer user_data)

G_CALLBACK (popup_menu_deactivated),

view);

/* add the "open" menu item */

menu_item = eel_image_menu_item_new_from_icon ("document-open", _("_Open"));

g_signal_connect (menu_item, "activate",

fm_tree_model_add_root_uri (view->details->child_model, "trash:///", _("Trash"), icon, NULL);

g_object_unref (icon);

volume_monitor = g_volume_monitor_get ();

view->details->volume_monitor = volume_monitor;

mounts = g_volume_monitor_get_mounts (volume_monitor);

/* fm-tree-view.h - tree view. */

#ifndef FM_TREE_VIEW_H

#define FM_TREE_VIEW_H

return FM_WIDGET_VIEW_ID;

}

static void

fm_widget_view_iface_init (CajaViewIface *iface)

{

iface->grab_focus = fm_widget_view_grab_focus;

}

static void

fm_widget_view_init (FMWidgetView *widget_view)

{