<category name="patterns" _display_name="_Patterns" image="backgrounds.png"

columns="5" mode="directory" path="caja/patterns" type="property/bgimage"

_description="Drag a pattern tile to an object to change it">

<pattern _display_name="Camouflage" filename="camouflage"/>

<pattern _display_name="Chalk" filename="chalk"/>

<pattern _display_name="Cork" filename="cork"/>

<pattern _display_name="Fossil" filename="fossil"/>

<pattern _display_name="MATE" filename="mate"/>

<pattern _display_name="Green Weave" filename="green_weave"/>

<pattern _display_name="Manila Paper" filename="manila_paper"/>

<pattern _display_name="Moss Ridge" filename="moss_ridge"/>

<pattern _display_name="Numbers" filename="numbers"/>

<pattern _display_name="Terracotta" filename="terracotta"/>

<pattern _display_name="Wavy White" filename="wavy_white"/>

</category>

<category name="colors" _display_name="C_olors" image="colors.png" columns="5" mode="inline" type="application/x-color" _description="Drag a color to an object to change it to that color">

<color _name="Mango">#E0D656</color>

<color _name="Orange">#D2AB50</color>

<color _name="Sky">#3978A7</color>

<color _name="Danube">#184A7F</color>

<color _name="Indigo">#3E4985</color>

<color _name="Sea Foam">#CCFFCC</color>

<color _name="Leaf">#66CC66</color>

<color _name="Deep Teal">#457263</color>

<color _name="Envy">#2C821E</color>

<color _name="Azul">#1822CA</color>

<color _name="Lemon">#F6E118</color>

<color _name="White">#FFFFFF</color>

<color _name="Apparition">#E5E5E5</color>

<color _name="Silver">#C9C9C9</color>

<color _name="Eclipse">#525252</color>

<color _name="Charcoal">#323232</color>

<color _name="Onyx">#222222</color>

</category>

<category name="emblems" _display_name="_Emblems" image="emblems.png" columns="6" mode="directory" path="caja/emblems" type="property/keyword" _description="Drag an emblem to an object to add it to the object">

<!-- translators: this is the name of an emblem -->

<emblem _display_name="Erase" filename="erase"/>

uses a number of CajaView objects to communicate with view

components. The relationship between CajaWindow and the

CajaViews is mostly, but not completely one-way; primarily, the

The CajaView object serves as a proxy for a view component. It

provides a number of methods which correspond to the methods of the

* Other Communication

The Caja:View and Caja:ViewFrame interfaces allow for other

The view may request that the frame update the status message,

indicate a certain level of progress during loading, or display a

if you are a source, you have to start a drag trough gtk_drag_begin.

This will call drag_begin signal in the source.

called in the source.

calls gtk_drag_get_data

those 3 signals and it should not have any memory management issue.

--------------

Things get a little bit complicated.

events. In caja, we do many things in this function:

- we start auto-scrolling if it is necessary.

- we call caja_*_ensure_data

- we prelight what is under the cursor if it can accept the drag.

- we try to expand what is under you if it can accept the drop (tree view)

data from the source. this allows the destination to store it in advance and use it

to know if what is under the cursor can accept the drag.

If no drop occurs, a drag_leave occurs.

in motion and store it. It is also called to do the actual drop operation when

a drop happened.

To solve 1), we should use ONE destroy function which cleans up the drag data.

To solve 2), we have to be very careful where we call this fution from.

- the list of expanded nodes (tree view).

- the autoscroll code.

- the prelighting code.

It also has to set drag_info->need_to_destroy to TRUE

rest of the drag data is destroyed before begening the actual

new drag.

Shift Tab - moves to the "previous" icon in order

Home - moves to the first icon

End - moves to the last icon

In order to allow multiple selection the above navigation keys can be

combined with the Control key to move the keyboard focus without

affecting the current selection. If you use normal movement (not using

In manual layout (and especially, on the desktop) the keyboard arrow

keys work in a slightly different way. To allow all icons to be

reached the closest icon in the quadrant of the direction selected

Other keyboard shortcuts:

<?xml version="1.0"?>

"http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [

<!ENTITY version SYSTEM "version.xml">

]>

widget_realized_setup (widget, self);

}

static void

