Author: stephan
Date: 2006-10-18 22:19:23 +0000 (Wed, 18 Oct 2006)
New Revision: 23465
Removed:
xarchiver/branches/xarchiver-psybsd/tests/
Modified:
xarchiver/branches/xarchiver-psybsd/Makefile.am
xarchiver/branches/xarchiver-psybsd/configure.in.in
xarchiver/branches/xarchiver-psybsd/libxarchiver/Makefile.am
xarchiver/branches/xarchiver-psybsd/libxarchiver/archive-support-gnu-tar.c
xarchiver/branches/xarchiver-psybsd/libxarchiver/archive.c
xarchiver/branches/xarchiver-psybsd/libxarchiver/archive.h
xarchiver/branches/xarchiver-psybsd/libxarchiver/libxarchiver.c
xarchiver/branches/xarchiver-psybsd/libxarchiver/slist.c
xarchiver/branches/xarchiver-psybsd/src/archive_store.c
xarchiver/branches/xarchiver-psybsd/src/main_window.c
Log:
Applied patch from Peter de Ridder <[EMAIL PROTECTED]>
Working on library interface cleanup. (do not expect this to work)
Modified: xarchiver/branches/xarchiver-psybsd/Makefile.am
===================================================================
--- xarchiver/branches/xarchiver-psybsd/Makefile.am 2006-10-18 20:10:53 UTC
(rev 23464)
+++ xarchiver/branches/xarchiver-psybsd/Makefile.am 2006-10-18 22:19:23 UTC
(rev 23465)
@@ -1,6 +1,6 @@
## Process this file with automake to produce Makefile.in
-SUBDIRS = libxarchiver src tests po
+SUBDIRS = libxarchiver src po
pixmapsdir = $(datadir)/pixmaps/xarchiver
pixmaps_DATA = pixmaps/xarchiver.png \
Modified: xarchiver/branches/xarchiver-psybsd/configure.in.in
===================================================================
--- xarchiver/branches/xarchiver-psybsd/configure.in.in 2006-10-18 20:10:53 UTC
(rev 23464)
+++ xarchiver/branches/xarchiver-psybsd/configure.in.in 2006-10-18 22:19:23 UTC
(rev 23465)
@@ -54,10 +54,11 @@
XDT_CHECK_PACKAGE([GTK], [gtk+-2.0], [2.2.0])
XDT_CHECK_PACKAGE([GLIB], [glib-2.0], [2.2.0])
XDT_CHECK_PACKAGE([GOBJECT], [gobject-2.0], [2.2.0])
+XDT_CHECK_PACKAGE([THUNAR_VFS], [thunar-vfs-1], [0.4.0])
-XDT_CHECK_OPTIONAL_PACKAGE([THUNAR_VFS], [thunar-vfs-1], [0.4.0], [thunar-vfs],
- AC_HELP_STRING([--disable-thunar-vfs],
- [Disable the use of Thunar's VFS layer)]))
+dnl XDT_CHECK_OPTIONAL_PACKAGE([THUNAR_VFS], [thunar-vfs-1], [0.4.0],
[thunar-vfs],
+dnl AC_HELP_STRING([--disable-thunar-vfs],
+dnl [Disable the use of Thunar's VFS layer)]))
XDT_CHECK_OPTIONAL_PACKAGE([LIBXFCE4UTIL], [libxfce4util-1.0], [4.3.99],
[libxfce4util],
AC_HELP_STRING([--disable-libxfce4util],
@@ -90,7 +91,6 @@
Makefile
po/Makefile.in
src/Makefile
-tests/Makefile
libxarchiver/Makefile
])
Modified: xarchiver/branches/xarchiver-psybsd/libxarchiver/Makefile.am
===================================================================
--- xarchiver/branches/xarchiver-psybsd/libxarchiver/Makefile.am
2006-10-18 20:10:53 UTC (rev 23464)
+++ xarchiver/branches/xarchiver-psybsd/libxarchiver/Makefile.am
2006-10-18 22:19:23 UTC (rev 23465)
@@ -7,9 +7,7 @@
slist.c slist.h \
archive.c archive.h \
archive-support.c archive-support.h \
- archive-support-zip.c archive-support-zip.h \
- archive-support-gnu-tar.c archive-support-gnu-tar.h \
- archive-support-rar.c archive-support-rar.h
+ archive-support-gnu-tar.c archive-support-gnu-tar.h
libxarchiver_a_CFLAGS = \
$(GLIB_CFLAGS) \
Modified:
xarchiver/branches/xarchiver-psybsd/libxarchiver/archive-support-gnu-tar.c
===================================================================
--- xarchiver/branches/xarchiver-psybsd/libxarchiver/archive-support-gnu-tar.c
2006-10-18 20:10:53 UTC (rev 23464)
+++ xarchiver/branches/xarchiver-psybsd/libxarchiver/archive-support-gnu-tar.c
2006-10-18 22:19:23 UTC (rev 23465)
@@ -197,6 +197,7 @@
{
LXAArchiveSupportGnuTar *support;
+ /*
support = g_object_new(LXA_TYPE_ARCHIVE_SUPPORT_GNU_TAR,
"view-time", TRUE,
"view-date", TRUE,
@@ -204,6 +205,14 @@
"view-rights", TRUE,
"view-size", TRUE,
NULL);
+ */
+ support = g_object_new(LXA_TYPE_ARCHIVE_SUPPORT_GNU_TAR,
+ "view-time", FALSE,
+
"view-date", FALSE,
+
"view-owner", FALSE,
+
"view-rights", FALSE,
+
"view-size", FALSE,
+
NULL);
return LXA_ARCHIVE_SUPPORT(support);
}
@@ -492,8 +501,6 @@
gchar *line = NULL;
LXAEntry *entry;
- gpointer props = NULL;
- gpointer props_iter = NULL;
gint n = 0, a = 0, i = 0, o = 0;
gchar *temp_filename = NULL;
gchar *_size = NULL;
@@ -512,13 +519,12 @@
if (line == NULL)
break;
- props = g_malloc0(archive->entry_props_size);
- props_iter = props;
-
if(LXA_ARCHIVE_SUPPORT_GNU_TAR(archive->support)->_view_rights)
{
+ /*
(*(gchar **)props_iter) = g_strndup (line, 10);
props_iter += sizeof(gchar *);
+ */
}
@@ -527,8 +533,10 @@
if(LXA_ARCHIVE_SUPPORT_GNU_TAR(archive->support)->_view_owner)
{
+ /*
(*(gchar **)props_iter) = g_strndup (&line[11],
n-11);
props_iter += sizeof(gchar *);
+ */
}
for(; n < strlen(line); n++)
@@ -541,10 +549,12 @@
if(LXA_ARCHIVE_SUPPORT_GNU_TAR(archive->support)->_view_size)
{
+ /*
_size = g_strndup(&line[a], n-a);
(*((guint64 *)props_iter)) = g_ascii_strtoull(
_size, NULL, 0);
g_free (_size);
props_iter += sizeof(guint64);
+ */
}
a = ++n;
@@ -554,8 +564,10 @@
if(LXA_ARCHIVE_SUPPORT_GNU_TAR(archive->support)->_view_date)
{
+ /*
(*(gchar **)props_iter) = g_strndup (&line[a],
n-a);
props_iter += sizeof(gchar *);
+ */
}
a = ++n;
@@ -564,8 +576,10 @@
if(LXA_ARCHIVE_SUPPORT_GNU_TAR(archive->support)->_view_time)
{
+ /*
(*(gchar **)props_iter) = g_strndup (&line[a],
n-a);
props_iter += sizeof(gchar *);
+ */
}
gchar *temp = g_strrstr (&line[n],"->");
@@ -579,7 +593,6 @@
}
entry = lxa_archive_add_file(archive, temp_filename);
- entry->props = props;
g_free(line);
g_free(temp_filename);
}
Modified: xarchiver/branches/xarchiver-psybsd/libxarchiver/archive.c
===================================================================
--- xarchiver/branches/xarchiver-psybsd/libxarchiver/archive.c 2006-10-18
20:10:53 UTC (rev 23464)
+++ xarchiver/branches/xarchiver-psybsd/libxarchiver/archive.c 2006-10-18
22:19:23 UTC (rev 23465)
@@ -25,8 +25,10 @@
#include "mime.h"
+//#include "entry.h"
#include "archive.h"
#include "archive-support.h"
+#include "slist.h"
#include "internals.h"
@@ -34,7 +36,20 @@
#define LXA_ENTRY_CHILD_BUFFER_SIZE 300
#endif
+#ifndef LXA_MIME_DIRECTORY
+#define LXA_MIME_DIRECTORY "inode/directory"
+#endif
+struct _LXAEntry
+{
+ gchar *filename;
+ gchar *mime_type;
+ gpointer props;
+ LXAEntry **children;
+ LXASList *buffer;
+};
+
+
static void
lxa_archive_class_init(LXAArchiveClass *archive_class);
@@ -44,13 +59,24 @@
static void
lxa_archive_finalize(GObject *object);
-void
-lxa_archive_free_entry(LXAArchive *archive, LXAEntry *entry);
+static LXAEntry *
+lxa_entry_new(const gchar *);
-void
-lxa_archive_entry_flush_buffer(LXAArchive *, LXAEntry *entry);
+static void
+lxa_archive_entry_free(LXAArchive *, LXAEntry *);
+static LXAEntry *
+lxa_entry_get_child(const LXAEntry *entry, const gchar *filename);
+static void
+lxa_archive_entry_add_child(LXAArchive *, LXAEntry *, LXAEntry *);
+
+static void
+lxa_archive_entry_flush_buffer(LXAArchive *, LXAEntry *);
+
+static gpointer
+lxa_archive_entry_get_props(LXAArchive *, LXAEntry *);
+
gint
lxa_archive_sort_entry_buffer(LXAEntry *entry1, LXAEntry *entry2)
{
@@ -108,8 +134,6 @@
lxa_archive_init(LXAArchive *archive)
{
archive->root_entry = g_new0(LXAEntry, 1);
- archive->root_entry->filename = NULL;
- archive->root_entry->children = NULL;
}
/** static void
@@ -123,7 +147,7 @@
LXAArchive *archive = LXA_ARCHIVE(object);
if(archive->path)
g_free(archive->path);
- lxa_archive_free_entry(archive, archive->root_entry);
+ lxa_archive_entry_free(archive, archive->root_entry);
switch(archive->status)
{
case(LXA_ARCHIVESTATUS_IDLE):
@@ -178,66 +202,91 @@
}
gint
-lxa_archive_lookup_dir(gpointer entry, gconstpointer filename)
+lxa_stop_archive_child( LXAArchive *archive )
{
- return strcmp(((LXAEntry *)entry)->filename, filename);
+ lxa_archive_set_status(archive, LXA_ARCHIVESTATUS_USERBREAK);
+ return 0;
}
-/*
- * LXAEntry *
- * lxa_archive_add_file(LXAArchive *archive, gchar *path);
- *
- * Add a file to the archive-tree or return
- */
-LXAEntry *
-lxa_archive_add_file(LXAArchive *archive, gchar *path)
+/********************
+ * LXAArchive stuff *
+ ********************/
+
+LXAArchiveIter *
+lxa_archive_add_file(LXAArchive *archive, const gchar *path)
{
- gint i = 0;
- gchar **path_items;
- LXAEntry *tmp_entry = NULL, *parent = NULL;
- path_items = g_strsplit_set(path, "/\n", -1);
- parent = archive->root_entry;
- if(path_items[i]?path_items[i][0]=='\0':0)
+ guint i = 0;
+ gchar **path_items = g_strsplit_set(path, "/\n", -1);
+ LXAArchiveIter *parent = (LXAArchiveIter*)archive->root_entry;
+ LXAArchiveIter *child = NULL;
+ gchar *basename;
+
+ while(path_items[i])
{
- /* has leading / */
- tmp_entry = lxa_entry_get_child(parent, "/");
- if(!tmp_entry)
+ basename = g_strconcat(path_items[i], path_items[i+1]?"/":NULL,
NULL);
+
+ if(basename[0] != '\0')
{
- tmp_entry = g_new0(LXAEntry, 1);
- tmp_entry->filename = g_strdup("/");
- lxa_archive_entry_add_child(archive, parent, tmp_entry);
- if(!parent->mime_type)
- parent->mime_type = g_strdup("inode/directory");
+ child = lxa_archive_iter_get_child(archive, parent,
basename);
+
+ if(!child)
+ child = lxa_archive_iter_add_child(archive,
parent, basename);
}
- parent = tmp_entry;
- ++i;
+
+ g_free(basename);
+
+ parent = child;
+ i++;
}
- for(; path_items[i]?strlen(path_items[i]):0;++i)
+
+ return child;
+}
+
+GType
+lxa_archive_get_property_type(LXAArchive *archive, guint i)
+{
+#ifdef DEBUG
+ g_return_if_fail(i < archive->n_property, G_TYPE_INVALID);
+#endif
+ switch(i)
{
- tmp_entry = lxa_entry_get_child(parent, path_items[i]);
- if(!tmp_entry)
- {
- tmp_entry = g_new0(LXAEntry, 1);
- tmp_entry->filename = g_strdup(path_items[i]);
- lxa_archive_entry_add_child(archive, parent, tmp_entry);
- if(!parent->mime_type)
- parent->mime_type = g_strdup("inode/directory");
- }
- parent = tmp_entry;
+ case LXA_ARCHIVE_PROP_FILENAME:
+ return G_TYPE_STRING;
+ case LXA_ARCHIVE_PROP_MIME_TYPE:
+ return G_TYPE_STRING;
+ case LXA_ARCHIVE_PROP_USER:
+ return archive->property_types[i -
LXA_ARCHIVE_PROP_USER];
}
- if(!tmp_entry->mime_type)
+}
+
+
+/******************
+ * LXAEntry stuff *
+ ******************/
+
+static LXAEntry *
+lxa_entry_new(const gchar *filename)
+{
+ LXAEntry *entry = g_new0(LXAEntry, 1);
+
+ const gchar *pos = strchr(filename, '/');
+
+ if(pos)
{
- if(path[strlen(path)-1] == '/')
- tmp_entry->mime_type = g_strdup("inode/directory");
- else
- tmp_entry->mime_type =
lxa_mime_get_mime_type_for_filename(tmp_entry->filename);
+ entry->filename = g_strndup(filename, (gsize)(pos - filename));
+ entry->mime_type = g_strdup(LXA_MIME_DIRECTORY);
}
- g_strfreev(path_items);
- return tmp_entry;
+ else
+ {
+ entry->filename = g_strdup(filename);
+ entry->mime_type =
lxa_mime_get_mime_type_for_filename(entry->filename);
+ }
+
+ return entry;
}
void
-lxa_archive_free_entry(LXAArchive *archive, LXAEntry *entry)
+lxa_archive_entry_free(LXAArchive *archive, LXAEntry *entry)
{
gint i = 0;
gpointer props_iter = entry->props;
@@ -245,20 +294,17 @@
for(; buffer_iter; buffer_iter = buffer_iter->next)
{
- lxa_archive_free_entry(archive, buffer_iter->entry);
+ lxa_archive_entry_free(archive, buffer_iter->entry);
}
- if(entry->buffer)
- {
- lxa_slist_free(entry->buffer);
- entry->buffer = NULL;
- }
+ lxa_slist_free(entry->buffer);
+ entry->buffer = NULL;
if(entry->children)
{
/* first elemant of the array (*entry->children) contains the
size of the array */
/* WHY DOES i end up being 2 when *entry->children == 1 ?! */
for(i = 1; i <= GPOINTER_TO_INT(*entry->children); ++i)
- lxa_archive_free_entry(archive, entry->children[i]);
+ lxa_archive_entry_free(archive, entry->children[i]);
g_free(entry->children);
entry->children = NULL;
@@ -266,7 +312,7 @@
if(props_iter)
{
- for(i=1; i<archive->n_property; i++)
+ for(i=0; i<archive->n_property; ++i)
{
switch(archive->property_types[i])
{
@@ -284,18 +330,55 @@
}
g_free(entry->props);
}
+ g_free(entry->mime_type);
g_free(entry->filename);
g_free(entry);
}
-gint
-lxa_stop_archive_child( LXAArchive *archive )
+static LXAEntry *
+lxa_entry_get_child(const LXAEntry *entry, const gchar *filename)
{
- lxa_archive_set_status(archive, LXA_ARCHIVESTATUS_USERBREAK);
- return 0;
+ LXASList *buffer_iter = NULL;
+ /* the first element of the array (*entry->children) contains the size
of the array */
+ guint size = entry->children?GPOINTER_TO_INT(*entry->children):0;
+ guint pos = 0;
+ guint begin = 1;
+ gint cmp = 0;
+ /* binary search algoritme */
+ while(size)
+ {
+ pos = (size / 2);
+
+ cmp = strcmp(filename, entry->children[begin+pos]->filename);
+ if(!cmp)
+ return entry->children[begin+pos];
+
+ if(cmp < 0)
+ {
+ size = pos;
+ }
+ else
+ {
+ size -= ++pos;
+ begin += pos;
+ }
+ }
+
+ /* search the buffer */
+ for(buffer_iter = entry->buffer; buffer_iter; buffer_iter =
buffer_iter->next)
+ {
+ cmp = strcmp(filename, buffer_iter->entry->filename);
+
+ if(!cmp)
+ return buffer_iter->entry;
+ if(cmp < 0)
+ break;
+ }
+
+ return NULL;
}
-void
+static void
lxa_archive_entry_add_child(LXAArchive *archive, LXAEntry *parent, LXAEntry
*child)
{
parent->buffer = lxa_slist_insert_sorted_single(parent->buffer, child);
@@ -304,7 +387,7 @@
lxa_archive_entry_flush_buffer(archive, parent);
}
-void
+static void
lxa_archive_entry_flush_buffer(LXAArchive *archive, LXAEntry *entry)
{
if(!entry->buffer)
@@ -374,60 +457,495 @@
g_free(children_old);
}
+static gpointer
+lxa_archive_entry_get_props(LXAArchive *archive, LXAEntry *entry)
+{
+ guint size = 0;
+ guint i;
+
+ if(!entry->props)
+ {
+ for(i = 0; i < archive->n_property; ++i)
+ {
+ switch(archive->property_types[i])
+ {
+ case G_TYPE_STRING:
+ size += sizeof(gchar *);
+ break;
+ case G_TYPE_UINT:
+ size += sizeof(guint);
+ break;
+ case G_TYPE_UINT64:
+ size += sizeof(guint64);
+ break;
+ }
+ }
+
+#ifdef DEBUG
+ entry->props = g_malloc0(size);
+#else
+ entry->props = g_malloc(size);
+#endif
+ }
+
+ return entry->props;
+}
+
+/************************
+ * LXAArchiveIter stuff *
+ ************************/
+
+/**
+ * gboolean
+ * lxa_archive_iter_is_directory(const LXAArchive *, const LXAArchiveIter *)
+ *
+ * Check if archive entry is a directory
+ **/
+gboolean
+lxa_archive_iter_is_directory(const LXAArchive *archive, const LXAArchiveIter
*iter)
+{
+ if(!strcmp(lxa_archive_iter_get_mime(archive, iter),
LXA_MIME_DIRECTORY))
+ return TRUE;
+ return FALSE;
+}
+
+/**
+ * guint
+ * lxa_archive_iter_n_children(const LXAArchive *, const LXAArchiveIter *)
+ *
+ * return number of children
+ **/
guint
-lxa_entry_children_length(LXAEntry *entry)
+lxa_archive_iter_n_children(const LXAArchive *archive, const LXAArchiveIter
*iter)
{
- g_return_val_if_fail(entry, 0);
- /* the first element of the array (*entry->children) contains the size
of the array */
- return entry->children?GPOINTER_TO_INT(*entry->children):0 +
lxa_slist_length(entry->buffer);
+#ifdef DEBUG
+ g_return_val_if_fail(iter, 0);
+#endif
+ /* the first element of the array (*iter->children) contains the size
of the array */
+ return iter->children?GPOINTER_TO_INT(*iter->children):0 +
lxa_slist_length(iter->buffer);
}
-/* FIXME FIXME FIXME FIXME FIXME FIXME FIXME*/
-/* these functions should not even exist do they? */
-LXAEntry *
-lxa_entry_get_child(LXAEntry *entry, const gchar *filename)
+/**
+ * LXAArchiveIter*
+ * lxa_archive_iter_nth_child(const LXAArchive *, const LXAArchiveIter *,
guint)
+ *
+ * return nth child
+ **/
+LXAArchiveIter*
+lxa_archive_iter_nth_child(LXAArchive *archive, LXAArchiveIter *iter, guint n)
{
- LXASList *buffer_iter = NULL;
- /* the first element of the array (*entry->children) contains the size
of the array */
- guint size = entry->children?GPOINTER_TO_INT(*entry->children):0;
- guint pos = 0;
- guint begin = 1;
- gint cmp = 0;
- /* binary search algoritme */
- while(size)
+#ifdef DEBUG
+ g_return_val_if_fail(n >= 0, NULL);
+ g_return_val_if_fail(n < lxa_archive_iter_n_children(archive, iter),
NULL);
+#endif
+ lxa_archive_entry_flush_buffer(archive, (LXAEntry *)iter);
+ /* the first element of the array (*iter->children) contains the size
of the array */
+ return ((LXAEntry *)iter->children[n+1]);
+}
+
+/**
+ * LXAArchiveIter*
+ * lxa_archive_iter_add_child(LXAArchive *, LXAArchiveIter *, const gchar *)
+ *
+ * return a new child
+ **/
+LXAArchiveIter *
+lxa_archive_iter_add_child(LXAArchive *archive, LXAArchiveIter *parent, const
gchar *filename)
+{
+ LXAEntry *entry = lxa_entry_new(filename);
+
+ lxa_archive_entry_add_child(archive, (LXAEntry *)parent, entry);
+
+ return (LXAArchiveIter*)entry;
+}
+
+/**
+ * LXAArchiveIter*
+ * lxa_archive_iter_get_child(const LXAArchive *, const LXAArchiveIter *,
const gchar *)
+ *
+ * return the child iter if found
+ **/
+LXAArchiveIter *
+lxa_archive_iter_get_child(const LXAArchive *archive, const LXAArchiveIter
*parent, const gchar *filename)
+{
+ return (LXAArchiveIter*)lxa_entry_get_child(parent, filename);
+}
+
+/**
+ * gboolean
+ * lxa_archive_iter_del_child(const LXAArchive *, LXAArchiveIter *,
LXAArchiveIter *)
+ *
+ * delete a child (if it can be found)
+ **/
+gboolean
+lxa_archive_iter_del_child(LXAArchive *archive, LXAArchiveIter *parent,
LXAArchiveIter *child)
+{
+ g_warning("not implemented yet");
+}
+
+/**
+ * const gchar *
+ * lxa_archive_iter_get_filename(const LXAArchive *, const LXAArchiveIter *)
+ *
+ * returns filename
+ */
+const gchar*
+lxa_archive_iter_get_filename(const LXAArchive *archive, const LXAArchiveIter
*iter)
+{
+ return ((LXAEntry *)iter)->filename;
+}
+
+/**
+ * const gchar *
+ * lxa_archive_iter_get_mime(const LXAArchive *, const LXAArchiveIter *)
+ *
+ * returns mime type
+ */
+const gchar*
+lxa_archive_iter_get_mime(const LXAArchive *archive, const LXAArchiveIter
*iter)
+{
+ return ((LXAEntry *)iter)->mime_type;
+}
+
+/**
+ * void
+ * lxa_archive_iter_set_mime(const LXAArchive *, const LXAArchiveIter *, const
gchar *)
+ *
+ * set mime type to entry
+ */
+void
+lxa_archive_iter_set_mime(LXAArchive *archive, LXAArchiveIter *iter, const
gchar *mime)
+{
+ g_free(((LXAEntry *)iter)->mime_type);
+ ((LXAEntry *)iter)->mime_type = g_strdup(mime);
+}
+
+/**
+ * void
+ * lxa_archive_iter_set_prop_str(const LXAArchive *, const LXAArchiveIter *,
guint, const gchar *)
+ *
+ */
+void
+lxa_archive_iter_set_prop_str(LXAArchive *archive, LXAArchiveIter *iter, guint
i, const gchar *str_val)
+{
+ gpointer props_iter = NULL;
+ guint n;
+#ifdef DEBUG
+ g_return_if_fail(i < (archive->n_property+LXA_ARCHIVE_PROP_USER));
+ if(i >= LXA_ARCHIVE_PROP_USER)
+
g_return_if_fail(archive->property_types[i-LXA_ARCHIVE_PROP_USER] ==
G_TYPE_STRING);
+#endif
+
+ switch(i)
{
- pos = (size / 2);
+ case LXA_ARCHIVE_PROP_FILENAME:
+#ifdef DEBUG
+ g_critical("DON'T set filename");
+#endif
+ break;
+ case LXA_ARCHIVE_PROP_MIME_TYPE:
+ lxa_archive_iter_set_mime(archive, iter, str_val);
+ break;
+ default:
+ props_iter = lxa_archive_entry_get_props(archive,
(LXAEntry *)iter);
+ for(n = 0; n < (i-LXA_ARCHIVE_PROP_USER); ++n)
+ {
+ switch(archive->property_types[n])
+ {
+ case G_TYPE_STRING:
+ props_iter += sizeof(gchar *);
+ break;
+ case G_TYPE_UINT:
+ props_iter += sizeof(guint);
+ break;
+ case G_TYPE_UINT64:
+ props_iter += sizeof(guint64);
+ break;
+ }
+ }
+ g_free(*((gchar **)props_iter));
+ (*((gchar **)props_iter)) = g_strdup(str_val);
+ break;
+ }
+}
- cmp = strcmp(filename, entry->children[begin+pos]->filename);
- if(!cmp)
- return entry->children[begin+pos];
+/**
+ * void
+ * lxa_archive_iter_set_prop_uint(const LXAArchive *, const LXAArchiveIter *,
guint, guint)
+ *
+ */
+void
+lxa_archive_iter_set_prop_uint(LXAArchive *archive, LXAArchiveIter *iter,
guint i, guint int_val)
+{
+ gpointer props_iter = lxa_archive_entry_get_props(archive, (LXAEntry
*)iter);
+ guint n;
+#ifdef DEBUG
+ g_return_if_fail(i < (archive->n_property+LXA_ARCHIVE_PROP_USER));
+ g_return_if_fail(i >= LXA_ARCHIVE_PROP_USER);
+ g_return_if_fail(archive->property_types[i-LXA_ARCHIVE_PROP_USER] ==
G_TYPE_UINT);
+#endif
+ for(n = 0; n < (i-LXA_ARCHIVE_PROP_USER); ++n)
+ {
+ switch(archive->property_types[n])
+ {
+ case G_TYPE_STRING:
+ props_iter += sizeof(gchar *);
+ break;
+ case G_TYPE_UINT:
+ props_iter += sizeof(guint);
+ break;
+ case G_TYPE_UINT64:
+ props_iter += sizeof(guint64);
+ break;
+ }
+ }
+ (*((guint *)props_iter)) = int_val;
+}
- if(cmp < 0)
+/**
+ * void
+ * lxa_archive_iter_set_prop_uint64(const LXAArchive *, const LXAArchiveIter
*, guint, guint64)
+ *
+ */
+void
+lxa_archive_iter_set_prop_uint64(LXAArchive *archive, LXAArchiveIter *iter,
guint i, guint64 int64_val)
+{
+ gpointer props_iter = lxa_archive_entry_get_props(archive, (LXAEntry
*)iter);
+ guint n;
+#ifdef DEBUG
+ g_return_if_fail(i < (archive->n_property+LXA_ARCHIVE_PROP_USER));
+ g_return_if_fail(i >= LXA_ARCHIVE_PROP_USER);
+ g_return_if_fail(archive->property_types[i-LXA_ARCHIVE_PROP_USER] ==
G_TYPE_UINT64);
+#endif
+ for(n = 0; n < (i-LXA_ARCHIVE_PROP_USER); ++n)
+ {
+ switch(archive->property_types[n])
{
- size = pos;
+ case G_TYPE_STRING:
+ props_iter += sizeof(gchar *);
+ break;
+ case G_TYPE_UINT:
+ props_iter += sizeof(guint);
+ break;
+ case G_TYPE_UINT64:
+ props_iter += sizeof(guint64);
+ break;
}
- else
+ }
+ (*((guint64 *)props_iter)) = int64_val;
+}
+
+/**
+ * void
+ * lxa_archive_iter_set_prop_value(const LXAArchive *, const LXAArchiveIter *,
guint, const GValue *)
+ *
+ */
+void
+lxa_archive_iter_set_prop_value(LXAArchive *archive, LXAArchiveIter *iter,
guint i, const GValue *value)
+{
+ switch(G_VALUE_TYPE(value))
+ {
+ case G_TYPE_STRING:
+ lxa_archive_iter_set_prop_str(archive, iter, i,
g_value_get_string(value));
+ break;
+ case G_TYPE_UINT:
+ lxa_archive_iter_set_prop_uint(archive, iter, i,
g_value_get_uint(value));
+ break;
+ case G_TYPE_UINT64:
+ lxa_archive_iter_set_prop_uint64(archive, iter, i,
g_value_get_uint64(value));
+ break;
+ }
+}
+
+/**
+ * void
+ * lxa_archive_iter_set_props(const LXAArchive *, const LXAArchiveIter *,
guint, ...)
+ *
+ */
+void
+lxa_archive_iter_set_props(LXAArchive *archive, LXAArchiveIter *iter, ...)
+{
+ gpointer props_iter = lxa_archive_entry_get_props(archive, (LXAEntry
*)iter);
+ guint i;
+ va_list ap;
+
+ va_start(ap, iter);
+
+ for(i = 0; i < (archive->n_property-LXA_ARCHIVE_PROP_USER); ++i)
+ {
+ switch(archive->property_types[i])
{
- size -= ++pos;
- begin += pos;
+ case G_TYPE_STRING:
+ (*((gchar **)props_iter)) = g_strdup(va_arg(ap,
gchar*));
+ props_iter += sizeof(gchar *);
+ break;
+ case G_TYPE_UINT:
+ (*((guint *)props_iter)) = va_arg(ap, guint);
+ props_iter += sizeof(guint);
+ break;
+ case G_TYPE_UINT64:
+ (*((guint64 *)props_iter)) = va_arg(ap,
guint64);
+ props_iter += sizeof(guint64);
+ break;
}
}
- /* search the buffer */
- for(buffer_iter = entry->buffer; buffer_iter; buffer_iter =
buffer_iter->next)
+ va_end(ap);
+}
+
+/**
+ * gboolean
+ * lxa_archive_iter_get_prop_value(const LXAArchive *, const LXAArchiveIter *,
guint, const GValue *)
+ *
+ */
+gboolean
+lxa_archive_iter_get_prop_value(const LXAArchive *archive, const
LXAArchiveIter *iter, guint i, GValue *value)
+{
+ if(i>=LXA_ARCHIVE_PROP_USER)
+ g_value_init(value,
archive->property_types[i-LXA_ARCHIVE_PROP_USER]);
+ else
+ g_value_init(value, G_TYPE_STRING);
+
+ switch(G_VALUE_TYPE(value))
{
- cmp = strcmp(filename, buffer_iter->entry->filename);
+ case G_TYPE_STRING:
+ g_value_set_string(value,
lxa_archive_iter_get_prop_str(archive, iter, i));
+ break;
+ case G_TYPE_UINT:
+ g_value_set_uint(value,
lxa_archive_iter_get_prop_uint(archive, iter, i));
+ break;
+ case G_TYPE_UINT64:
+ g_value_set_uint64(value,
lxa_archive_iter_get_prop_uint64(archive, iter, i));
+ break;
+ }
+ return TRUE;
+}
- if(!cmp)
- return buffer_iter->entry;
- if(cmp < 0)
+/**
+ * const gchar *
+ * lxa_archive_iter_get_prop_str(const LXAArchive *, const LXAArchiveIter *,
guint)
+ *
+ */
+const gchar*
+lxa_archive_iter_get_prop_str(const LXAArchive *archive, const LXAArchiveIter
*iter, guint i)
+{
+ const gchar *retval = NULL;
+ gpointer props_iter = NULL;
+ guint n;
+#ifdef DEBUG
+ g_return_val_if_fail(i < (archive->n_property+LXA_ARCHIVE_PROP_USER),
NULL);
+ if(i >= LXA_ARCHIVE_PROP_USER)
+
g_return_val_if_fail(archive->property_types[i-LXA_ARCHIVE_PROP_USER] ==
G_TYPE_STRING, NULL);
+#endif
+
+ switch(i)
+ {
+ case LXA_ARCHIVE_PROP_FILENAME:
+ retval = lxa_archive_iter_get_filename(archive, iter);
break;
+ case LXA_ARCHIVE_PROP_MIME_TYPE:
+ retval = lxa_archive_iter_get_mime(archive, iter);
+ break;
+ default:
+ props_iter = ((LXAEntry *)iter)->props;
+ if(props_iter)
+ {
+ for(n = 0; n < (i-LXA_ARCHIVE_PROP_USER); ++n)
+ {
+ switch(archive->property_types[n])
+ {
+ case G_TYPE_STRING:
+ props_iter +=
sizeof(gchar *);
+ break;
+ case G_TYPE_UINT:
+ props_iter +=
sizeof(guint);
+ break;
+ case G_TYPE_UINT64:
+ props_iter +=
sizeof(guint64);
+ break;
+ }
+ }
+ retval = (*((gchar **)props_iter));
+ }
+ break;
}
+ return retval;
+}
- return NULL;
+/**
+ * guint
+ * lxa_archive_iter_get_prop_uint(const LXAArchive *, const LXAArchiveIter *,
guint)
+ *
+ */
+guint
+lxa_archive_iter_get_prop_uint(const LXAArchive *archive, const LXAArchiveIter
*iter, guint i)
+{
+ gpointer props_iter = ((LXAEntry *)iter)->props;
+ guint n;
+#ifdef DEBUG
+ g_return_val_if_fail(i < (archive->n_property+LXA_ARCHIVE_PROP_USER),
0);
+ g_return_val_if_fail(i >= LXA_ARCHIVE_PROP_USER, 0);
+ g_return_val_if_fail(archive->property_types[i-LXA_ARCHIVE_PROP_USER]
== G_TYPE_UINT, 0);
+#endif
+ if(!props_iter)
+ return 0;
+ for(n = 0; n < (i-LXA_ARCHIVE_PROP_USER); ++n)
+ {
+ switch(archive->property_types[n])
+ {
+ case G_TYPE_STRING:
+ props_iter += sizeof(gchar *);
+ break;
+ case G_TYPE_UINT:
+ props_iter += sizeof(guint);
+ break;
+ case G_TYPE_UINT64:
+ props_iter += sizeof(guint64);
+ break;
+ }
+ }
+ return (*((guint *)props_iter));
}
+/**
+ * guint64
+ * lxa_archive_iter_get_prop_uint64(const LXAArchive *, const LXAArchiveIter
*, guint)
+ *
+ */
+guint64
+lxa_archive_iter_get_prop_uint64(const LXAArchive *archive, const
LXAArchiveIter *iter, guint i)
+{
+ gpointer props_iter = ((LXAEntry *)iter)->props;
+ guint n;
+#ifdef DEBUG
+ g_return_val_if_fail(i < (archive->n_property+LXA_ARCHIVE_PROP_USER),
0);
+ g_return_val_if_fail(i >= LXA_ARCHIVE_PROP_USER, 0);
+ g_return_val_if_fail(archive->property_types[i-LXA_ARCHIVE_PROP_USER]
== G_TYPE_UINT64, 0);
+#endif
+ if(!props_iter)
+ return 0;
+ for(n = 0; n < (i-LXA_ARCHIVE_PROP_USER); ++n)
+ {
+ switch(archive->property_types[n])
+ {
+ case G_TYPE_STRING:
+ props_iter += sizeof(gchar *);
+ break;
+ case G_TYPE_UINT:
+ props_iter += sizeof(guint);
+ break;
+ case G_TYPE_UINT64:
+ props_iter += sizeof(guint64);
+ break;
+ }
+ }
+ return (*((guint64 *)props_iter));
+}
+/**************
+ * Depricated *
+ **************/
+
LXAEntry *
lxa_entry_children_nth_data(LXAArchive *archive, LXAEntry *entry, guint n)
{
@@ -442,3 +960,12 @@
return NULL;
}
+guint
+lxa_entry_children_length(LXAEntry *entry)
+{
+ g_return_val_if_fail(entry, 0);
+ /* the first element of the array (*entry->children) contains the size
of the array */
+ return entry->children?GPOINTER_TO_INT(*entry->children):0 +
lxa_slist_length(entry->buffer);
+}
+
+
Modified: xarchiver/branches/xarchiver-psybsd/libxarchiver/archive.h
===================================================================
--- xarchiver/branches/xarchiver-psybsd/libxarchiver/archive.h 2006-10-18
20:10:53 UTC (rev 23464)
+++ xarchiver/branches/xarchiver-psybsd/libxarchiver/archive.h 2006-10-18
22:19:23 UTC (rev 23465)
@@ -31,20 +31,17 @@
LXA_ARCHIVESTATUS_USERBREAK
} LXAArchiveStatus;
+enum
+{
+ LXA_ARCHIVE_PROP_FILENAME = 0,
+ LXA_ARCHIVE_PROP_MIME_TYPE,
+ LXA_ARCHIVE_PROP_USER
+};
typedef struct _LXAEntry LXAEntry;
+typedef LXAEntry LXAArchiveIter;
-#include "slist.h"
-struct _LXAEntry {
- gchar *filename;
- gpointer props;
- gchar *mime_type;
- /* */
- LXAEntry **children;
- LXASList *buffer;
-};
-
#define LXA_ARCHIVE(obj) ( \
G_TYPE_CHECK_INSTANCE_CAST ((obj), \
lxa_archive_get_type(), \
@@ -96,21 +93,37 @@
GObjectClass parent;
};
-GType lxa_archive_get_type(void);
-LXAArchive *lxa_archive_new(gchar *, gchar *);
+GType lxa_archive_get_type(void);
+LXAArchive *lxa_archive_new(gchar *, gchar *);
-void lxa_archive_set_status(LXAArchive *archive,
LXAArchiveStatus status);
-gint lxa_archive_lookup_dir(gpointer entry, gconstpointer
filename);
-LXAEntry *lxa_archive_add_file(LXAArchive *archive, gchar *path);
-void lxa_archive_entry_add_child(LXAArchive *archive, LXAEntry
*parent, LXAEntry *child);
+void lxa_archive_set_status(LXAArchive *archive, LXAArchiveStatus
status);
-GSList *lxa_archive_get_children(LXAArchive *archive, gchar *path);
-LXAEntry *lxa_entry_get_child(LXAEntry *, const gchar *);
-guint lxa_entry_children_length(LXAEntry *entry);
-LXAEntry *lxa_entry_children_nth_data(LXAArchive *archive, LXAEntry
*entry, guint n);
-//gint lxa_entry_children_index(LXAEntry *entry, LXAEntry *find);
+/* new */
+gboolean lxa_archive_iter_is_directory(const LXAArchive *, const
LXAArchiveIter *);
+guint lxa_archive_iter_n_children(const LXAArchive *, const
LXAArchiveIter *);
+LXAArchiveIter *lxa_archive_iter_nth_child(LXAArchive *, LXAArchiveIter *,
guint);
+LXAArchiveIter *lxa_archive_iter_add_child(LXAArchive *, LXAArchiveIter *,
const gchar *);
+LXAArchiveIter *lxa_archive_iter_get_child(const LXAArchive *, const
LXAArchiveIter *, const gchar *);
+gboolean lxa_archive_iter_del_child(LXAArchive *, LXAArchiveIter *,
LXAArchiveIter *);
+/* void lxa_archive_iter_set_filename(LXAArchive *, LXAArchiveIter
*, const gchar *); */
+void lxa_archive_iter_set_mime(LXAArchive *, LXAArchiveIter *,
const gchar *);
+void lxa_archive_iter_set_prop_str(LXAArchive *, LXAArchiveIter *,
guint, const gchar *);
+void lxa_archive_iter_set_prop_uint(LXAArchive *, LXAArchiveIter *,
guint, guint);
+void lxa_archive_iter_set_prop_uint64(LXAArchive *, LXAArchiveIter
*, guint, guint64);
+void lxa_archive_iter_set_prop_value(LXAArchive *, LXAArchiveIter
*, guint, const GValue *);
+void lxa_archive_iter_set_props(LXAArchive *, LXAArchiveIter *,
...);
+const gchar *lxa_archive_iter_get_filename(const LXAArchive *, const
LXAArchiveIter *);
+const gchar *lxa_archive_iter_get_mime(const LXAArchive *, const
LXAArchiveIter *);
+const gchar *lxa_archive_iter_get_prop_str(const LXAArchive *, const
LXAArchiveIter *, guint);
+guint lxa_archive_iter_get_prop_uint(const LXAArchive *, const
LXAArchiveIter *, guint);
+guint64 lxa_archive_iter_get_prop_uint64(const LXAArchive *, const
LXAArchiveIter *, guint);
+gboolean lxa_archive_iter_get_prop_value(const LXAArchive *, const
LXAArchiveIter *, guint, GValue *);
+
+LXAArchiveIter *lxa_archive_add_file(LXAArchive *, const gchar *);
+GType lxa_archive_get_property_type(LXAArchive *, guint);
+
G_END_DECLS
#endif /* __LIBXARCHIVER_ARCHIVE_H__ */
Modified: xarchiver/branches/xarchiver-psybsd/libxarchiver/libxarchiver.c
===================================================================
--- xarchiver/branches/xarchiver-psybsd/libxarchiver/libxarchiver.c
2006-10-18 20:10:53 UTC (rev 23464)
+++ xarchiver/branches/xarchiver-psybsd/libxarchiver/libxarchiver.c
2006-10-18 22:19:23 UTC (rev 23465)
@@ -40,9 +40,11 @@
lxa_mime_init();
+ lxa_register_support(lxa_archive_support_gnu_tar_new());
+
+/*
lxa_register_support(lxa_archive_support_zip_new());
- lxa_register_support(lxa_archive_support_gnu_tar_new());
- /* TODO: Implement right commands in unrar
+ TODO: Implement right commands in unrar
lxa_register_support(lxa_archive_support_rar_new());
lxa_register_support(lxa_archive_support_unrar_new());
*/
Modified: xarchiver/branches/xarchiver-psybsd/libxarchiver/slist.c
===================================================================
--- xarchiver/branches/xarchiver-psybsd/libxarchiver/slist.c 2006-10-18
20:10:53 UTC (rev 23464)
+++ xarchiver/branches/xarchiver-psybsd/libxarchiver/slist.c 2006-10-18
22:19:23 UTC (rev 23465)
@@ -4,6 +4,7 @@
#include <glib-object.h>
#include "archive.h"
+#include "slist.h"
LXASList *
lxa_slist_insert_sorted_single(LXASList *list, LXAEntry *entry)
@@ -15,7 +16,8 @@
for(; iter; iter = iter->next)
{
- cmp = strcmp(entry->filename,
((LXAEntry*)iter->entry)->filename);
+ /* archive can be NULL */
+ cmp = strcmp(lxa_archive_iter_get_filename(NULL, entry),
lxa_archive_iter_get_filename( NULL, (LXAEntry*)iter->entry));
if(!cmp)
{
Modified: xarchiver/branches/xarchiver-psybsd/src/archive_store.c
===================================================================
--- xarchiver/branches/xarchiver-psybsd/src/archive_store.c 2006-10-18
20:10:53 UTC (rev 23464)
+++ xarchiver/branches/xarchiver-psybsd/src/archive_store.c 2006-10-18
22:19:23 UTC (rev 23465)
@@ -26,8 +26,6 @@
#include "archive_store.h"
-static LXAEntry xa_archive_store_up_entry;
-
static void
xa_archive_store_class_init(XAArchiveStoreClass *as_class);
@@ -105,7 +103,7 @@
xa_archive_store_has_default_sort_func(GtkTreeSortable *);
static gint
-xa_archive_entry_compare(XAArchiveStore *store, LXAEntry *a, LXAEntry *b);
+xa_archive_entry_compare(XAArchiveStore *store, LXAArchiveIter *a,
LXAArchiveIter *b);
static void
xa_archive_quicksort(XAArchiveStore *store, gint left, gint right);
static void
@@ -261,11 +259,12 @@
G_TYPE_NONE,
0,
NULL);
-
+/*
xa_archive_store_up_entry.filename = "..";
xa_archive_store_up_entry.props = NULL;
xa_archive_store_up_entry.children = NULL;
xa_archive_store_up_entry.buffer = NULL;
+*/
}
static void
@@ -278,7 +277,7 @@
if(XA_ARCHIVE_STORE(object)->props._show_icons !=
g_value_get_boolean(value)?1:0)
{
if(XA_ARCHIVE_STORE(object)->current_entry)
- prev_size =
lxa_entry_children_length(((LXAEntry*)XA_ARCHIVE_STORE(object)->current_entry->data));
+ prev_size =
lxa_entry_children_length(((LXAArchiveIter*)XA_ARCHIVE_STORE(object)->current_entry->data));
XA_ARCHIVE_STORE(object)->props._show_icons =
g_value_get_boolean(value)?1:0;
xa_archive_store_refresh(XA_ARCHIVE_STORE(object), prev_size);
}
@@ -287,7 +286,7 @@
if(XA_ARCHIVE_STORE(object)->props._show_up_dir !=
g_value_get_boolean(value)?1:0)
{
if(XA_ARCHIVE_STORE(object)->current_entry)
- prev_size =
lxa_entry_children_length(((LXAEntry*)XA_ARCHIVE_STORE(object)->current_entry->data));
+ prev_size =
lxa_entry_children_length(((LXAArchiveIter*)XA_ARCHIVE_STORE(object)->current_entry->data));
XA_ARCHIVE_STORE(object)->props._show_up_dir =
g_value_get_boolean(value)?1:0;
xa_archive_store_refresh(XA_ARCHIVE_STORE(object), prev_size);
}
@@ -350,7 +349,7 @@
if(!archive)
return 0;
- return archive->n_property + 2;
+ return archive->n_property + 1;
}
static GType
@@ -364,14 +363,12 @@
if(!archive)
return G_TYPE_INVALID;
- index -= 2;
+ index--;
if(index < 0)
return G_TYPE_STRING;
- g_return_val_if_fail(index < archive->n_property, G_TYPE_INVALID);
-
- return archive->property_types[index];
+ return lxa_archive_get_property_type(archive, index);
}
static gboolean
@@ -382,7 +379,7 @@
XAArchiveStore *store = XA_ARCHIVE_STORE(tree_model);
LXAArchive *archive = store->archive;
- LXAEntry *entry = NULL;
+ LXAArchiveIter *entry = NULL;
if(!store->current_entry)
return FALSE;
@@ -402,7 +399,7 @@
if(index == -1)
{
- entry = &xa_archive_store_up_entry;
+ entry = NULL;
}
else
{
@@ -410,7 +407,7 @@
if(store->sort_list)
entry = store->sort_list[index];
else
- entry = lxa_entry_children_nth_data(archive, entry,
index);
+ entry = lxa_archive_iter_nth_child(archive, entry,
index);
g_return_val_if_fail(entry, FALSE);
@@ -434,7 +431,7 @@
g_return_val_if_fail(archive, NULL);
- LXAEntry *entry = (LXAEntry*)iter->user_data2;
+ LXAArchiveIter *entry = (LXAArchiveIter*)iter->user_data2;
gint pos = GPOINTER_TO_INT(iter->user_data3);
if(store->props._show_up_dir && archive->root_entry != entry)
@@ -456,76 +453,39 @@
XAArchiveStore *store = XA_ARCHIVE_STORE(tree_model);
LXAArchive *archive = store->archive;
+ LXAArchiveIter *entry = iter->user_data;
g_return_if_fail(archive);
- column -= 2;
+ column--;
- g_return_if_fail (column < (gint)archive->n_property);
-
- LXAEntry *entry = ((LXAEntry *)iter->user_data);
- gpointer props_iter = entry->props;
- gint i = 0;
-
- if(column == -2)
+ if(entry)
{
- g_value_init(value, G_TYPE_STRING);
-
- if(store->props._show_icons)
+ if(column == -1)
{
- if(entry == &xa_archive_store_up_entry)
- {
- g_value_set_string(value, GTK_STOCK_GO_UP);
- }
- else
- {
- if(store->icon_theme)
- {
- g_value_set_string(value,
entry->mime_type);
-
lxa_mime_convert_to_icon_name(store->icon_theme, value);
- }
- }
+ lxa_archive_iter_get_prop_value(archive, entry,
LXA_ARCHIVE_PROP_MIME_TYPE, value);
+ lxa_mime_convert_to_icon_name(store->icon_theme, value);
}
+ else
+ {
+ lxa_archive_iter_get_prop_value(archive, entry, column,
value);
+ }
}
- else if(column == -1)
- {
- g_value_init(value, G_TYPE_STRING);
-
- g_value_set_string(value, entry->filename);
- }
else
{
- g_value_init(value, archive->property_types[column]);
-
- if(props_iter)
+ switch(column)
{
- for(;i<column;i++)
- {
- switch(archive->property_types[i])
- {
- case G_TYPE_STRING:
- props_iter+=sizeof(gchar *);
- break;
- case G_TYPE_UINT64:
- props_iter+=sizeof(guint64);
- break;
- case G_TYPE_UINT:
- props_iter+=sizeof(guint);
- break;
- }
- }
- switch(archive->property_types[column])
- {
- case G_TYPE_STRING:
- g_value_set_string(value, *(gchar
**)props_iter);
- break;
- case G_TYPE_UINT64:
- g_value_set_uint64(value, *(guint64
*)props_iter);
- break;
- case G_TYPE_UINT:
- g_value_set_uint(value, *(guint
*)props_iter);
- break;
- }
+ case -1:
+ g_value_init(value, G_TYPE_STRING);
+ g_value_set_string(value, GTK_STOCK_GO_UP);
+ break;
+ case LXA_ARCHIVE_PROP_FILENAME:
+ g_value_init(value, G_TYPE_STRING);
+ g_value_set_string(value, "..");
+ break;
+ default:
+ g_value_init(value,
lxa_archive_get_property_type(archive, column));
+ break;
}
}
}
@@ -537,19 +497,19 @@
XAArchiveStore *store = XA_ARCHIVE_STORE(tree_model);
- LXAEntry *entry = (LXAEntry*)iter->user_data2;
+ LXAArchiveIter *entry = (LXAArchiveIter*)iter->user_data2;
gint pos = GPOINTER_TO_INT(iter->user_data3);
pos++;
if(store->sort_list)
{
- if(pos < lxa_entry_children_length(entry))
+ if(pos < lxa_archive_iter_n_children(store->archive, entry))
entry = store->sort_list[pos];
else
entry = NULL;
}
else
- entry = lxa_entry_children_nth_data(store->archive, entry, pos);
+ entry = lxa_archive_iter_nth_child(store->archive, entry, pos);
if(!entry)
return FALSE;
@@ -568,7 +528,7 @@
XAArchiveStore *store = XA_ARCHIVE_STORE(tree_model);
LXAArchive *archive = store->archive;
- LXAEntry *entry = store->current_entry->data;
+ LXAArchiveIter *entry = store->current_entry->data;
g_return_val_if_fail(archive, FALSE);
g_return_val_if_fail(entry, FALSE);
@@ -578,7 +538,7 @@
if(store->props._show_up_dir && archive->root_entry != entry)
{
- entry = &xa_archive_store_up_entry;
+ entry = NULL;
iter->user_data3 = GINT_TO_POINTER(-1);
}
else
@@ -586,7 +546,7 @@
if(store->sort_list)
entry = store->sort_list[0];
else
- entry = lxa_entry_children_nth_data(archive, entry, 0);
+ entry = lxa_archive_iter_nth_child(archive, entry, 0);
g_return_val_if_fail(entry, FALSE);
@@ -613,7 +573,7 @@
XAArchiveStore *store = XA_ARCHIVE_STORE(tree_model);
LXAArchive *archive = store->archive;
- LXAEntry *entry = store->current_entry->data;
+ LXAArchiveIter *entry = store->current_entry->data;
g_return_val_if_fail(archive, 0);
g_return_val_if_fail(entry, 0);
@@ -631,7 +591,7 @@
XAArchiveStore *store = XA_ARCHIVE_STORE(tree_model);
LXAArchive *archive = store->archive;
- LXAEntry *entry = store->current_entry->data;
+ LXAArchiveIter *entry = store->current_entry->data;
g_return_val_if_fail(archive, FALSE);
g_return_val_if_fail(entry, FALSE);
@@ -645,14 +605,14 @@
if(n == -1)
{
- entry = &xa_archive_store_up_entry;
+ entry = NULL;
}
else
{
if(store->sort_list)
entry = store->sort_list[n];
else
- entry = lxa_entry_children_nth_data(archive, entry, n);
+ entry = lxa_archive_iter_nth_child(archive, entry, n);
g_return_val_if_fail(entry, FALSE);
}
@@ -728,22 +688,22 @@
}
static gint
-xa_archive_entry_compare(XAArchiveStore *store, LXAEntry *a, LXAEntry *b)
+xa_archive_entry_compare(XAArchiveStore *store, LXAArchiveIter *a,
LXAArchiveIter *b)
{
- gint cmp_a = 0;
- gint cmp_b = 0;
+ gboolean cmp_a = 0;
+ gboolean cmp_b = 0;
if(store->props._sort_folders_first)
{
- cmp_a = strcmp(a->mime_type, "inode/directory");
- cmp_b = strcmp(b->mime_type, "inode/directory");
+ cmp_a = lxa_archive_iter_is_directory(store->archive, a);
+ cmp_b = lxa_archive_iter_is_directory(store->archive, b);
- if(cmp_a == 0 && cmp_b != 0)
+ if(cmp_a && !cmp_b)
return -1;
- if(cmp_b == 0 && cmp_a != 0)
+ if(cmp_b && !cmp_a)
return 1;
}
- LXAEntry *swap = b;
+ LXAArchiveIter *swap = b;
if(store->sort_order == GTK_SORT_DESCENDING)
{
b = a;
@@ -752,65 +712,24 @@
LXAArchive *archive = store->archive;
gint column = store->sort_column;
- gpointer props_a = a->props;
- gpointer props_b = b->props;
gint i = 0;
- column -= 2;
+ column--;
- g_return_val_if_fail(column > -2, 0);
-
- if(column == -1)
- switch(store->props._sort_case_sensitive)
- {
- case 0: /* case insensitive */
- return g_ascii_strcasecmp(a->filename,
b->filename);
- case 1: /* case sensitive*/
- return strcmp(a->filename, b->filename);
- }
-
- if(!props_a)
+ switch(lxa_archive_get_property_type(archive, column))
{
- return props_b?-1:0;
- }
- if(!props_b)
- {
- return props_a?1:0;
- }
-
- for(i=0;i<column;i++)
- {
- switch(archive->property_types[i])
- {
- case G_TYPE_STRING:
- props_a+=sizeof(gchar *);
- props_b+=sizeof(gchar *);
- break;
- case G_TYPE_UINT64:
- props_a+=sizeof(guint64);
- props_b+=sizeof(guint64);
- break;
- case G_TYPE_UINT:
- props_a+=sizeof(guint);
- props_b+=sizeof(guint);
- break;
- }
- }
-
- switch(archive->property_types[column])
- {
case G_TYPE_STRING:
switch(store->props._sort_case_sensitive)
{
case 0: /* case insensitive */
- return
g_ascii_strcasecmp(*((gchar**)props_a), *((gchar**)props_b));
+ return
g_ascii_strcasecmp(lxa_archive_iter_get_prop_str(archive, a, column),
lxa_archive_iter_get_prop_str(archive, b, column));
case 1: /* case sensitive */
- return strcmp(*((gchar**)props_a),
*((gchar**)props_b));
+ return
strcmp(lxa_archive_iter_get_prop_str(archive, a, column),
lxa_archive_iter_get_prop_str(archive, b, column));
}
case G_TYPE_UINT64:
- return (*((guint64*)props_a)) - (*((guint64*)props_b));
+ return lxa_archive_iter_get_prop_uint64(archive, a,
column) - lxa_archive_iter_get_prop_uint64(archive, b, column);
case G_TYPE_UINT:
- return (*((guint*)props_a)) - (*((guint*)props_b));
+ return lxa_archive_iter_get_prop_uint(archive, a,
column) - lxa_archive_iter_get_prop_uint(archive, b, column);
}
g_return_val_if_reached(0);
@@ -828,27 +747,27 @@
if(store->sort_column < 0)
return;
- LXAEntry *pentry = (LXAEntry*)store->current_entry->data;
+ LXAArchiveIter *pentry = (LXAArchiveIter*)store->current_entry->data;
gint psize = lxa_entry_children_length(pentry);
gint i = 0;
if(psize <= 1)
return;
- store->sort_list = g_new(LXAEntry*, psize);
+ store->sort_list = g_new(LXAArchiveIter*, psize);
for(i = 0; i < psize; i++)
{
- store->sort_list[i] =
lxa_entry_children_nth_data(store->archive, pentry, i);
+ store->sort_list[i] =
lxa_archive_iter_nth_child(store->archive, pentry, i);
}
xa_archive_quicksort(store, 0, psize-1);
xa_archive_insertionsort(store, 0, psize-1);
}
inline void
-swap(LXAEntry **left, LXAEntry **right)
+swap(LXAArchiveIter **left, LXAArchiveIter **right)
{
- LXAEntry *tmp = *right;
+ LXAArchiveIter *tmp = *right;
*right = *left;
*left = tmp;
}
@@ -860,8 +779,8 @@
gint i = (left+right)/2;
gint j = right-1;
- LXAEntry *value = NULL;
- LXAEntry **list = store->sort_list;
+ LXAArchiveIter *value = NULL;
+ LXAArchiveIter **list = store->sort_list;
if(xa_archive_entry_compare(store, list[left], list[i]) > 0)
swap(list+left, list+i);
@@ -892,8 +811,8 @@
{
gint i = 0;
gint j = 0;
- LXAEntry *value = NULL;
- LXAEntry **list = store->sort_list;
+ LXAArchiveIter *value = NULL;
+ LXAArchiveIter **list = store->sort_list;
for(i = left+1; i <= right; i++)
{
@@ -937,7 +856,7 @@
xa_archive_store_refresh(XAArchiveStore *store, gint prev_size)
{
LXAArchive *archive = store->archive;
- LXAEntry *entry = store->current_entry->data;
+ LXAArchiveIter *entry = store->current_entry->data;
g_return_if_fail(archive);
g_return_if_fail(entry);
@@ -953,7 +872,7 @@
gtk_tree_path_append_index(path_, 0);
iter.stamp = store->stamp;
- iter.user_data = &xa_archive_store_up_entry;
+ iter.user_data = NULL;
iter.user_data2 = entry;
iter.user_data3 = GINT_TO_POINTER(-1);
@@ -975,7 +894,7 @@
if(store->sort_list)
iter.user_data = store->sort_list[i];
else
- iter.user_data = lxa_entry_children_nth_data(archive,
archive->root_entry, i);
+ iter.user_data = lxa_archive_iter_nth_child(archive,
archive->root_entry, i);
iter.user_data2 = entry;
iter.user_data3 = GINT_TO_POINTER(index);
@@ -1007,7 +926,7 @@
LXAArchive *archive = store->archive;
- LXAEntry *entry = store->current_entry->data;
+ LXAArchiveIter *entry = store->current_entry->data;
g_return_if_fail(archive);
g_return_if_fail(entry);
@@ -1037,12 +956,12 @@
if(store->sort_list)
entry = store->sort_list[index];
else
- entry = lxa_entry_children_nth_data(archive, entry,
index);
+ entry = lxa_archive_iter_nth_child(archive, entry,
index);
g_return_if_fail(entry);
/* TODO Signal file-activated */
- if(strcmp(entry->mime_type, "inode/directory"))
+ if(!lxa_archive_iter_is_directory(archive, entry))
{
#ifdef DEBUG
g_debug("file clicked");
@@ -1063,7 +982,7 @@
xa_archive_store_go_up(XAArchiveStore *store)
{
LXAArchive *archive = store->archive;
- LXAEntry *entry = store->current_entry->data;
+ LXAArchiveIter *entry = store->current_entry->data;
g_return_if_fail(archive);
g_return_if_fail(entry);
@@ -1095,7 +1014,7 @@
GtkTreeIter iter;
g_return_if_fail(store);
- LXAEntry *entry = NULL;
+ LXAArchiveIter *entry = NULL;
gint prev_size = 0;
if(store->sort_list)
@@ -1152,7 +1071,7 @@
if(store->sort_list)
iter.user_data = store->sort_list[i];
else
- iter.user_data = lxa_entry_children_nth_data(archive,
archive->root_entry, i);
+ iter.user_data = lxa_archive_iter_nth_child(archive,
archive->root_entry, i);
iter.user_data2 = archive->root_entry;
iter.user_data3 = GINT_TO_POINTER(i);
@@ -1171,7 +1090,7 @@
g_return_val_if_fail(store, NULL);
gchar *path = NULL;
- gchar **buf = NULL;
+ const gchar **buf = NULL;
GSList *iter = store->current_entry;
gint i = g_slist_length(iter);
gchar *lastfile = NULL;
@@ -1181,13 +1100,13 @@
if(i<=1)
return g_strdup("");
- buf = g_new(gchar*, i);
+ buf = g_new(const gchar*, i);
i--;
buf[i] = NULL;
- namelen = strlen(((LXAEntry*)iter->data)->filename);
+ namelen = strlen(lxa_archive_iter_get_filename(store->archive,
(LXAArchiveIter*)iter->data));
lastfile = g_new(gchar, namelen+2);
- strcpy(lastfile, ((LXAEntry*)iter->data)->filename);
+ strcpy(lastfile, lxa_archive_iter_get_filename(store->archive,
(LXAArchiveIter*)iter->data));
if(lastfile[namelen-1] != '/')
{
lastfile[namelen] = '/';
@@ -1203,7 +1122,7 @@
while(iter->next)
{
--i;
- buf[i] = ((LXAEntry*)iter->data)->filename;
+ buf[i] = lxa_archive_iter_get_filename(store->archive,
(LXAArchiveIter*)iter->data);
iter = iter->next;
}
}
@@ -1213,7 +1132,8 @@
buf[0] = "";
}
- path = g_strjoinv("/", buf);
+ /* why does glib want buf to be gchar** instead of const gchar** ? */
+ path = g_strjoinv("/", (gchar**)buf);
g_free(lastfile);
g_free(buf);
@@ -1235,7 +1155,7 @@
/* we don't want to include de archive rootentry */
while(iter->next)
{
- path = g_slist_prepend(path,
g_strdup(((LXAEntry*)iter->data)->filename));
+ path = g_slist_prepend(path,
g_strdup(lxa_archive_iter_get_filename(store->archive,
(LXAArchiveIter*)iter->data)));
iter = iter->next;
}
@@ -1261,14 +1181,14 @@
gchar **buf = g_strsplit_set(path, "/\n", -1);
gchar **iter = buf;
- LXAEntry *entry = store->archive->root_entry;
+ LXAArchiveIter *entry = store->archive->root_entry;
GSList *stack = g_slist_prepend(NULL, entry);
- gint prev_size =
lxa_entry_children_length(((LXAEntry*)store->current_entry->data));
+ gint prev_size =
lxa_entry_children_length(((LXAArchiveIter*)store->current_entry->data));
if(store->props._show_up_dir && store->archive->root_entry !=
store->current_entry->data)
prev_size++;
- if(path[0] == '/' && lxa_entry_get_child(store->archive->root_entry,
"/"))
+ if(path[0] == '/' && lxa_archive_iter_get_child(store->archive,
store->archive->root_entry, "/"))
{
iter[0] = strdup("/");
}
@@ -1277,7 +1197,7 @@
{
if((*iter)[0])
{
- entry = lxa_entry_get_child(entry, *iter);
+ entry = lxa_archive_iter_get_child(store->archive,
entry, *iter);
if(!entry)
{
g_strfreev(buf);
Modified: xarchiver/branches/xarchiver-psybsd/src/main_window.c
===================================================================
--- xarchiver/branches/xarchiver-psybsd/src/main_window.c 2006-10-18
20:10:53 UTC (rev 23464)
+++ xarchiver/branches/xarchiver-psybsd/src/main_window.c 2006-10-18
22:19:23 UTC (rev 23465)
@@ -64,7 +64,7 @@
xa_main_window_finalize(GObject *object);
gboolean
-xa_main_window_add_item(LXAEntry *entry, gpointer data);
+xa_main_window_add_item(LXAArchiveIter *entry, gpointer data);
void
xa_main_window_set_contents(XAMainWindow *, LXAArchive *);
@@ -809,11 +809,11 @@
case(G_TYPE_STRING):
case(G_TYPE_UINT64):
renderer = gtk_cell_renderer_text_new();
- column =
gtk_tree_view_column_new_with_attributes(archive->property_names[x], renderer,
"text", x+2, NULL);
+ column =
gtk_tree_view_column_new_with_attributes(archive->property_names[x], renderer,
"text", x+3, NULL);
break;
}
gtk_tree_view_column_set_resizable(column, TRUE);
- gtk_tree_view_column_set_sort_column_id(column, x+2);
+ gtk_tree_view_column_set_sort_column_id(column, x+3);
gtk_tree_view_append_column(GTK_TREE_VIEW(window->treeview), column);
}
}
@@ -834,83 +834,18 @@
gtk_tree_view_set_model(GTK_TREE_VIEW(main_window->treeview),
GTK_TREE_MODEL(liststore));
}
-gboolean
-xa_main_window_add_item(LXAEntry *entry, gpointer data)
-{
- gint i = 0;
- GtkTreeIter iter;
- gpointer props;
- gpointer props_iter;
- GValue *tmp_value;
- XAMainWindow *main_window= XA_MAIN_WINDOW(data);
- GtkTreeModel *liststore = main_window->treemodel;
- gtk_list_store_append(GTK_LIST_STORE(liststore), &iter);
- if(main_window->props._show_icons)
- {
- tmp_value = g_new0(GValue, 1);
- tmp_value = g_value_init(tmp_value, G_TYPE_STRING);
- g_value_set_string(tmp_value, entry->mime_type);
- gtk_list_store_set_value(GTK_LIST_STORE(liststore), &iter, i,
tmp_value);
- g_value_unset(tmp_value);
- g_free(tmp_value);
- i++;
- }
- tmp_value = g_new0(GValue, 1);
- tmp_value = g_value_init(tmp_value, G_TYPE_STRING);
- g_value_set_string(tmp_value, entry->filename);
- gtk_list_store_set_value(GTK_LIST_STORE(liststore), &iter, i,
tmp_value);
- g_value_unset(tmp_value);
- g_free(tmp_value);
-
- props = entry->props;
- if(props)
- {
- props_iter = props;
-
- for(i=0; i < main_window->lp_xa_archive->n_property; i++)
- {
- tmp_value = g_new0(GValue, 1);
- tmp_value = g_value_init(tmp_value,
main_window->lp_xa_archive->property_types[i]);
- switch(main_window->lp_xa_archive->property_types[i])
- {
- case(G_TYPE_UINT):
- g_value_set_uint(tmp_value, *(guint
*)props_iter);
- props_iter += sizeof(guint);
- break;
- case(G_TYPE_STRING):
- g_value_set_string(tmp_value, *(gchar
**)props_iter);
- props_iter += sizeof(gchar *);
- break;
- case(G_TYPE_UINT64):
- g_value_set_uint64(tmp_value, *(guint64
*)props_iter);
- props_iter += sizeof(guint64);
- break;
- }
- if(main_window->props._show_icons)
-
gtk_list_store_set_value(GTK_LIST_STORE(liststore), &iter, i+1, tmp_value);
- else
-
gtk_list_store_set_value(GTK_LIST_STORE(liststore), &iter, i, tmp_value);
- g_value_unset(tmp_value);
- g_free(tmp_value);
- }
- }
- return FALSE;
-}
-
-
-
gchar *
xa_main_window_get_working_dir(XAMainWindow *window)
{
- gchar *temp = ((LXAEntry *)window->working_node->data)->filename;
+ const gchar *temp =
lxa_archive_iter_get_filename(window->lp_xa_archive, (LXAArchiveIter
*)window->working_node->data);
gchar *path = g_strdup(temp), *_temp = NULL;
GSList *_path = window->working_node->next;
while(_path)
{
- if((((LXAEntry *)_path->data)->filename[0] != '/'))
+ if((lxa_archive_iter_get_filename(window->lp_xa_archive,
(LXAArchiveIter *)_path->data)[0] != '/'))
{
_temp = path;
- path = g_strconcat(((LXAEntry *)_path->data)->filename,
"/", _temp,NULL);
+ path =
g_strconcat(lxa_archive_iter_get_filename(window->lp_xa_archive,
(LXAArchiveIter *)_path->data), "/", _temp,NULL);
g_free(_temp);
}
_path = _path->next;
_______________________________________________
Xfce4-commits mailing list
Xfce4-commits@xfce.org
http://foo-projects.org/mailman/listinfo/xfce4-commits
