From 5d4895eb431adfbf2c7895d4257fa20a28f474f9 Mon Sep 17 00:00:00 2001 From: Christopher James Lahey Date: Tue, 8 May 2001 04:56:03 +0000 Subject: Added util/e-sorter-array.lo and widgets/e-reflow-model.lo. Removed 2001-05-07 Christopher James Lahey * gal/Makefile.am (libgal_la_LIBADD): Added util/e-sorter-array.lo and widgets/e-reflow-model.lo. Removed widgets/e-reflow-sorted.lo. * gal/util/Makefile.am (libutil_la_SOURCES): Added e-sorter-array.c. (libgalinclude_HEADERS): Added e-sorter-array.h. * gal/util/e-sorter-array.c, gal/util/e-sorter-array.h: A sorter for use with a single compare function to do sorting. * gal/util/e-util.c, gal/util/e-util.h (e_marshal_INT__OBJECT_POINTER): Added this marshaller. * gal/widgets/Makefile.am (libwidgets_la_SOURCES): Added e-reflow-model.c. Removed e-reflow-sorted.c. (libwidgetsinclude_HEADERS): Added e-reflow-sorted.h. Removed e-reflow-model.h. * gal/widgets/e-reflow-model.c, gal/widgets/e-reflow-model.h: Model for EReflow. Has a number of items and generates canvas items on the fly. * gal/widgets/e-reflow.c, gal/widgets/e-reflow.h: Major rewrite. This now uses a model to generate its canvas items instead of having canvas items added to it. It doesn't create the canvas items now until they will be shown on screen. svn path=/trunk/; revision=9710 --- e-util/e-sorter-array.c | 278 ++++++++++++++++++++++++++++++++++++++++++++++++ e-util/e-sorter-array.h | 56 ++++++++++ e-util/e-util.c | 21 ++++ e-util/e-util.h | 21 ++-- 4 files changed, 365 insertions(+), 11 deletions(-) create mode 100644 e-util/e-sorter-array.c create mode 100644 e-util/e-sorter-array.h (limited to 'e-util') diff --git a/e-util/e-sorter-array.c b/e-util/e-sorter-array.c new file mode 100644 index 0000000000..44cf7b0f67 --- /dev/null +++ b/e-util/e-sorter-array.c @@ -0,0 +1,278 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* + * e-sorter-array.c: + * + * Author: + * Christopher James Lahey + * + * (C) 2001 Ximian, Inc. + */ +#include +#include +#include +#include +#include "gal/util/e-util.h" +#include "e-sorter-array.h" + +#define d(x) + +/* The arguments we take */ +enum { + ARG_0, +}; + +#define PARENT_TYPE e_sorter_get_type() + +#define INCREMENT_AMOUNT 100 + +static ESorterClass *parent_class; + +static void esa_sort (ESorterArray *esa); +static void esa_backsort (ESorterArray *esa); + +static gint esa_model_to_sorted (ESorter *sorter, int row); +static gint esa_sorted_to_model (ESorter *sorter, int row); +static void esa_get_model_to_sorted_array (ESorter *sorter, int **array, int *count); +static void esa_get_sorted_to_model_array (ESorter *sorter, int **array, int *count); +static gboolean esa_needs_sorting (ESorter *esa); + +#define ESA_NEEDS_SORTING(esa) (((ESorterArray *) (esa))->compare != NULL) + +static int +esort_callback(const void *data1, const void *data2, gpointer user_data) +{ + ESorterArray *esa = user_data; + int ret_val; + int int1, int2; + + int1 = *(int *)data1; + int2 = *(int *)data2; + + ret_val = esa->compare (int1, int2, esa->closure); + if (ret_val != 0) + return ret_val; + + if (int1 < int2) + return -1; + if (int1 > int2) + return 1; + return 0; +} + +static void +esa_sort(ESorterArray *esa) +{ + int rows; + int i; + + if (esa->sorted) + return; + + rows = esa->rows; + + esa->sorted = g_new(int, rows); + for (i = 0; i < rows; i++) + esa->sorted[i] = i; + + if (esa->compare) + e_sort (esa->sorted, rows, sizeof(int), esort_callback, esa); +} + +static void +esa_backsort(ESorterArray *esa) +{ + int i, rows; + + if (esa->backsorted) + return; + + esa_sort(esa); + + rows = esa->rows; + + esa->backsorted = g_new0(int, rows); + + for (i = 0; i < rows; i++) { + esa->backsorted[esa->sorted[i]] = i; + } +} + + +static gint +esa_model_to_sorted (ESorter *es, int row) +{ + ESorterArray *esa = E_SORTER_ARRAY(es); + + g_return_val_if_fail(row >= 0, -1); + g_return_val_if_fail(row < esa->rows, -1); + + if (ESA_NEEDS_SORTING(es)) + esa_backsort(esa); + + if (esa->backsorted) + return esa->backsorted[row]; + else + return row; +} + +static gint +esa_sorted_to_model (ESorter *es, int row) +{ + ESorterArray *esa = (ESorterArray *) es; + + g_return_val_if_fail(row >= 0, -1); + g_return_val_if_fail(row < esa->rows, -1); + + if (ESA_NEEDS_SORTING(es)) + esa_sort(esa); + + if (esa->sorted) + return esa->sorted[row]; + else + return row; +} + +static void +esa_get_model_to_sorted_array (ESorter *es, int **array, int *count) +{ + ESorterArray *esa = E_SORTER_ARRAY(es); + if (array || count) { + esa_backsort(esa); + + if (array) + *array = esa->backsorted; + if (count) + *count = esa->rows; + } +} + +static void +esa_get_sorted_to_model_array (ESorter *es, int **array, int *count) +{ + ESorterArray *esa = E_SORTER_ARRAY(es); + if (array || count) { + esa_sort(esa); + + if (array) + *array = esa->sorted; + if (count) + *count = esa->rows; + } +} + +static gboolean +esa_needs_sorting(ESorter *es) +{ + ESorterArray *esa = E_SORTER_ARRAY(es); + return esa->compare != NULL; +} + +void +e_sorter_array_clean(ESorterArray *esa) +{ + g_free(esa->sorted); + esa->sorted = NULL; + + g_free(esa->backsorted); + esa->backsorted = NULL; +} + +void +e_sorter_array_set_count (ESorterArray *esa, int count) +{ + e_sorter_array_clean (esa); + esa->rows = count; +} + +void +e_sorter_array_append (ESorterArray *esa, int count) +{ + int i; + g_free(esa->backsorted); + esa->backsorted = NULL; + + if (esa->sorted) { + esa->sorted = g_renew(int, esa->sorted, esa->rows + count); + for (i = 0; i < count; i++) { + int value = esa->rows; + int pos; + e_bsearch (&value, esa->sorted, esa->rows, sizeof (int), esort_callback, esa, &pos, NULL); + memmove (esa->sorted + pos + 1, esa->sorted + pos, sizeof (int) * (esa->rows - pos)); + esa->sorted[pos] = value; + esa->rows ++; + } + } else { + esa->rows = count; + } +} + +ESorterArray * +e_sorter_array_construct (ESorterArray *esa, + ECompareRowsFunc compare, + gpointer closure) +{ + esa->compare = compare; + esa->closure = closure; + return esa; +} + +ESorterArray * +e_sorter_array_new (ECompareRowsFunc compare, gpointer closure) +{ + ESorterArray *esa = gtk_type_new (E_SORTER_ARRAY_TYPE); + + return e_sorter_array_construct (esa, compare, closure); +} + +static void +esa_destroy (GtkObject *object) +{ + GTK_OBJECT_CLASS (parent_class)->destroy (object); +} + +static void +esa_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) +{ + switch (arg_id) { + default: + break; + } +} + +static void +esa_get_arg (GtkObject *object, GtkArg *arg, guint arg_id) +{ + switch (arg_id) { + } +} + +static void +esa_class_init (ESorterArrayClass *klass) +{ + GtkObjectClass *object_class = GTK_OBJECT_CLASS(klass); + ESorterClass *sorter_class = E_SORTER_CLASS(klass); + + parent_class = gtk_type_class (PARENT_TYPE); + + object_class->destroy = esa_destroy; + object_class->set_arg = esa_set_arg; + object_class->get_arg = esa_get_arg; + + sorter_class->model_to_sorted = esa_model_to_sorted ; + sorter_class->sorted_to_model = esa_sorted_to_model ; + sorter_class->get_model_to_sorted_array = esa_get_model_to_sorted_array ; + sorter_class->get_sorted_to_model_array = esa_get_sorted_to_model_array ; + sorter_class->needs_sorting = esa_needs_sorting ; +} + +static void +esa_init (ESorterArray *esa) +{ + esa->rows = 0; + esa->compare = NULL; + esa->closure = NULL; + esa->sorted = NULL; + esa->backsorted = NULL; +} + +E_MAKE_TYPE(e_sorter_array, "ESorterArray", ESorterArray, esa_class_init, esa_init, PARENT_TYPE); diff --git a/e-util/e-sorter-array.h b/e-util/e-sorter-array.h new file mode 100644 index 0000000000..7f876e4148 --- /dev/null +++ b/e-util/e-sorter-array.h @@ -0,0 +1,56 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +#ifndef _E_SORTER_ARRAY_H_ +#define _E_SORTER_ARRAY_H_ + +#include +#include +#include +#include + +BEGIN_GNOME_DECLS + +#define E_SORTER_ARRAY_TYPE (e_sorter_array_get_type ()) +#define E_SORTER_ARRAY(o) (GTK_CHECK_CAST ((o), E_SORTER_ARRAY_TYPE, ESorterArray)) +#define E_SORTER_ARRAY_CLASS(k) (GTK_CHECK_CLASS_CAST((k), E_SORTER_ARRAY_TYPE, ESorterArrayClass)) +#define E_IS_SORTER_ARRAY(o) (GTK_CHECK_TYPE ((o), E_SORTER_ARRAY_TYPE)) +#define E_IS_SORTER_ARRAY_CLASS(k) (GTK_CHECK_CLASS_TYPE ((k), E_SORTER_ARRAY_TYPE)) + +#ifndef _E_COMPARE_ROWS_FUNC_H_ +#define _E_COMPARE_ROWS_FUNC_H_ +typedef int (*ECompareRowsFunc) (int row1, + int row2, + gpointer closure); +#endif + +typedef struct { + ESorter base; + + ECompareRowsFunc compare; + gpointer closure; + + /* If needs_sorting is 0, then model_to_sorted and sorted_to_model are no-ops. */ + int *sorted; + int *backsorted; + + int rows; +} ESorterArray; + +typedef struct { + ESorterClass parent_class; +} ESorterArrayClass; + +GtkType e_sorter_array_get_type (void); +ESorterArray *e_sorter_array_construct (ESorterArray *sorter, + ECompareRowsFunc compare, + gpointer closure); +ESorterArray *e_sorter_array_new (ECompareRowsFunc compare, + gpointer closure); +void e_sorter_array_clean (ESorterArray *esa); +void e_sorter_array_set_count (ESorterArray *esa, + int count); +void e_sorter_array_append (ESorterArray *esa, + int count); + +END_GNOME_DECLS + +#endif /* _E_SORTER_ARRAY_H_ */ diff --git a/e-util/e-util.c b/e-util/e-util.c index 5bbb9522b4..d7770ac3fa 100644 --- a/e-util/e-util.c +++ b/e-util/e-util.c @@ -678,6 +678,27 @@ e_marshal_NONE__POINTER_INT_INT_INT (GtkObject *object, func_data); } +typedef int (*GtkSignal_INT__OBJECT_POINTER) (GtkObject *, + GtkObject *, gpointer, + gpointer user_data); +void +e_marshal_INT__OBJECT_POINTER (GtkObject *object, + GtkSignalFunc func, + gpointer func_data, + GtkArg *args) +{ + GtkSignal_INT__OBJECT_POINTER rfunc; + int *return_val; + + rfunc = (GtkSignal_INT__OBJECT_POINTER) func; + return_val = GTK_RETLOC_INT (args[2]); + + *return_val = (*rfunc) (object, + GTK_VALUE_OBJECT (args[0]), + GTK_VALUE_POINTER (args[1]), + func_data); +} + gchar** e_strsplit (const gchar *string, const gchar *delimiter, diff --git a/e-util/e-util.h b/e-util/e-util.h index bf89b27aa1..c131676fc6 100644 --- a/e-util/e-util.h +++ b/e-util/e-util.h @@ -80,14 +80,12 @@ gchar *e_strstrcase (cons void e_filename_make_safe (gchar *string); gchar *e_format_number (gint number); gchar *e_format_number_float (gfloat number); - gboolean e_create_directory (gchar *directory); typedef int (*ESortCompareFunc) (const void *first, const void *second, gpointer closure); - void e_sort (void *base, size_t nmemb, size_t size, @@ -99,11 +97,8 @@ void e_bsearch (cons size_t size, ESortCompareFunc compare, gpointer closure, - size_t *start, - size_t *end); - - - + size_t *start, + size_t *end); void e_marshal_INT__INT_INT_POINTER (GtkObject *object, GtkSignalFunc func, gpointer func_data, @@ -192,11 +187,15 @@ void e_marshal_INT__POINTER_POINTER_POINTER_POINTER (GtkO GtkSignalFunc func, gpointer func_data, GtkArg *args); +void e_marshal_NONE__POINTER_INT_INT_INT (GtkObject *object, + GtkSignalFunc func, + gpointer func_data, + GtkArg *args); +void e_marshal_INT__OBJECT_POINTER (GtkObject *object, + GtkSignalFunc func, + gpointer func_data, + GtkArg *args); -void e_marshal_NONE__POINTER_INT_INT_INT (GtkObject *object, - GtkSignalFunc func, - gpointer func_data, - GtkArg *args); #ifdef __cplusplus } -- cgit v1.2.3