gtk_container_add (GTK_CONTAINER (box), icon);

gtk_container_add (GTK_CONTAINER (box), label_menu);

gtk_container_add (GTK_CONTAINER (menuitem), box);

gtk_widget_show_all (menuitem);

? 0 \

: ((* class_cast_macro (G_OBJECT_GET_CLASS (object))->signal) \

parameters) \

#ifndef G_DISABLE_ASSERT

/* Define a signal that is not implemented by this class but must be

}

/* Create the dialog. */

0,

message_type,

GTK_BUTTONS_NONE,

gtk_label_set_max_width_chars (label, (ELLIPSISED_MENU_ITEM_MIN_CHARS + 2));

GtkWidget *menuitem = gtk_menu_item_new ();

gtk_container_add (GTK_CONTAINER (box), icon);

gtk_container_add (GTK_CONTAINER (box), label_menu);

gtk_container_add (GTK_CONTAINER (menuitem), box);

gtk_widget_show_all (menuitem);

retval = g_build_filename (xdg_dir, "desktop-metadata", NULL);

g_free (xdg_dir);

return retval;

}

if (caja_desktop_update_metadata_from_keyfile (file, name)) {

caja_file_changed (file);

}

#define STRV_TERMINATOR "@x-caja-desktop-metadata-term@"

should_skip_file (CajaDirectory *directory, GFileInfo *info)

{

static gboolean show_hidden_files_changed_callback_installed = FALSE;

/* Add the callback once for the life of our process */

if (!show_hidden_files_changed_callback_installed)

{

*

* You should have received a copy of the GNU Library General Public

* License along with this library; if not, write to the Free

* Boston, MA 02110-1301, USA.

*

* Author: Alexander van der Meij <[email protected]>

{

gchar **list;

gint i;

CAJA_PREFERENCES_DISABLED_EXTENSIONS);

if (list != NULL)

gchar **new;

gint size;

gboolean retval;

CAJA_PREFERENCES_DISABLED_EXTENSIONS);

for (size = 0; current[size] != NULL; size++);

size += 1;

size += 1;

new = g_realloc_n (current, size, sizeof (gchar *));

new[size - 2] = g_strdup (value);

new[size - 1] = NULL;

CAJA_PREFERENCES_DISABLED_EXTENSIONS,

(const gchar **) new);

GArray *array;

gint i;

gboolean retval;

CAJA_PREFERENCES_DISABLED_EXTENSIONS);

array = g_array_new (TRUE, TRUE, sizeof (gchar *));

{

if (g_strcmp0 (current[i], value) != 0)

array = g_array_append_val (array, current[i]);

}

CAJA_PREFERENCES_DISABLED_EXTENSIONS,

(const gchar **) array->data);

g_return_val_if_fail (ext->state != new_state, FALSE);

ext->state = new_state;

}

gboolean retval;

if (new_state) {

retval = gsettings_remove_from_list (ext->filename);

else {

retval = gsettings_append_to_list (ext->filename);

}

g_return_val_if_fail (retval == TRUE, FALSE);

return TRUE;

}

*

* You should have received a copy of the GNU Library General Public

* License along with this library; if not, write to the Free

* Boston, MA 02110-1301, USA.

*

* Author: Alexander van der Meij <[email protected]>

gtk_button_set_label (GTK_BUTTON (details->replace_button),

_("Merge"));

}

/* If meld is installed, and source and destination arent binary

* files, show the diff button

*/

g_free (meld_found);

gboolean src_is_binary;

gboolean dest_is_binary;

src_is_binary = caja_file_is_binary (details->source);

dest_is_binary = caja_file_is_binary (details->destination);

if (!src_is_binary && !dest_is_binary)

gtk_widget_show (details->diff_button);

}

