moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 475 insertions, 0 deletions

diff --git a/libcaja-private/caja-file-changes-queue.c b/libcaja-private/caja-file-changes-queue.c
new file mode 100644
index 00000000..0be95302
--- /dev/null
+++ b/libcaja-private/caja-file-changes-queue.c
@@ -0,0 +1,475 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-
+
+   Copyright (C) 1999, 2000, 2001 Eazel, Inc.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public
+   License along with this program; if not, write to the
+   Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.
+
+   Author: Pavel Cisler <[email protected]>
+*/
+
+#include <config.h>
+#include "caja-file-changes-queue.h"
+
+#include "caja-directory-notify.h"
+#include <eel/eel-glib-extensions.h>
+
+#ifdef G_THREADS_ENABLED
+#define MUTEX_LOCK(a)	if ((a) != NULL) g_mutex_lock (a)
+#define MUTEX_UNLOCK(a)	if ((a) != NULL) g_mutex_unlock (a)
+#else
+#define MUTEX_LOCK(a)
+#define MUTEX_UNLOCK(a)
+#endif
+
+typedef enum
+{
+    CHANGE_FILE_INITIAL,
+    CHANGE_FILE_ADDED,
+    CHANGE_FILE_CHANGED,
+    CHANGE_FILE_REMOVED,
+    CHANGE_FILE_MOVED,
+    CHANGE_POSITION_SET,
+    CHANGE_POSITION_REMOVE
+} CajaFileChangeKind;
+
+typedef struct
+{
+    CajaFileChangeKind kind;
+    GFile *from;
+    GFile *to;
+    GdkPoint point;
+    int screen;
+} CajaFileChange;
+
+typedef struct
+{
+    GList *head;
+    GList *tail;
+#ifdef G_THREADS_ENABLED
+    GMutex *mutex;
+#endif
+} CajaFileChangesQueue;
+
+static CajaFileChangesQueue *
+caja_file_changes_queue_new (void)
+{
+    CajaFileChangesQueue *result;
+
+    result = g_new0 (CajaFileChangesQueue, 1);
+
+#ifdef G_THREADS_ENABLED
+    result->mutex = g_mutex_new ();
+#endif
+    return result;
+}
+
+static CajaFileChangesQueue *
+caja_file_changes_queue_get (void)
+{
+    static CajaFileChangesQueue *file_changes_queue;
+
+    if (file_changes_queue == NULL)
+    {
+        file_changes_queue = caja_file_changes_queue_new ();
+    }
+
+    return file_changes_queue;
+}
+
+#if 0 /* no public free call yet */
+
+static void
+caja_file_change_free (CajaFileChange *change)
+{
+    if (change->from)
+    {
+        g_object_unref (change->from);
+    }
+    if (change->to)
+    {
+        g_object_unref (change->to);
+    }
+}
+
+void
+caja_file_changes_queue_free (CajaFileChangesQueue *queue)
+{
+    GList *p;
+    if (queue == NULL)
+    {
+        return;
+    }
+
+#ifdef G_THREADS_ENABLED
+    /* if lock on a defunct mutex were defined (returning a failure)
+     * we would lock here
+     */
+#endif
+
+    for (p = queue->head; p != NULL; p = p->next)
+    {
+        caja_file_change_free (p->data);
+    }
+    g_list_free (queue->head);
+
+#ifdef G_THREADS_ENABLED
+    g_mutex_free (queue->mutex);
+#endif
+    g_free (queue);
+}
+
+#endif /* no public free call yet */
+
+static void
+caja_file_changes_queue_add_common (CajaFileChangesQueue *queue,
+                                    CajaFileChange *new_item)
+{
+    /* enqueue the new queue item while locking down the list */
+    MUTEX_LOCK (queue->mutex);
+
+    queue->head = g_list_prepend (queue->head, new_item);
+    if (queue->tail == NULL)
+        queue->tail = queue->head;
+
+    MUTEX_UNLOCK (queue->mutex);
+}
+
+void
+caja_file_changes_queue_file_added (GFile *location)
+{
+    CajaFileChange *new_item;
+    CajaFileChangesQueue *queue;
+
+    queue = caja_file_changes_queue_get();
+
+    new_item = g_new0 (CajaFileChange, 1);
+    new_item->kind = CHANGE_FILE_ADDED;
+    new_item->from = g_object_ref (location);
+    caja_file_changes_queue_add_common (queue, new_item);
+}
+
+void
+caja_file_changes_queue_file_changed (GFile *location)
+{
+    CajaFileChange *new_item;
+    CajaFileChangesQueue *queue;
+
+    queue = caja_file_changes_queue_get();
+
+    new_item = g_new0 (CajaFileChange, 1);
+    new_item->kind = CHANGE_FILE_CHANGED;
+    new_item->from = g_object_ref (location);
+    caja_file_changes_queue_add_common (queue, new_item);
+}
+
+void
+caja_file_changes_queue_file_removed (GFile *location)
+{
+    CajaFileChange *new_item;
+    CajaFileChangesQueue *queue;
+
+    queue = caja_file_changes_queue_get();
+
+    new_item = g_new0 (CajaFileChange, 1);
+    new_item->kind = CHANGE_FILE_REMOVED;
+    new_item->from = g_object_ref (location);
+    caja_file_changes_queue_add_common (queue, new_item);
+}
+
+void
+caja_file_changes_queue_file_moved (GFile *from,
+                                    GFile *to)
+{
+    CajaFileChange *new_item;
+    CajaFileChangesQueue *queue;
+
+    queue = caja_file_changes_queue_get ();
+
+    new_item = g_new (CajaFileChange, 1);
+    new_item->kind = CHANGE_FILE_MOVED;
+    new_item->from = g_object_ref (from);
+    new_item->to = g_object_ref (to);
+    caja_file_changes_queue_add_common (queue, new_item);
+}
+
+void
+caja_file_changes_queue_schedule_position_set (GFile *location,
+        GdkPoint point,
+        int screen)
+{
+    CajaFileChange *new_item;
+    CajaFileChangesQueue *queue;
+
+    queue = caja_file_changes_queue_get ();
+
+    new_item = g_new (CajaFileChange, 1);
+    new_item->kind = CHANGE_POSITION_SET;
+    new_item->from = g_object_ref (location);
+    new_item->point = point;
+    new_item->screen = screen;
+    caja_file_changes_queue_add_common (queue, new_item);
+}
+
+void
+caja_file_changes_queue_schedule_position_remove (GFile *location)
+{
+    CajaFileChange *new_item;
+    CajaFileChangesQueue *queue;
+
+    queue = caja_file_changes_queue_get ();
+
+    new_item = g_new (CajaFileChange, 1);
+    new_item->kind = CHANGE_POSITION_REMOVE;
+    new_item->from = g_object_ref (location);
+    caja_file_changes_queue_add_common (queue, new_item);
+}
+
+static CajaFileChange *
+caja_file_changes_queue_get_change (CajaFileChangesQueue *queue)
+{
+    GList *new_tail;
+    CajaFileChange *result;
+
+    g_assert (queue != NULL);
+
+    /* dequeue the tail item while locking down the list */
+    MUTEX_LOCK (queue->mutex);
+
+    if (queue->tail == NULL)
+    {
+        result = NULL;
+    }
+    else
+    {
+        new_tail = queue->tail->prev;
+        result = queue->tail->data;
+        queue->head = g_list_remove_link (queue->head,
+                                          queue->tail);
+        g_list_free_1 (queue->tail);
+        queue->tail = new_tail;
+    }
+
+    MUTEX_UNLOCK (queue->mutex);
+
+    return result;
+}
+
+enum
+{
+    CONSUME_CHANGES_MAX_CHUNK = 20
+};
+
+static void
+pairs_list_free (GList *pairs)
+{
+    GList *p;
+    GFilePair *pair;
+
+    /* deep delete the list of pairs */
+
+    for (p = pairs; p != NULL; p = p->next)
+    {
+        /* delete the strings in each pair */
+        pair = p->data;
+        g_object_unref (pair->from);
+        g_object_unref (pair->to);
+    }
+
+    /* delete the list and the now empty pair structs */
+    eel_g_list_free_deep (pairs);
+}
+
+static void
+position_set_list_free (GList *list)
+{
+    GList *p;
+    CajaFileChangesQueuePosition *item;
+
+    for (p = list; p != NULL; p = p->next)
+    {
+        item = p->data;
+        g_object_unref (item->location);
+    }
+    /* delete the list and the now empty structs */
+    eel_g_list_free_deep (list);
+}
+
+/* go through changes in the change queue, send ones with the same kind
+ * in a list to the different caja_directory_notify calls
+ */
+void
+caja_file_changes_consume_changes (gboolean consume_all)
+{
+    CajaFileChange *change;
+    GList *additions, *changes, *deletions, *moves;
+    GList *position_set_requests;
+    GFilePair *pair;
+    CajaFileChangesQueuePosition *position_set;
+    guint chunk_count;
+    CajaFileChangesQueue *queue;
+    gboolean flush_needed;
+
+
+    additions = NULL;
+    changes = NULL;
+    deletions = NULL;
+    moves = NULL;
+    position_set_requests = NULL;
+
+    queue = caja_file_changes_queue_get();
+
+    /* Consume changes from the queue, stuffing them into one of three lists,
+     * keep doing it while the changes are of the same kind, then send them off.
+     * This is to ensure that the changes get sent off in the same order that they
+     * arrived.
+     */
+    for (chunk_count = 0; ; chunk_count++)
+    {
+        change = caja_file_changes_queue_get_change (queue);
+
+        /* figure out if we need to flush the pending changes that we collected sofar */
+
+        if (change == NULL)
+        {
+            flush_needed = TRUE;
+            /* no changes left, flush everything */
+        }
+        else
+        {
+            flush_needed = additions != NULL
+                           && change->kind != CHANGE_FILE_ADDED
+                           && change->kind != CHANGE_POSITION_SET
+                           && change->kind != CHANGE_POSITION_REMOVE;
+
+            flush_needed |= changes != NULL
+                            && change->kind != CHANGE_FILE_CHANGED;
+
+            flush_needed |= moves != NULL
+                            && change->kind != CHANGE_FILE_MOVED
+                            && change->kind != CHANGE_POSITION_SET
+                            && change->kind != CHANGE_POSITION_REMOVE;
+
+            flush_needed |= deletions != NULL
+                            && change->kind != CHANGE_FILE_REMOVED;
+
+            flush_needed |= position_set_requests != NULL
+                            && change->kind != CHANGE_POSITION_SET
+                            && change->kind != CHANGE_POSITION_REMOVE
+                            && change->kind != CHANGE_FILE_ADDED
+                            && change->kind != CHANGE_FILE_MOVED;
+
+            flush_needed |= !consume_all && chunk_count >= CONSUME_CHANGES_MAX_CHUNK;
+            /* we have reached the chunk maximum */
+        }
+
+        if (flush_needed)
+        {
+            /* Send changes we collected off.
+             * At one time we may only have one of the lists
+             * contain changes.
+             */
+
+            if (deletions != NULL)
+            {
+                deletions = g_list_reverse (deletions);
+                caja_directory_notify_files_removed (deletions);
+                eel_g_object_list_free (deletions);
+                deletions = NULL;
+            }
+            if (moves != NULL)
+            {
+                moves = g_list_reverse (moves);
+                caja_directory_notify_files_moved (moves);
+                pairs_list_free (moves);
+                moves = NULL;
+            }
+            if (additions != NULL)
+            {
+                additions = g_list_reverse (additions);
+                caja_directory_notify_files_added (additions);
+                eel_g_object_list_free (additions);
+                additions = NULL;
+            }
+            if (changes != NULL)
+            {
+                changes = g_list_reverse (changes);
+                caja_directory_notify_files_changed (changes);
+                eel_g_object_list_free (changes);
+                changes = NULL;
+            }
+            if (position_set_requests != NULL)
+            {
+                position_set_requests = g_list_reverse (position_set_requests);
+                caja_directory_schedule_position_set (position_set_requests);
+                position_set_list_free (position_set_requests);
+                position_set_requests = NULL;
+            }
+        }
+
+        if (change == NULL)
+        {
+            /* we are done */
+            return;
+        }
+
+        /* add the new change to the list */
+        switch (change->kind)
+        {
+        case CHANGE_FILE_ADDED:
+            additions = g_list_prepend (additions, change->from);
+            break;
+
+        case CHANGE_FILE_CHANGED:
+            changes = g_list_prepend (changes, change->from);
+            break;
+
+        case CHANGE_FILE_REMOVED:
+            deletions = g_list_prepend (deletions, change->from);
+            break;
+
+        case CHANGE_FILE_MOVED:
+            pair = g_new (GFilePair, 1);
+            pair->from = change->from;
+            pair->to = change->to;
+            moves = g_list_prepend (moves, pair);
+            break;
+
+        case CHANGE_POSITION_SET:
+            position_set = g_new (CajaFileChangesQueuePosition, 1);
+            position_set->location = change->from;
+            position_set->set = TRUE;
+            position_set->point = change->point;
+            position_set->screen = change->screen;
+            position_set_requests = g_list_prepend (position_set_requests,
+                                                    position_set);
+            break;
+
+        case CHANGE_POSITION_REMOVE:
+            position_set = g_new (CajaFileChangesQueuePosition, 1);
+            position_set->location = change->from;
+            position_set->set = FALSE;
+            position_set_requests = g_list_prepend (position_set_requests,
+                                                    position_set);
+            break;
+
+        default:
+            g_assert_not_reached ();
+            break;
+        }
+
+        g_free (change);
+    }
+}