{

CajaFileConflictDialogPrivate *details;

details = dialog->details;

GError *error;

char *command;

argv[1] = g_file_get_path (caja_file_get_location (details->source));

argv[2] = g_file_get_path (caja_file_get_location (details->destination));

argv[3] = NULL;

error = NULL;

if (!g_spawn_async_with_pipes (NULL,

argv,

if (common->skip_files != NULL) {

return g_hash_table_lookup (common->skip_files, file) != NULL;

}

return FALSE;

}

file->details->is_symlink = is_symlink;

is_hidden = g_file_info_get_is_hidden (info);

if (file->details->is_hidden != is_hidden ||

file->details->is_backup != is_backup) {

changed = TRUE;

}

file->details->is_hidden = is_hidden;

is_mountpoint = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT);

if (file->details->is_mountpoint != is_mountpoint) {

changed = TRUE;

MAX (h * thumb_scale, 1),

GDK_INTERP_BILINEAR);

gboolean is_image = file->details->mime_type &&

(strncmp(eel_ref_str_peek (file->details->mime_type), "image/", 6) == 0);

if (!is_image ||

{

return FALSE;

}

gboolean is_binary = FALSE;

int i = 0;

FILE *fp;

/* Check the first 4096 bytes of the files. If these contains a 0,

* we can assume the file is binary.

* This idea is taken from python code of meld.

*/

fp = g_fopen (g_file_get_path (caja_file_get_location (file)), "r");

if (fp == NULL)

{

return FALSE;

}

while (!feof (fp)) {

int c;

i++;

}

fclose(fp);

return is_binary;

}

}

initialized = TRUE;

caja_preferences = g_settings_new("org.mate.caja.preferences");

caja_media_preferences = g_settings_new("org.mate.media-handling");

caja_window_state = g_settings_new("org.mate.caja.window-state");

g_param_spec_boolean ("highlighted_for_selection",

"highlighted for selection",

"whether we are highlighted for a selection",

g_object_class_install_property (

object_class,

g_param_spec_boolean ("highlighted_as_keyboard_focus",

"highlighted as keyboard focus",

"whether we are highlighted to render keyboard focus",

g_object_class_install_property (

l = container->details->icons;

while (l) {

icon = l->data;

if (icon->item == item) {

if (icon->is_selected) {

one_item_selected = TRUE;

while ((action = (CajaUndoStackActionData *) g_queue_pop_tail (tmp_stack)) != NULL)

if (action->trashed)

trash = g_list_append(trash, l->data);

}

g_queue_free (tmp_stack);

return (trash);

}

is_destination_uri_action_partof_trashed(GList *trash, GList *g)

{

GList *l;

char *uri;

//printf ("destinations: %s\n", g_file_get_uri(l->data));

uri = g_file_get_uri(g->data);

if (!strcmp (uri, l->data)) {

typedef struct _CajaUndoStackManagerClass

{

GObjectClass parent_class;

} CajaUndoStackManagerClass;

#define TYPE_CAJA_UNDOSTACK_MANAGER (caja_undostack_manager_get_type())

#define CAJA_UNDOSTACK_MANAGER_GET_CLASS(object) \

(G_TYPE_INSTANCE_GET_CLASS((object), TYPE_CAJA_UNDOSTACK_MANAGER, CajaUndoStackManagerClass))

GType

caja_undostack_manager_get_type (void);

void

caja_undostack_manager_data_add_file_permissions(

CajaUndoStackActionData* data, GFile* file, guint32 permission);

void

caja_undostack_manager_data_set_recursive_permissions(

CajaUndoStackActionData* data, guint32 file_permissions, guint32 file_mask,

guint32 dir_permissions, guint32 dir_mask);

void

caja_undostack_manager_data_set_file_permissions(

CajaUndoStackActionData* data, char* uri, guint32 current_permissions, guint32 new_permissions);

void

caja_undostack_manager_data_set_owner_change_information(

CajaUndoStackActionData* data, char* uri, const char* current_user, const char* new_user);

void

caja_undostack_manager_data_set_group_change_information(

#endif /* CAJA_UNDOSTACK_MANAGER_H */

NULL, NULL,

g_cclosure_marshal_VOID__VOID,

G_TYPE_NONE, 0);

initialized = TRUE;

}

}

(* get_backup_files_mode) (CajaWindowInfo *window);

void (* set_backup_files_mode) (CajaWindowInfo *window,

CajaWindowShowBackupFilesMode mode);

CajaWindowSlotInfo * (* get_active_slot) (CajaWindowInfo *window);

CajaWindowSlotInfo * (* get_extra_slot) (CajaWindowInfo *window);

CajaWindowShowBackupFilesMode caja_window_info_get_backup_files_mode (CajaWindowInfo *window);

void caja_window_info_set_backup_files_mode (CajaWindowInfo *window,

CajaWindowShowBackupFilesMode mode);

gboolean caja_window_info_get_initiated_unmount (CajaWindowInfo *window);

void caja_window_info_set_initiated_unmount (CajaWindowInfo *window,

gboolean initiated_unmount);

char *data;

data = caja_application_get_session_data (application);

{

g_key_file_set_string (state_file,

"Caja",

static void

open_window (CajaApplication *application,

gboolean browser_window)

{

CajaApplication *self = CAJA_APPLICATION (application);

static void

open_tabs (CajaApplication *application,

gboolean browser_window)

{

CajaApplication *self = CAJA_APPLICATION (application);

/* monitor the preference to use browser or spatial windows */

/* connect before trying to read or this preference won't be read by root or after change */

"changed::"CAJA_PREFERENCES_ALWAYS_USE_BROWSER,

G_CALLBACK (caja_empty_callback_to_ensure_read),

self);

caja_window_go_to (window, locations[0]);

g_free (uri);

for (int i = 1; i< n_files;i++) {

* tab is opened before the previous one */

guint tab = n_files-i;

uri = g_file_get_uri (locations[tab]);

/* Open one window with one tab at each requested location */

open_tabs (application, files, n_files, screen, geometry, browser_window);

} else {

i = 0;

open_window (application, files[i], screen, geometry, browser_window);

i++ ;

}

}

caja_window_slot_open_location_full (caja_window_get_active_slot (window), location,

sel_list, NULL, NULL);

if (sel_list != NULL) {

{

g_bus_unwatch_name (application->ss_watch_id);

}

if (application->volume_queue != NULL)

{

g_list_free_full (application->volume_queue, g_object_unref);

} else {

/* mount it immediately */

caja_file_operations_mount_volume (NULL, volume, TRUE);

}

static void

CajaDirectory *directory;

GFile *root;

gchar *uri;

root = g_mount_get_root (mount);

uri = g_file_get_uri (root);

g_debug ("Added mount at uri %s", uri);

g_free (uri);

directory = caja_directory_get_existing (root);

g_object_unref (root);

if (directory != NULL) {

}

win_node = xmlNewChild (root_node, NULL, "window", NULL);

xmlNewProp (win_node, "location", tmp);

g_free (tmp);

xmlNewProp (win_node, "type", CAJA_IS_NAVIGATION_WINDOW (window) ? "navigation" : "spatial");

if (CAJA_IS_NAVIGATION_WINDOW (window)) { /* spatial windows store their state as file metadata */

xmlSaveFlush (ctx) < 0) {

g_message ("failed to save session");

}

xmlSaveClose(ctx);

data = g_strndup (buffer->content, buffer->use);

xmlBufferFree (buffer);

}

bail = TRUE;

doc = xmlReadMemory (data, strlen (data), NULL, "UTF-8", 0);

if (doc != NULL && (root_node = xmlDocGetRootElement (doc)) != NULL)

{

else if (g_strcmp0 (type, "spatial") == 0)

{

location = g_file_new_for_uri (location_uri);

location, gdk_screen_get_default (),

NULL);

const GOptionEntry options[] = {

#ifndef CAJA_OMIT_SELF_CHECK

N_("Perform a quick set of self-check tests."), NULL },

#endif

{ "version", '\0', 0, G_OPTION_ARG_NONE, &version,

N_("Do not manage the desktop (ignore the preference set in the preferences dialog)."), NULL },

{ "force-desktop", '\0', 0, G_OPTION_ARG_NONE, &self->priv->force_desktop,

N_("Manage the desktop regardless of set preferences or environment (on new startup only)"), NULL },

N_("Open URIs in tabs."), NULL },

N_("Open a browser window."), NULL },

N_("Quit Caja."), NULL },

{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &remaining, NULL, N_("[URI...]") },

out:

g_option_context_free (context);

}

self);

}

caja_application_save_accel_map (gpointer data)

{

if (save_of_accel_map_requested) {

return FALSE;

}

queue_accel_map_save_callback (GtkAccelMap *object, gchar *accel_path,

guint accel_key, GdkModifierType accel_mods,

gpointer user_data)

{

if (!save_of_accel_map_requested) {

save_of_accel_map_requested = TRUE;

caja_application_save_accel_map, NULL);

}

}

/* initialize theming */

init_icons_and_styles ();

init_gtk_accels ();

/* initialize caja modules */

caja_module_setup ();

/* attach menu-provider module callback */

menu_provider_init_callback ();

/* Initialize notifications for eject operations */

/* Watch for unmounts so we can close open windows */

/* TODO-gio: This should be using the UNMOUNTED feature of GFileMonitor instead */

init_desktop (self);

/* exit_with_last_window is already set to TRUE, and we need to keep that value

* Otherwise, we read the value from the configuration.

*/

{

GApplication *instance;

CAJA_PREFERENCES_EXIT_WITH_LAST_WINDOW);

/*Keep this inside the running as mate/not as root block */

/*So other desktop don't get unkillable caja instances holding open */

gint width, height;

connect_dialog_restore_info_bar (dialog, GTK_MESSAGE_INFO);

content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (dialog->details->info_bar));

image = gtk_image_new_from_icon_name ("dialog-error", GTK_ICON_SIZE_SMALL_TOOLBAR);

gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 6);

gtk_widget_show (image);

label = gtk_label_new (_("Can't load the supported server method list.\n"

"Please check your GVfs installation."));

gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 6);

g_signal_handlers_disconnect_by_func (entry,

iconized_entry_changed_cb,

}

static void

g_free (str);

case G_IO_ERROR_FAILED:

default:

label = gtk_label_new (error->message);

g_mount_operation_set_password (G_MOUNT_OPERATION (operation),

str);

set_flags ^= G_ASK_PASSWORD_NEED_PASSWORD;

if (flags & G_ASK_PASSWORD_SAVING_SUPPORTED &&

gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->details->remember_checkbox))) {

g_mount_operation_set_password_save (G_MOUNT_OPERATION (operation),

GtkTreeModel *model;

gboolean new_state;

Extension *ext;

path = gtk_tree_path_new_from_string (path_str);

model = gtk_tree_view_get_model (GTK_TREE_VIEW (data));

g_object_get (G_OBJECT (cell), "active", &new_state, NULL);

gtk_tree_model_get_iter_from_string (model, &iter, path_str);

new_state ^= 1;

if (&iter != NULL)

{

gtk_tree_model_get (model, &iter, EXT_STRUCT_COLUMN, &ext, -1);

if (caja_extension_set_state (ext, new_state))

{

EXT_STATE_COLUMN, new_state, -1);

}

}

GdkPixbuf *ext_pixbuf_icon;

GtkButton *about_button, *configure_button;

gchar *ext_text_info;

GList *extensions;

int i;

gtk_builder_get_object (builder, "extension_view"));

store = GTK_LIST_STORE (

gtk_builder_get_object (builder, "extension_store"));

toggle = GTK_CELL_RENDERER_TOGGLE (

gtk_builder_get_object (builder, "extension_toggle"));

g_object_set (toggle, "xpad", 6, NULL);

g_signal_connect (toggle, "toggled",

G_CALLBACK (extension_state_toggled), view);

icon_theme = gtk_icon_theme_get_default();

for (i = 0; i < g_list_length (extensions); i++)

{

Extension* ext = EXTENSION (g_list_nth_data (extensions, i));

gtk_list_store_append (store, &iter);

gtk_list_store_set (store, &iter,

EXT_STATE_COLUMN, ext->state,

EXT_INFO_COLUMN, ext_text_info,

EXT_STRUCT_COLUMN, ext, -1);

if (g_getenv ("CAJA_DEBUG") != NULL) {

eel_make_warnings_and_criticals_stop_in_debugger ();

}

/* Initialize gettext support */

bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);

bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

if (g_file_test (DATADIR "/applications/caja.desktop", G_FILE_TEST_EXISTS)) {

egg_set_desktop_file (DATADIR "/applications/caja.desktop");

}

#ifdef HAVE_EXEMPI

xmp_init();

#endif

/* navigation bar (manual entry) */

caja_location_bar_set_active (CAJA_LOCATION_BAR (nav_pane->navigation_bar), is_active);

/* location button */

gtk_widget_set_sensitive (gtk_bin_get_child (GTK_BIN (nav_pane->location_button)), is_active);

}

g_assert (slot != NULL);

caja_window_set_active_slot (slot->pane->window, slot);

caja_window_slot_update_icon (slot);

return FALSE;

{

caja_navigation_window_pane_set_bar_mode (pane, CAJA_BAR_PATH);

}

g_signal_handlers_block_by_func (pane->location_button,

G_CALLBACK (location_button_toggled_cb),

pane);

gtk_widget_hide (pane->navigation_bar);

break;

}

if (mode == CAJA_BAR_NAVIGATION || mode == CAJA_BAR_PATH) {

use_entry = (mode == CAJA_BAR_NAVIGATION);

<menuitem name="Folder Window" action="Folder Window"/>

<separator/>

</placeholder>

<placeholder name="Close Items Placeholder">

<menuitem name="Close All Windows" action="Close All Windows"/>

</placeholder>

gtk_paned_pack2 (GTK_PANED (window->details->content_paned), vbox,

TRUE, FALSE);

gtk_widget_show (vbox);

hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);

gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);

gtk_widget_show (hpaned);

gint width, height, bold_width, bold_height;

gint pad_left, pad_right;

gchar *markup;

layout = gtk_widget_create_pango_layout (button_data->label, dir_name);

pango_layout_get_pixel_size (layout, &width, &height);

* will get the event too and call us back.

*/

current_location = caja_file_get_location (current_button_data->file);

if (g_file_has_prefix (location, current_location))

{

/* remove this and the following buttons */

gtk_list_store_append (sidebar->store, &iter);

gtk_list_store_set (sidebar->store, &iter,

PLACES_SIDEBAR_COLUMN_ROW_TYPE, PLACES_HEADING,

PLACES_SIDEBAR_COLUMN_HEADING_TEXT, title,

PLACES_SIDEBAR_COLUMN_EJECT, FALSE,

PLACES_SIDEBAR_COLUMN_NO_EJECT, TRUE,

location, mount_uri, last_uri,

&last_iter, &select_path);

/* XDG directories */

xdg_dirs = NULL;

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

compare_for_selection (sidebar,

location, mount_uri, last_uri,

&last_iter, &select_path);

g_free (location);

if (select_path != NULL) {

NULL);

g_free (primary);

}

}

else {

*/

/* if this is the only window, we don't want to quit, so we redirect it to home */

app = CAJA_APPLICATION (g_application_get_default ());

if (g_list_length (gtk_application_get_windows (GTK_APPLICATION (app))) == 1) {

/* the user could have typed in a home directory that doesn't exist,

g_signal_connect_swapped (caja_preferences, "changed::" CAJA_PREFERENCES_SHOW_BACKUP_FILES,

G_CALLBACK(show_backup_files_preference_callback),

window);

window->details->ui_manager = gtk_ui_manager_new ();

ui_manager = window->details->ui_manager;

gtk_window_add_accel_group (GTK_WINDOW (window),

iface->get_selection = caja_window_get_selection;

iface->get_hidden_files_mode = caja_window_get_hidden_files_mode;

iface->set_hidden_files_mode = caja_window_set_hidden_files_mode;

iface->get_backup_files_mode = caja_window_get_backup_files_mode;

iface->set_backup_files_mode = caja_window_set_backup_files_mode;

binding_set = gtk_binding_set_by_class (class);

gtk_binding_entry_add_signal (binding_set,

"change_value",

1, GTK_TYPE_SCROLL_TYPE,

GTK_SCROLL_STEP_DOWN);

GTK_SCROLL_STEP_DOWN);

gtk_binding_entry_add_signal (binding_set,

"zoom_to_default",

0);

gtk_binding_entry_add_signal (binding_set,

"zoom_to_default",

0);

gtk_binding_entry_add_signal (binding_set,

"change_value",

1, GTK_TYPE_SCROLL_TYPE,

GTK_SCROLL_STEP_UP);

gtk_binding_entry_add_signal (binding_set,

"change_value",

1, GTK_TYPE_SCROLL_TYPE,

GTK_SCROLL_STEP_UP);

gboolean show_foreign_files;

gboolean show_hidden_files;

gboolean ignore_hidden_file_preferences;

gboolean show_backup_files;

gboolean batching_selection_level;

gboolean show_hidden_files;

gboolean show_backup_files;

gboolean show_only_directories;

GList *highlighted_files;

};

g_signal_connect (directory, "files-changed", G_CALLBACK (files_changed), NULL);

g_signal_connect (directory, "done-loading", G_CALLBACK (done_loading), NULL);

caja_directory_file_monitor_add (directory, client1, TRUE,

NULL, NULL);

static void

hits_added_cb (CajaSearchEngine *engine, GSList *hits)

g_print ("hits added\n");

while (hits) {

g_print (" - %s\n", (char *)hits->data);

// gtk_main_quit ();

}

main (int argc, char* argv[])

{

CajaSearchEngine *engine;

gtk_init (&argc, &argv);

engine = caja_search_engine_new ();

G_CALLBACK (hits_added_cb), NULL);

G_CALLBACK (hits_subtracted_cb), NULL);

G_CALLBACK (finished_cb), NULL);

query = caja_query_new ();

g_object_unref (query);

caja_search_engine_start (engine);

gtk_main ();

return 0;

}

#include "test.h"

main (int argc, char* argv[])

{

CajaCustomizationData *customization_data;

gtk_widget_show (emblems_table);

gtk_container_set_border_width (GTK_CONTAINER (emblems_table), 8);

scroller = gtk_scrolled_window_new (NULL, NULL);

gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroller),

GTK_POLICY_NEVER,

gtk_widget_show (scroller);

#if 0

* This must be done after the widget is realized, due to

* an apparent bug in gtk_viewport_set_shadow_type.

*/

NULL);

#endif

/* Use caja_customization to make the emblem widgets */

customization_data = caja_customization_data_new ("emblems", TRUE,

CAJA_ICON_SIZE_SMALL);

while (caja_customization_data_get_next_element_for_display (customization_data,

&emblem_name,

&pixbuf,

stripped_name = eel_filename_strip_extension (emblem_name);

g_free (emblem_name);

if (strcmp (stripped_name, "erase") == 0) {

g_object_unref (pixbuf);

g_free (label);

"caja_property_name",

stripped_name,

(GDestroyNotify) g_free);

gtk_container_add (GTK_CONTAINER (emblems_table), button);

}

gtk_widget_show_all (emblems_table);

gtk_widget_show (window);

gtk_main ();

return 0;

}

gtk_main_quit ();

}

main (int argc, char* argv[])

{

GtkWidget *window;

sources = g_list_prepend (sources, source);

}

sources = g_list_reverse (sources);

dest = g_file_new_for_commandline_arg (argv[i]);

window = test_window_new ("copy test", 5);

gtk_widget_show (window);

caja_file_operations_copy (sources,

g_signal_connect (progress_info, "changed", (GCallback)changed_cb, NULL);

g_signal_connect (progress_info, "progress-changed", (GCallback)progress_changed_cb, NULL);

g_signal_connect (progress_info, "finished", (GCallback)finished_cb, NULL);

gtk_main ();

return 0;

}

gtk_main_quit ();

}

main (int argc, char* argv[])

{

GtkWidget *window;

GtkWidget *label;

GtkWidget *vbox;

gtk_init (&argc, &argv);

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);

gtk_container_add (GTK_CONTAINER (window), vbox);

label = eel_editable_label_new ("Centered dsau dsfgsdfgoydsfiugy oiusdyfg iouysdf goiuys dfioguy siodufgy iusdyfgiu ydsf giusydf gouiysdfgoiuysdfg oiudyfsg Label");

gtk_widget_set_size_request (label, 200, -1);

eel_editable_label_set_line_wrap (EEL_EDITABLE_LABEL (label), TRUE);

gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 4);

label = eel_editable_label_new ("Left aligned label");

gtk_label_set_xalign (GTK_LABEL (label), 0.0);

gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 4);

label = eel_editable_label_new ("Right aligned label");

gtk_label_set_xalign (GTK_LABEL (label), 1.0);

gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 4);

gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);

gtk_main ();

return 0;

{

const char *info = callback_data;

g_return_if_fail (GTK_IS_BUTTON (button));

g_print ("%s(%p)\n", info, button);

}

}

gtk_widget_show_all (vbox);

return window;

}

main (int argc, char* argv[])

{

GtkWidget *labeled_image_window = NULL;

if (labeled_image_window) gtk_widget_show (labeled_image_window);

if (labeled_image_button_window) gtk_widget_show (labeled_image_button_window);

gtk_main ();

return test_quit (EXIT_SUCCESS);

#define DEST_WIDTH 32

#define DEST_HEIGHT 32

main (int argc, char* argv[])

{

GdkPixbuf *pixbuf, *scaled;

GError *error;

struct timeval t1, t2;

int i;

test_init (&argc, &argv);

if (argc != 2) {

printf ("error loading pixbuf: %s\n", error->message);

exit (1);

}

printf ("scale factors: %f, %f\n",

(double)gdk_pixbuf_get_width(pixbuf)/DEST_WIDTH,

(double)gdk_pixbuf_get_height(pixbuf)/DEST_HEIGHT);

gettimeofday(&t1, NULL);

for (i = 0; i < N_SCALES; i++) {

scaled = eel_gdk_pixbuf_scale_down (pixbuf, DEST_WIDTH, DEST_HEIGHT);

gettimeofday(&t2, NULL);

g_print ("Time for eel_gdk_pixbuf_scale_down: %ld msecs\n",

(t2.tv_sec - t1.tv_sec) * 1000 + (t2.tv_usec - t1.tv_usec) / 1000);

gettimeofday(&t1, NULL);

for (i = 0; i < N_SCALES; i++) {

scaled = gdk_pixbuf_scale_simple (pixbuf, DEST_WIDTH, DEST_HEIGHT, GDK_INTERP_NEAREST);

g_print ("Time for INTERP_NEAREST: %ld msecs\n",

(t2.tv_sec - t1.tv_sec) * 1000 + (t2.tv_usec - t1.tv_usec) / 1000);

gettimeofday(&t1, NULL);

for (i = 0; i < N_SCALES; i++) {

scaled = gdk_pixbuf_scale_simple (pixbuf, DEST_WIDTH, DEST_HEIGHT, GDK_INTERP_BILINEAR);

gettimeofday(&t2, NULL);

g_print ("Time for INTERP_BILINEAR: %ld msecs\n",

(t2.tv_sec - t1.tv_sec) * 1000 + (t2.tv_usec - t1.tv_usec) / 1000);

scaled = eel_gdk_pixbuf_scale_down (pixbuf, DEST_WIDTH, DEST_HEIGHT);

g_object_unref (scaled);

scaled = gdk_pixbuf_scale_simple (pixbuf, DEST_WIDTH, DEST_HEIGHT, GDK_INTERP_NEAREST);

g_object_unref (scaled);

scaled = gdk_pixbuf_scale_simple (pixbuf, DEST_WIDTH, DEST_HEIGHT, GDK_INTERP_BILINEAR);

g_object_unref (scaled);

return 0;

GtkWidget *window;

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

if (title != NULL) {

gtk_window_set_title (GTK_WINDOW (window), title);

}

g_signal_connect (window, "delete_event",

G_CALLBACK (test_delete_event), NULL);

gtk_container_set_border_width (GTK_CONTAINER (window), border_width);

return window;

}

g_return_if_fail (image_name != NULL);

background = eel_get_widget_background (widget);

uri = g_strdup_printf ("file://%s/%s", CAJA_DATADIR, image_name);

eel_background_set_image_uri (background, uri);

g_return_if_fail (color_spec != NULL);

background = eel_get_widget_background (widget);

eel_background_set_color (background, color_spec);

}

g_free (path);

g_return_val_if_fail (pixbuf != NULL, NULL);

if (scale != 1.0) {

GdkPixbuf *scaled;

float width = gdk_pixbuf_get_width (pixbuf) * scale;

if (text == NULL) {

text = "Foo";

}

label = gtk_label_new (text);

return label;

}

test_window_set_title_with_pid (GtkWindow *window,

const char *title)

{

char *tmp;

g_return_if_fail (GTK_IS_WINDOW (window));

tmp = g_strdup_printf ("%lu: %s", (gulong) getpid (), title);