callisto-debian/evolution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

CVS move mistake. Fixed the correct changes in the correct places.

Browse Source 
2000-04-08  Christopher James Lahey  <clahey@helixcode.com>

	* addressbook/gui/minicard/.cvsignore,
	addressbook/gui/minicard/Makefile.am,
	addressbook/gui/minicard/e-minicard-view.c,
	addressbook/gui/minicard/e-minicard-view.h,
	addressbook/gui/minicard/e-minicard.c,
	addressbook/gui/minicard/e-minicard.h,
	addressbook/gui/minicard/e-reflow-sorted.c,
	addressbook/gui/minicard/e-reflow-sorted.h,
	addressbook/gui/minicard/e-reflow.c,
	addressbook/gui/minicard/e-reflow.h,
	addressbook/gui/minicard/test-minicard-view.c,
	addressbook/gui/minicard/test-reflow.c,
	widgets/e-minicard/.cvsignore, widgets/e-minicard/Makefile.am,
	widgets/e-minicard/e-minicard-label.c,
	widgets/e-minicard/e-minicard-label.h,
	widgets/e-minicard/e-minicard-view.c,
	widgets/e-minicard/e-minicard-view.h,
	widgets/e-minicard/e-minicard.c, widgets/e-minicard/e-minicard.h,
	widgets/e-minicard/e-reflow-sorted.c,
	widgets/e-minicard/e-reflow-sorted.h,
	widgets/e-minicard/e-reflow.c, widgets/e-minicard/e-reflow.h,
	widgets/e-minicard/test-minicard-label.c,
	widgets/e-minicard/test-minicard-view.c,
	widgets/e-minicard/test-minicard.c,
	widgets/e-minicard/test-reflow.c: CVS move mistake.  Fixed the
	correct changes in the correct places.

svn path=/trunk/; revision=2344
This commit is contained in:
Christopher James Lahey
2000-04-08 22:18:26 +00:00
committed by Chris Lahey
parent 58e7df4e03
commit a09c52cdf9
36 changed files with 1178 additions and 2660 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
ChangeLog
View File

@ -1,3 +1,32 @@
2000-04-08 Christopher James Lahey <clahey@helixcode.com>
* addressbook/gui/minicard/.cvsignore,
addressbook/gui/minicard/Makefile.am,
addressbook/gui/minicard/e-minicard-view.c,
addressbook/gui/minicard/e-minicard-view.h,
addressbook/gui/minicard/e-minicard.c,
addressbook/gui/minicard/e-minicard.h,
addressbook/gui/minicard/e-reflow-sorted.c,
addressbook/gui/minicard/e-reflow-sorted.h,
addressbook/gui/minicard/e-reflow.c,
addressbook/gui/minicard/e-reflow.h,
addressbook/gui/minicard/test-minicard-view.c,
addressbook/gui/minicard/test-reflow.c,
widgets/e-minicard/.cvsignore, widgets/e-minicard/Makefile.am,
widgets/e-minicard/e-minicard-label.c,
widgets/e-minicard/e-minicard-label.h,
widgets/e-minicard/e-minicard-view.c,
widgets/e-minicard/e-minicard-view.h,
widgets/e-minicard/e-minicard.c, widgets/e-minicard/e-minicard.h,
widgets/e-minicard/e-reflow-sorted.c,
widgets/e-minicard/e-reflow-sorted.h,
widgets/e-minicard/e-reflow.c, widgets/e-minicard/e-reflow.h,
widgets/e-minicard/test-minicard-label.c,
widgets/e-minicard/test-minicard-view.c,
widgets/e-minicard/test-minicard.c,
widgets/e-minicard/test-reflow.c: CVS move mistake. Fixed the
correct changes in the correct places.
2000-04-08 Christopher James Lahey <clahey@helixcode.com>
* art/Makefile.am: pixmap_DATA isn't defined so don't use it as a variable.

1
addressbook/gui/minicard/.cvsignore
View File

@ -6,4 +6,5 @@ Makefile.in
*.la
minicard-label-test
minicard-test
minicard-view-test
reflow-test

41
addressbook/gui/minicard/Makefile.am
View File

@ -1,7 +1,7 @@
INCLUDES = \
-I$(top_srcdir)/addressbook/backend/ebook \
-I$(top_srcdir)/widgets/e-text \
-I$(top_srcdir)/e-util \
-I$(top_srcdir)/widgets/e-table \
$(GNOME_INCLUDEDIR)
noinst_LIBRARIES = \
@ -12,40 +12,65 @@ libeminicard_a_SOURCES = \
e-minicard.h \
e-minicard-label.c \
e-minicard-label.h \
e-minicard-view.c \
e-minicard-view.h \
e-reflow-sorted.c \
e-reflow-sorted.h \
e-reflow.c \
e-reflow.h
noinst_PROGRAMS = \
minicard-label-test \
minicard-test \
reflow-test
reflow-test \
minicard-view-test
minicard_label_test_SOURCES = \
test-minicard-label.c
minicard_label_test_LDADD = \
$(EXTRA_GNOME_LIBS) \
$(GNOMEGNORBA_LIBS) \
libeminicard.a \
-lbonobo \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/widgets/e-text/libetext.a \
$(top_builddir)/widgets/e-table/libetable.a
$(top_builddir)/widgets/e-text/libetext.a
minicard_test_SOURCES = \
test-minicard.c
minicard_test_LDADD = \
$(EXTRA_GNOME_LIBS) \
$(GNOMEGNORBA_LIBS) \
libeminicard.a \
-lbonobo \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/widgets/e-text/libetext.a \
$(top_builddir)/widgets/e-table/libetable.a
$(top_builddir)/addressbook/backend/ebook/libebook.la \
$(top_builddir)/libversit/libversit.la \
$(top_builddir)/widgets/e-text/libetext.a
reflow_test_SOURCES = \
test-reflow.c
reflow_test_LDADD = \
$(EXTRA_GNOME_LIBS) \
$(GNOMEGNORBA_LIBS) \
libeminicard.a \
-lbonobo \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/widgets/e-text/libetext.a \
$(top_builddir)/widgets/e-table/libetable.a
$(top_builddir)/addressbook/backend/ebook/libebook.la \
$(top_builddir)/libversit/libversit.la \
$(top_builddir)/widgets/e-text/libetext.a
minicard_view_test_SOURCES = \
test-minicard-view.c
minicard_view_test_LDADD = \
$(EXTRA_GNOME_LIBS) \
$(GNOMEGNORBA_LIBS) \
libeminicard.a \
-lbonobo \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/addressbook/backend/ebook/libebook.la \
$(top_builddir)/libversit/libversit.la \
$(top_builddir)/widgets/e-text/libetext.a

0
widgets/e-minicard/e-minicard-view.c → addressbook/gui/minicard/e-minicard-view.c
View File

0
widgets/e-minicard/e-minicard-view.h → addressbook/gui/minicard/e-minicard-view.h
View File

218
addressbook/gui/minicard/e-minicard.c
View File

@ -24,7 +24,7 @@
#include "e-minicard.h"
#include "e-minicard-label.h"
#include "e-text.h"
#include "e-table-text-model.h"
#include "e-book.h"
#include "e-canvas.h"
#include "e-util.h"
#include "e-canvas-utils.h"
@ -49,9 +49,7 @@ enum {
ARG_WIDTH,
ARG_HEIGHT,
ARG_HAS_FOCUS,
ARG_CARD,
ARG_MODEL,
ARG_ROW
ARG_CARD
};
GtkType
@ -98,10 +96,6 @@ e_minicard_class_init (EMinicardClass *klass)
GTK_ARG_READWRITE, ARG_HAS_FOCUS);
gtk_object_add_arg_type ("EMinicard::card", GTK_TYPE_OBJECT,
GTK_ARG_READWRITE, ARG_CARD);
gtk_object_add_arg_type ("EMinicard::model", GTK_TYPE_OBJECT,
GTK_ARG_READWRITE, ARG_MODEL);
gtk_object_add_arg_type ("EMinicard::row", GTK_TYPE_INT,
GTK_ARG_READWRITE, ARG_ROW);
object_class->set_arg = e_minicard_set_arg;
object_class->get_arg = e_minicard_get_arg;
@ -123,8 +117,7 @@ e_minicard_init (EMinicard *minicard)
minicard->height = 10;
minicard->has_focus = FALSE;
minicard->model = NULL;
minicard->row = 0;
minicard->card = NULL;
e_canvas_item_set_reflow_callback(GNOME_CANVAS_ITEM(minicard), e_minicard_reflow);
}
@ -164,21 +157,11 @@ e_minicard_set_arg (GtkObject *o, GtkArg *arg, guint arg_id)
e_canvas_item_grab_focus(item);
break;
case ARG_CARD:
/* e_minicard->card = GTK_VALUE_OBJECT (*arg);
_update_card(e_minicard);
gnome_canvas_item_request_update (item);*/
break;
case ARG_MODEL:
if (e_minicard->model)
gtk_object_unref (e_minicard->model);
e_minicard->model = E_TABLE_MODEL(GTK_VALUE_OBJECT (*arg));
if (e_minicard->model)
gtk_object_ref (e_minicard->model);
remodel(e_minicard);
e_canvas_item_request_reflow(item);
break;
case ARG_ROW:
e_minicard->row = GTK_VALUE_INT (*arg);
if (e_minicard->card)
gtk_object_unref (GTK_OBJECT(e_minicard->card));
e_minicard->card = E_CARD(GTK_VALUE_OBJECT (*arg));
if (e_minicard->card)
gtk_object_ref (GTK_OBJECT(e_minicard->card));
remodel(e_minicard);
e_canvas_item_request_reflow(item);
break;
@ -203,13 +186,7 @@ e_minicard_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
GTK_VALUE_ENUM (*arg) = e_minicard->has_focus ? E_FOCUS_CURRENT : E_FOCUS_NONE;
break;
case ARG_CARD:
/* GTK_VALUE_OBJECT (*arg) = e_minicard->card; */
break;
case ARG_MODEL:
GTK_VALUE_OBJECT (*arg) = GTK_OBJECT(e_minicard->model);
break;
case ARG_ROW:
GTK_VALUE_INT (*arg) = e_minicard->row;
GTK_VALUE_OBJECT (*arg) = GTK_OBJECT(e_minicard->card);
break;
default:
arg->type = GTK_TYPE_INVALID;
@ -227,8 +204,8 @@ e_minicard_destroy (GtkObject *object)
e_minicard = E_MINICARD (object);
if (e_minicard->model)
gtk_object_unref (e_minicard->model);
if (e_minicard->card)
gtk_object_unref (GTK_OBJECT(e_minicard->card));
if (GTK_OBJECT_CLASS (parent_class)->destroy)
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
@ -239,7 +216,6 @@ e_minicard_realize (GnomeCanvasItem *item)
{
EMinicard *e_minicard;
GnomeCanvasGroup *group;
GnomeCanvasItem *new_item;
e_minicard = E_MINICARD (item);
group = GNOME_CANVAS_GROUP( item );
@ -276,46 +252,10 @@ e_minicard_realize (GnomeCanvasItem *item)
"use_ellipsis", TRUE,
"font", "lucidasans-bold-10",
"fill_color", "black",
"text", "Chris Lahey",
"text", "",
NULL );
e_canvas_item_move_absolute(e_minicard->header_text, 6, 6);
new_item = e_minicard_label_new(group);
gnome_canvas_item_set( new_item,
"width", e_minicard->width - 4.0,
"fieldname", "Email:",
"field", "clahey@address.com",
NULL );
e_minicard->fields = g_list_append( e_minicard->fields, new_item);
e_canvas_item_move_absolute(new_item, 2, e_minicard->height);
new_item = e_minicard_label_new(group);
gnome_canvas_item_set( new_item,
"width", e_minicard->width - 4,
"fieldname", "Full Name:",
"field", "Christopher James Lahey",
NULL );
e_minicard->fields = g_list_append( e_minicard->fields, new_item);
e_canvas_item_move_absolute(new_item, 2, e_minicard->height);
new_item = e_minicard_label_new(group);
gnome_canvas_item_set( new_item,
"width", e_minicard->width - 4,
"fieldname", "Street Address:",
"field", "100 Main St\nHome town, USA",
NULL );
e_minicard->fields = g_list_append( e_minicard->fields, new_item);
e_canvas_item_move_absolute(new_item, 2, e_minicard->height);
new_item = e_minicard_label_new(group);
gnome_canvas_item_set( new_item,
"width", e_minicard->width - 4,
"fieldname", "Phone:",
"field", "000-0000",
NULL );
e_minicard->fields = g_list_append( e_minicard->fields, new_item);
e_canvas_item_move_absolute(new_item, 2, e_minicard->height);
remodel(e_minicard);
e_canvas_item_request_reflow(item);
@ -439,31 +379,92 @@ e_minicard_resize_children( EMinicard *e_minicard )
}
static void
remodel( EMinicard *e_minicard )
add_field (EMinicard *e_minicard, char *fieldname, char* field)
{
GnomeCanvasItem *new_item;
GnomeCanvasGroup *group;
group = GNOME_CANVAS_GROUP( e_minicard );
if ( e_minicard->model ) {
gint column = 0;
GList *list = e_minicard->fields;
ETableTextModel *model;
for ( ; list; list = list->next, column++ ) {
ETableTextModel *model = e_table_text_model_new(e_minicard->model, e_minicard->row, column);
gnome_canvas_item_set(GNOME_CANVAS_ITEM(list->data),
"text_model", model,
NULL);
gtk_object_sink(GTK_OBJECT(model));
}
if ( e_minicard->header_text ) {
model = e_table_text_model_new(e_minicard->model, e_minicard->row, 1);
gnome_canvas_item_set(GNOME_CANVAS_ITEM(e_minicard->header_text),
"model", model,
NULL);
gtk_object_sink(GTK_OBJECT(model));
}
new_item = e_minicard_label_new(group);
gnome_canvas_item_set( new_item,
"width", e_minicard->width - 4.0,
"fieldname", fieldname,
"field", field,
NULL );
e_minicard->fields = g_list_append( e_minicard->fields, new_item);
e_canvas_item_move_absolute(new_item, 2, e_minicard->height);
}
static void
remodel( EMinicard *e_minicard )
{
if (e_minicard->card) {
char *fname;
ECardList *address_list;
ECardList *phone_list;
ECardList *email_list;
ECardIterator *iterator;
GList *list;
for ( list = e_minicard->fields; list; list = g_list_next( list ) ) {
gtk_object_destroy( GTK_OBJECT( list->data ) );
}
g_list_free(e_minicard->fields);
e_minicard->fields = NULL;
gtk_object_get(GTK_OBJECT(e_minicard->card),
"full_name", &fname,
"address", &address_list,
"phone", &phone_list,
"email", &email_list,
NULL);
if (fname) {
add_field(e_minicard, "Name:", fname);
if (e_minicard->header_text)
gnome_canvas_item_set(e_minicard->header_text,
"text", fname,
NULL);
} else
if (e_minicard->header_text)
gnome_canvas_item_set(e_minicard->header_text,
"text", "",
NULL);
if (address_list) {
for (iterator = e_card_list_get_iterator(address_list); e_card_iterator_is_valid(iterator); e_card_iterator_next(iterator)) {
const ECardDeliveryAddress *address = e_card_iterator_get(iterator);
if (address->flags & ADDR_WORK) {
add_field(e_minicard, "Work Address:", address->city);
} else if (address->flags & ADDR_HOME) {
add_field(e_minicard, "Home Address:", address->city);
} else {
add_field(e_minicard, "Address:", address->city);
}
}
}
if (phone_list) {
for (iterator = e_card_list_get_iterator(phone_list); e_card_iterator_is_valid(iterator); e_card_iterator_next(iterator)) {
const ECardPhone *phone = e_card_iterator_get(iterator);
if (phone->flags & E_CARD_PHONE_WORK) {
add_field(e_minicard, "Work Phone:", phone->number);
} else if (phone->flags & E_CARD_PHONE_HOME) {
add_field(e_minicard, "Home Phone:", phone->number);
} else if (phone->flags & E_CARD_PHONE_CELL) {
add_field(e_minicard, "Mobile Phone:", phone->number);
} else {
add_field(e_minicard, "Phone:", phone->number);
}
}
}
if (email_list) {
for (iterator = e_card_list_get_iterator(email_list); e_card_iterator_is_valid(iterator); e_card_iterator_next(iterator)) {
add_field(e_minicard, "Email:", (char *) e_card_iterator_get(iterator));
}
}
}
}
@ -513,3 +514,38 @@ e_minicard_reflow( GnomeCanvasItem *item, int flags )
e_canvas_item_request_parent_reflow(item);
}
}
char *
e_minicard_get_card_id (EMinicard *minicard)
{
g_return_val_if_fail(minicard != NULL, NULL);
g_return_val_if_fail(E_IS_MINICARD(minicard), NULL);
if (minicard->card) {
return e_card_get_id(minicard->card);
} else {
return NULL;
}
}
int
e_minicard_compare (EMinicard *minicard1, EMinicard *minicard2)
{
g_return_val_if_fail(minicard1 != NULL, 0);
g_return_val_if_fail(E_IS_MINICARD(minicard1), 0);
g_return_val_if_fail(minicard2 != NULL, 0);
g_return_val_if_fail(E_IS_MINICARD(minicard2), 0);
if (minicard1->card && minicard2->card) {
char *fname1, *fname2;
gtk_object_get(GTK_OBJECT(minicard1->card),
"full_name", &fname1,
NULL);
gtk_object_get(GTK_OBJECT(minicard2->card),
"full_name", &fname2,
NULL);
return strcmp(fname1, fname2);
} else {
return 0;
}
}

13
addressbook/gui/minicard/e-minicard.h
View File

@ -22,7 +22,7 @@
#define __E_MINICARD_H__
#include <gnome.h>
#include "e-table-model.h"
#include "e-card.h"
#ifdef __cplusplus
extern "C" {
@ -37,10 +37,6 @@ extern "C" {
* --------------------------------------------------------------------------------
* width double RW width of the card
* height double R height of the card
* model ETableModel RW model to read from
* row int RW ETableModel row to read from
*
* Later:
* card ECard* RW Pointer to the ECard
*/
@ -72,8 +68,7 @@ struct _EMinicard
GnomeCanvasItem *header_text;
GList *fields; /* Of type GnomeCanvasItem. */
ETableModel *model;
int row;
ECard *card;
guint needs_remodeling : 1;
gboolean has_focus;
@ -90,7 +85,9 @@ struct _EMinicardClass
};
GtkType e_minicard_get_type (void);
GtkType e_minicard_get_type (void);
char *e_minicard_get_card_id (EMinicard *minicard);
int e_minicard_compare (EMinicard *minicard1, EMinicard *minicard2);
#ifdef __cplusplus
}

0
widgets/e-minicard/e-reflow-sorted.c → addressbook/gui/minicard/e-reflow-sorted.c
View File

0
widgets/e-minicard/e-reflow-sorted.h → addressbook/gui/minicard/e-reflow-sorted.h
View File

36
addressbook/gui/minicard/e-reflow.c
View File

@ -26,10 +26,11 @@
#include "e-canvas-utils.h"
#include "e-canvas.h"
#include "e-util.h"
static void e_reflow_init (EReflow *card);
static void e_reflow_init (EReflow *reflow);
static void e_reflow_class_init (EReflowClass *klass);
static void e_reflow_set_arg (GtkObject *o, GtkArg *arg, guint arg_id);
static void e_reflow_get_arg (GtkObject *object, GtkArg *arg, guint arg_id);
static void e_reflow_destroy (GtkObject *object);
static gboolean e_reflow_event (GnomeCanvasItem *item, GdkEvent *event);
static void e_reflow_realize (GnomeCanvasItem *item);
static void e_reflow_unrealize (GnomeCanvasItem *item);
@ -38,6 +39,7 @@ static void e_reflow_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
static void e_reflow_update (GnomeCanvasItem *item, double affine[6], ArtSVP *clip_path, gint flags);
static double e_reflow_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item);
static void e_reflow_reflow (GnomeCanvasItem *item, int flags);
static void e_reflow_real_add_item(EReflow *e_reflow, GnomeCanvasItem *item);
static void e_reflow_resize_children (GnomeCanvasItem *item);
@ -97,10 +99,12 @@ e_reflow_class_init (EReflowClass *klass)
GTK_ARG_READABLE, ARG_WIDTH);
gtk_object_add_arg_type ("EReflow::height", GTK_TYPE_DOUBLE,
GTK_ARG_READWRITE, ARG_HEIGHT);
klass->add_item = e_reflow_real_add_item;
object_class->set_arg = e_reflow_set_arg;
object_class->get_arg = e_reflow_get_arg;
/* object_class->destroy = e_reflow_destroy; */
object_class->set_arg = e_reflow_set_arg;
object_class->get_arg = e_reflow_get_arg;
object_class->destroy = e_reflow_destroy;
/* GnomeCanvasItem method overrides */
item_class->event = e_reflow_event;
@ -114,7 +118,6 @@ e_reflow_class_init (EReflowClass *klass)
static void
e_reflow_init (EReflow *reflow)
{
/* reflow->card = NULL;*/
reflow->items = NULL;
reflow->columns = NULL;
reflow->column_width = 150;
@ -180,6 +183,14 @@ e_reflow_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
}
}
static void
e_reflow_destroy (GtkObject *object)
{
EReflow *reflow = E_REFLOW(object);
g_list_free(reflow->items);
}
static void
e_reflow_realize (GnomeCanvasItem *item)
{
@ -228,9 +239,11 @@ e_reflow_unrealize (GnomeCanvasItem *item)
gdk_cursor_destroy (e_reflow->arrow_cursor);
gdk_cursor_destroy (e_reflow->default_cursor);
e_reflow->arrow_cursor = NULL;
e_reflow->default_cursor = NULL;
g_list_free (e_reflow->items);
g_list_free (e_reflow->columns);
e_reflow->columns = NULL;
if (GNOME_CANVAS_ITEM_CLASS(parent_class)->unrealize)
(* GNOME_CANVAS_ITEM_CLASS(parent_class)->unrealize) (item);
@ -428,8 +441,8 @@ e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
return 0;
}
void
e_reflow_add_item(EReflow *e_reflow, GnomeCanvasItem *item)
static void
e_reflow_real_add_item(EReflow *e_reflow, GnomeCanvasItem *item)
{
e_reflow->items = g_list_append(e_reflow->items, item);
if ( GTK_OBJECT_FLAGS( e_reflow ) & GNOME_CANVAS_ITEM_REALIZED ) {
@ -747,3 +760,10 @@ e_reflow_reflow( GnomeCanvasItem *item, int flags )
e_canvas_item_request_parent_reflow(item);
}
}
void
e_reflow_add_item(EReflow *e_reflow, GnomeCanvasItem *item)
{
if (E_REFLOW_CLASS(GTK_OBJECT(e_reflow)->klass)->add_item)
(E_REFLOW_CLASS(GTK_OBJECT(e_reflow)->klass)->add_item) (e_reflow, item);
}

16
addressbook/gui/minicard/e-reflow.h
View File

@ -54,10 +54,8 @@ struct _EReflow
GnomeCanvasGroup parent;
/* item specific fields */
/* EBook *book; */
GList *items; /* Of type GnomeCanvasItem */
GList *columns; /* Of type GList pointing to type GnomeCanvasItem (points into items) */
GList *columns; /* Of type GList of type GnomeCanvasItem (points into items) */
gint column_count; /* Number of columnns */
double minimum_width;
@ -87,12 +85,16 @@ struct _EReflowClass
{
GnomeCanvasGroupClass parent_class;
void (* resize) (EReflow *reflow);
/* Virtual methods. */
void (* add_item) (EReflow *reflow, GnomeCanvasItem *item);
};
/* To be added to a reflow, an item must have the arguments "x", "y",
and "width" as Read/Write arguments and "height" as a Read Only
argument. It must also have a "resize" signal. */
/*
* To be added to a reflow, an item must have the argument "width" as
* a Read/Write argument and "height" as a Read Only argument. It
* should also do an ECanvas parent reflow request if its size
* changes.
*/
void e_reflow_add_item(EReflow *e_reflow, GnomeCanvasItem *item);
GtkType e_reflow_get_type (void);

0
widgets/e-minicard/test-minicard-view.c → addressbook/gui/minicard/test-minicard-view.c
View File

28
addressbook/gui/minicard/test-reflow.c
View File

@ -16,6 +16,32 @@
*/
#define TEST_VCARD \
"BEGIN:VCARD
" \
"FN:Nat
" \
"N:Friedman;Nat;D;Mr.
" \
"BDAY:1977-08-06
" \
"TEL;WORK:617 679 1984
" \
"TEL;CELL:123 456 7890
" \
"EMAIL;INTERNET:nat@nat.org
" \
"EMAIL;INTERNET:nat@helixcode.com
" \
"ADR;WORK;POSTAL:P.O. Box 101;;;Any Town;CA;91921-1234;
" \
"ADR;HOME;POSTAL;INTL:P.O. Box 202;;;Any Town 2;MI;12344-4321;USA
" \
"END:VCARD
" \
"
"
#include "config.h"
@ -127,8 +153,10 @@ int main( int argc, char *argv[] )
for ( i = 0; i < 200; i++ )
{
GnomeCanvasItem *item;
ECard *card = e_card_new (TEST_VCARD);
item = gnome_canvas_item_new( GNOME_CANVAS_GROUP(reflow),
e_minicard_get_type(),
"card", card,
NULL);
e_reflow_add_item(E_REFLOW(reflow), item);
}

41
addressbook/gui/widgets/Makefile.am
View File

@ -1,7 +1,7 @@
INCLUDES = \
-I$(top_srcdir)/addressbook/backend/ebook \
-I$(top_srcdir)/widgets/e-text \
-I$(top_srcdir)/e-util \
-I$(top_srcdir)/widgets/e-table \
$(GNOME_INCLUDEDIR)
noinst_LIBRARIES = \
@ -12,40 +12,65 @@ libeminicard_a_SOURCES = \
e-minicard.h \
e-minicard-label.c \
e-minicard-label.h \
e-minicard-view.c \
e-minicard-view.h \
e-reflow-sorted.c \
e-reflow-sorted.h \
e-reflow.c \
e-reflow.h
noinst_PROGRAMS = \
minicard-label-test \
minicard-test \
reflow-test
reflow-test \
minicard-view-test
minicard_label_test_SOURCES = \
test-minicard-label.c
minicard_label_test_LDADD = \
$(EXTRA_GNOME_LIBS) \
$(GNOMEGNORBA_LIBS) \
libeminicard.a \
-lbonobo \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/widgets/e-text/libetext.a \
$(top_builddir)/widgets/e-table/libetable.a
$(top_builddir)/widgets/e-text/libetext.a
minicard_test_SOURCES = \
test-minicard.c
minicard_test_LDADD = \
$(EXTRA_GNOME_LIBS) \
$(GNOMEGNORBA_LIBS) \
libeminicard.a \
-lbonobo \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/widgets/e-text/libetext.a \
$(top_builddir)/widgets/e-table/libetable.a
$(top_builddir)/addressbook/backend/ebook/libebook.la \
$(top_builddir)/libversit/libversit.la \
$(top_builddir)/widgets/e-text/libetext.a
reflow_test_SOURCES = \
test-reflow.c
reflow_test_LDADD = \
$(EXTRA_GNOME_LIBS) \
$(GNOMEGNORBA_LIBS) \
libeminicard.a \
-lbonobo \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/widgets/e-text/libetext.a \
$(top_builddir)/widgets/e-table/libetable.a
$(top_builddir)/addressbook/backend/ebook/libebook.la \
$(top_builddir)/libversit/libversit.la \
$(top_builddir)/widgets/e-text/libetext.a
minicard_view_test_SOURCES = \
test-minicard-view.c
minicard_view_test_LDADD = \
$(EXTRA_GNOME_LIBS) \
$(GNOMEGNORBA_LIBS) \
libeminicard.a \
-lbonobo \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/addressbook/backend/ebook/libebook.la \
$(top_builddir)/libversit/libversit.la \
$(top_builddir)/widgets/e-text/libetext.a

239
addressbook/gui/widgets/e-minicard-view.c Normal file
View File

@ -0,0 +1,239 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* e-minicard-view.c
* Copyright (C) 2000 Helix Code, Inc.
* Author: Chris Lahey <clahey@helixcode.com>
*
* This library 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 library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <config.h>
#include <gnome.h>
#include "e-minicard-view.h"
#include "e-minicard.h"
static void e_minicard_view_init (EMinicardView *reflow);
static void e_minicard_view_class_init (EMinicardViewClass *klass);
static void e_minicard_view_set_arg (GtkObject *o, GtkArg *arg, guint arg_id);
static void e_minicard_view_get_arg (GtkObject *object, GtkArg *arg, guint arg_id);
static void e_minicard_view_destroy (GtkObject *object);
#define E_MINICARD_VIEW_DIVIDER_WIDTH 2
#define E_MINICARD_VIEW_BORDER_WIDTH 7
#define E_MINICARD_VIEW_FULL_GUTTER (E_MINICARD_VIEW_DIVIDER_WIDTH + E_MINICARD_VIEW_BORDER_WIDTH * 2)
static EReflowSortedClass *parent_class = NULL;
/* The arguments we take */
enum {
ARG_0,
ARG_BOOK
};
GtkType
e_minicard_view_get_type (void)
{
static GtkType reflow_type = 0;
if (!reflow_type)
{
static const GtkTypeInfo reflow_info =
{
"EMinicardView",
sizeof (EMinicardView),
sizeof (EMinicardViewClass),
(GtkClassInitFunc) e_minicard_view_class_init,
(GtkObjectInitFunc) e_minicard_view_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
reflow_type = gtk_type_unique (e_reflow_sorted_get_type (), &reflow_info);
}
return reflow_type;
}
static void
e_minicard_view_class_init (EMinicardViewClass *klass)
{
GtkObjectClass *object_class;
GnomeCanvasItemClass *item_class;
object_class = (GtkObjectClass*) klass;
item_class = (GnomeCanvasItemClass *) klass;
parent_class = gtk_type_class (e_reflow_sorted_get_type ());
gtk_object_add_arg_type ("EMinicardView::book", GTK_TYPE_OBJECT,
GTK_ARG_READWRITE, ARG_BOOK);
object_class->set_arg = e_minicard_view_set_arg;
object_class->get_arg = e_minicard_view_get_arg;
object_class->destroy = e_minicard_view_destroy;
/* GnomeCanvasItem method overrides */
}
static void
e_minicard_view_init (EMinicardView *view)
{
view->book = NULL;
view->book_view = NULL;
view->get_view_idle = 0;
view->create_card_id = 0;
view->remove_card_id = 0;
view->modify_card_id = 0;
E_REFLOW_SORTED(view)->compare_func = (GCompareFunc) e_minicard_compare;
E_REFLOW_SORTED(view)->string_func = (EReflowStringFunc) e_minicard_get_card_id;
}
static void
create_card(EBookView *book_view, const GList *cards, EMinicardView *view)
{
for (; cards; cards = g_list_next(cards)) {
GnomeCanvasItem *item = gnome_canvas_item_new(GNOME_CANVAS_GROUP(view),
e_minicard_get_type(),
"card", cards->data,
NULL);
e_reflow_add_item(E_REFLOW(view), item);
}
}
static void
modify_card(EBookView *book_view, const GList *cards, EMinicardView *view)
{
for (; cards; cards = g_list_next(cards)) {
GnomeCanvasItem *item = gnome_canvas_item_new(GNOME_CANVAS_GROUP(view),
e_minicard_get_type(),
"card", cards->data,
NULL);
e_reflow_sorted_replace_item(E_REFLOW_SORTED(view), item);
}
}
static void
remove_card(EBookView *book_view, const char *id, EMinicardView *view)
{
e_reflow_sorted_remove_item(E_REFLOW_SORTED(view), id);
}
static void
book_view_loaded (EBook *book, EBookStatus status, EBookView *book_view, gpointer closure)
{
EMinicardView *view = closure;
if (view->book_view && view->create_card_id)
gtk_signal_disconnect(GTK_OBJECT (view->book_view),
view->create_card_id);
if (view->book_view && view->remove_card_id)
gtk_signal_disconnect(GTK_OBJECT (view->book_view),
view->remove_card_id);
if (view->book_view && view->modify_card_id)
gtk_signal_disconnect(GTK_OBJECT (view->book_view),
view->modify_card_id);
if (view->book_view)
gtk_object_unref(GTK_OBJECT(view->book_view));
view->book_view = book_view;
if (view->book_view)
gtk_object_ref(GTK_OBJECT(view->book_view));
view->create_card_id = gtk_signal_connect(GTK_OBJECT(view->book_view),
"card_added",
GTK_SIGNAL_FUNC(create_card),
view);
view->remove_card_id = gtk_signal_connect(GTK_OBJECT(view->book_view),
"card_removed",
GTK_SIGNAL_FUNC(remove_card),
view);
view->modify_card_id = gtk_signal_connect(GTK_OBJECT(view->book_view),
"card_changed",
GTK_SIGNAL_FUNC(modify_card),
view);
g_list_foreach(E_REFLOW(view)->items, (GFunc) gtk_object_destroy, NULL);
g_list_free(E_REFLOW(view)->items);
}
static gboolean
get_view(EMinicardView *view)
{
E_REFLOW(view)->items = NULL;
e_book_get_book_view(view->book, "", book_view_loaded, view);
view->get_view_idle = 0;
return FALSE;
}
static void
e_minicard_view_set_arg (GtkObject *o, GtkArg *arg, guint arg_id)
{
GnomeCanvasItem *item;
EMinicardView *view;
item = GNOME_CANVAS_ITEM (o);
view = E_MINICARD_VIEW (o);
switch (arg_id){
case ARG_BOOK:
if (view->book)
gtk_object_unref(GTK_OBJECT(view->book));
view->book = E_BOOK(GTK_VALUE_OBJECT (*arg));
if (view->book) {
gtk_object_ref(GTK_OBJECT(view->book));
if (view->get_view_idle == 0)
g_idle_add((GSourceFunc)get_view, view);
}
break;
}
}
static void
e_minicard_view_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
EMinicardView *e_minicard_view;
e_minicard_view = E_MINICARD_VIEW (object);
switch (arg_id) {
case ARG_BOOK:
GTK_VALUE_OBJECT (*arg) = GTK_OBJECT(e_minicard_view->book);
break;
default:
arg->type = GTK_TYPE_INVALID;
break;
}
}
static void
e_minicard_view_destroy (GtkObject *object)
{
EMinicardView *view = E_MINICARD_VIEW(object);
if (view->get_view_idle)
g_source_remove(view->get_view_idle);
if (view->book)
gtk_object_unref(GTK_OBJECT(view->book));
if (view->book_view && view->create_card_id)
gtk_signal_disconnect(GTK_OBJECT (view->book_view),
view->create_card_id);
if (view->book_view && view->remove_card_id)
gtk_signal_disconnect(GTK_OBJECT (view->book_view),
view->remove_card_id);
if (view->book_view && view->modify_card_id)
gtk_signal_disconnect(GTK_OBJECT (view->book_view),
view->modify_card_id);
if (view->book_view)
gtk_object_unref(GTK_OBJECT(view->book_view));
}

79
addressbook/gui/widgets/e-minicard-view.h Normal file
View File

@ -0,0 +1,79 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* e-minicard-view.h
* Copyright (C) 2000 Helix Code, Inc.
* Author: Chris Lahey <clahey@helixcode.com>
*
* This library 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 library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __E_MINICARD_VIEW_H__
#define __E_MINICARD_VIEW_H__
#include <gnome.h>
#include "e-reflow-sorted.h"
#include "e-book.h"
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus */
/* EMinicardView - A canvas item container.
*
* The following arguments are available:
*
* name type read/write description
* --------------------------------------------------------------------------------
* minimum_width double RW minimum width of the reflow. width >= minimum_width
* width double R width of the reflow
* height double RW height of the reflow
*/
#define E_MINICARD_VIEW_TYPE (e_minicard_view_get_type ())
#define E_MINICARD_VIEW(obj) (GTK_CHECK_CAST ((obj), E_MINICARD_VIEW_TYPE, EMinicardView))
#define E_MINICARD_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), E_MINICARD_VIEW_TYPE, EMinicardViewClass))
#define E_IS_MINICARD_VIEW(obj) (GTK_CHECK_TYPE ((obj), E_MINICARD_VIEW_TYPE))
#define E_IS_MINICARD_VIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((obj), E_MINICARD_VIEW_TYPE))
typedef struct _EMinicardView EMinicardView;
typedef struct _EMinicardViewClass EMinicardViewClass;
struct _EMinicardView
{
EReflowSorted parent;
/* item specific fields */
EBook *book;
EBookView *book_view;
int get_view_idle;
int create_card_id, remove_card_id, modify_card_id;
};
struct _EMinicardViewClass
{
EReflowSortedClass parent_class;
};
GtkType e_minicard_view_get_type (void);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __E_MINICARD_VIEW_H__ */

218
addressbook/gui/widgets/e-minicard.c
View File

@ -24,7 +24,7 @@
#include "e-minicard.h"
#include "e-minicard-label.h"
#include "e-text.h"
#include "e-table-text-model.h"
#include "e-book.h"
#include "e-canvas.h"
#include "e-util.h"
#include "e-canvas-utils.h"
@ -49,9 +49,7 @@ enum {
ARG_WIDTH,
ARG_HEIGHT,
ARG_HAS_FOCUS,
ARG_CARD,
ARG_MODEL,
ARG_ROW
ARG_CARD
};
GtkType
@ -98,10 +96,6 @@ e_minicard_class_init (EMinicardClass *klass)
GTK_ARG_READWRITE, ARG_HAS_FOCUS);
gtk_object_add_arg_type ("EMinicard::card", GTK_TYPE_OBJECT,
GTK_ARG_READWRITE, ARG_CARD);
gtk_object_add_arg_type ("EMinicard::model", GTK_TYPE_OBJECT,
GTK_ARG_READWRITE, ARG_MODEL);
gtk_object_add_arg_type ("EMinicard::row", GTK_TYPE_INT,
GTK_ARG_READWRITE, ARG_ROW);
object_class->set_arg = e_minicard_set_arg;
object_class->get_arg = e_minicard_get_arg;
@ -123,8 +117,7 @@ e_minicard_init (EMinicard *minicard)
minicard->height = 10;
minicard->has_focus = FALSE;
minicard->model = NULL;
minicard->row = 0;
minicard->card = NULL;
e_canvas_item_set_reflow_callback(GNOME_CANVAS_ITEM(minicard), e_minicard_reflow);
}
@ -164,21 +157,11 @@ e_minicard_set_arg (GtkObject *o, GtkArg *arg, guint arg_id)
e_canvas_item_grab_focus(item);
break;
case ARG_CARD:
/* e_minicard->card = GTK_VALUE_OBJECT (*arg);
_update_card(e_minicard);
gnome_canvas_item_request_update (item);*/
break;
case ARG_MODEL:
if (e_minicard->model)
gtk_object_unref (e_minicard->model);
e_minicard->model = E_TABLE_MODEL(GTK_VALUE_OBJECT (*arg));
if (e_minicard->model)
gtk_object_ref (e_minicard->model);
remodel(e_minicard);
e_canvas_item_request_reflow(item);
break;
case ARG_ROW:
e_minicard->row = GTK_VALUE_INT (*arg);
if (e_minicard->card)
gtk_object_unref (GTK_OBJECT(e_minicard->card));
e_minicard->card = E_CARD(GTK_VALUE_OBJECT (*arg));
if (e_minicard->card)
gtk_object_ref (GTK_OBJECT(e_minicard->card));
remodel(e_minicard);
e_canvas_item_request_reflow(item);
break;
@ -203,13 +186,7 @@ e_minicard_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
GTK_VALUE_ENUM (*arg) = e_minicard->has_focus ? E_FOCUS_CURRENT : E_FOCUS_NONE;
break;
case ARG_CARD:
/* GTK_VALUE_OBJECT (*arg) = e_minicard->card; */
break;
case ARG_MODEL:
GTK_VALUE_OBJECT (*arg) = GTK_OBJECT(e_minicard->model);
break;
case ARG_ROW:
GTK_VALUE_INT (*arg) = e_minicard->row;
GTK_VALUE_OBJECT (*arg) = GTK_OBJECT(e_minicard->card);
break;
default:
arg->type = GTK_TYPE_INVALID;
@ -227,8 +204,8 @@ e_minicard_destroy (GtkObject *object)
e_minicard = E_MINICARD (object);
if (e_minicard->model)
gtk_object_unref (e_minicard->model);
if (e_minicard->card)
gtk_object_unref (GTK_OBJECT(e_minicard->card));
if (GTK_OBJECT_CLASS (parent_class)->destroy)
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
@ -239,7 +216,6 @@ e_minicard_realize (GnomeCanvasItem *item)
{
EMinicard *e_minicard;
GnomeCanvasGroup *group;
GnomeCanvasItem *new_item;
e_minicard = E_MINICARD (item);
group = GNOME_CANVAS_GROUP( item );
@ -276,46 +252,10 @@ e_minicard_realize (GnomeCanvasItem *item)
"use_ellipsis", TRUE,
"font", "lucidasans-bold-10",
"fill_color", "black",
"text", "Chris Lahey",
"text", "",
NULL );
e_canvas_item_move_absolute(e_minicard->header_text, 6, 6);
new_item = e_minicard_label_new(group);
gnome_canvas_item_set( new_item,
"width", e_minicard->width - 4.0,
"fieldname", "Email:",
"field", "clahey@address.com",
NULL );
e_minicard->fields = g_list_append( e_minicard->fields, new_item);
e_canvas_item_move_absolute(new_item, 2, e_minicard->height);
new_item = e_minicard_label_new(group);
gnome_canvas_item_set( new_item,
"width", e_minicard->width - 4,
"fieldname", "Full Name:",
"field", "Christopher James Lahey",
NULL );
e_minicard->fields = g_list_append( e_minicard->fields, new_item);
e_canvas_item_move_absolute(new_item, 2, e_minicard->height);
new_item = e_minicard_label_new(group);
gnome_canvas_item_set( new_item,
"width", e_minicard->width - 4,
"fieldname", "Street Address:",
"field", "100 Main St\nHome town, USA",
NULL );
e_minicard->fields = g_list_append( e_minicard->fields, new_item);
e_canvas_item_move_absolute(new_item, 2, e_minicard->height);
new_item = e_minicard_label_new(group);
gnome_canvas_item_set( new_item,
"width", e_minicard->width - 4,
"fieldname", "Phone:",
"field", "000-0000",
NULL );
e_minicard->fields = g_list_append( e_minicard->fields, new_item);
e_canvas_item_move_absolute(new_item, 2, e_minicard->height);
remodel(e_minicard);
e_canvas_item_request_reflow(item);
@ -439,31 +379,92 @@ e_minicard_resize_children( EMinicard *e_minicard )
}
static void
remodel( EMinicard *e_minicard )
add_field (EMinicard *e_minicard, char *fieldname, char* field)
{
GnomeCanvasItem *new_item;
GnomeCanvasGroup *group;
group = GNOME_CANVAS_GROUP( e_minicard );
if ( e_minicard->model ) {
gint column = 0;
GList *list = e_minicard->fields;
ETableTextModel *model;
for ( ; list; list = list->next, column++ ) {
ETableTextModel *model = e_table_text_model_new(e_minicard->model, e_minicard->row, column);
gnome_canvas_item_set(GNOME_CANVAS_ITEM(list->data),
"text_model", model,
NULL);
gtk_object_sink(GTK_OBJECT(model));
}
if ( e_minicard->header_text ) {
model = e_table_text_model_new(e_minicard->model, e_minicard->row, 1);
gnome_canvas_item_set(GNOME_CANVAS_ITEM(e_minicard->header_text),
"model", model,
NULL);
gtk_object_sink(GTK_OBJECT(model));
}
new_item = e_minicard_label_new(group);
gnome_canvas_item_set( new_item,
"width", e_minicard->width - 4.0,
"fieldname", fieldname,
"field", field,
NULL );
e_minicard->fields = g_list_append( e_minicard->fields, new_item);
e_canvas_item_move_absolute(new_item, 2, e_minicard->height);
}
static void
remodel( EMinicard *e_minicard )
{
if (e_minicard->card) {
char *fname;
ECardList *address_list;
ECardList *phone_list;
ECardList *email_list;
ECardIterator *iterator;
GList *list;
for ( list = e_minicard->fields; list; list = g_list_next( list ) ) {
gtk_object_destroy( GTK_OBJECT( list->data ) );
}
g_list_free(e_minicard->fields);
e_minicard->fields = NULL;
gtk_object_get(GTK_OBJECT(e_minicard->card),
"full_name", &fname,
"address", &address_list,
"phone", &phone_list,
"email", &email_list,
NULL);
if (fname) {
add_field(e_minicard, "Name:", fname);
if (e_minicard->header_text)
gnome_canvas_item_set(e_minicard->header_text,
"text", fname,
NULL);
} else
if (e_minicard->header_text)
gnome_canvas_item_set(e_minicard->header_text,
"text", "",
NULL);
if (address_list) {
for (iterator = e_card_list_get_iterator(address_list); e_card_iterator_is_valid(iterator); e_card_iterator_next(iterator)) {
const ECardDeliveryAddress *address = e_card_iterator_get(iterator);
if (address->flags & ADDR_WORK) {
add_field(e_minicard, "Work Address:", address->city);
} else if (address->flags & ADDR_HOME) {
add_field(e_minicard, "Home Address:", address->city);
} else {
add_field(e_minicard, "Address:", address->city);
}
}
}
if (phone_list) {
for (iterator = e_card_list_get_iterator(phone_list); e_card_iterator_is_valid(iterator); e_card_iterator_next(iterator)) {
const ECardPhone *phone = e_card_iterator_get(iterator);
if (phone->flags & E_CARD_PHONE_WORK) {
add_field(e_minicard, "Work Phone:", phone->number);
} else if (phone->flags & E_CARD_PHONE_HOME) {
add_field(e_minicard, "Home Phone:", phone->number);
} else if (phone->flags & E_CARD_PHONE_CELL) {
add_field(e_minicard, "Mobile Phone:", phone->number);
} else {
add_field(e_minicard, "Phone:", phone->number);
}
}
}
if (email_list) {
for (iterator = e_card_list_get_iterator(email_list); e_card_iterator_is_valid(iterator); e_card_iterator_next(iterator)) {
add_field(e_minicard, "Email:", (char *) e_card_iterator_get(iterator));
}
}
}
}
@ -513,3 +514,38 @@ e_minicard_reflow( GnomeCanvasItem *item, int flags )
e_canvas_item_request_parent_reflow(item);
}
}
char *
e_minicard_get_card_id (EMinicard *minicard)
{
g_return_val_if_fail(minicard != NULL, NULL);
g_return_val_if_fail(E_IS_MINICARD(minicard), NULL);
if (minicard->card) {
return e_card_get_id(minicard->card);
} else {
return NULL;
}
}
int
e_minicard_compare (EMinicard *minicard1, EMinicard *minicard2)
{
g_return_val_if_fail(minicard1 != NULL, 0);
g_return_val_if_fail(E_IS_MINICARD(minicard1), 0);
g_return_val_if_fail(minicard2 != NULL, 0);
g_return_val_if_fail(E_IS_MINICARD(minicard2), 0);
if (minicard1->card && minicard2->card) {
char *fname1, *fname2;
gtk_object_get(GTK_OBJECT(minicard1->card),
"full_name", &fname1,
NULL);
gtk_object_get(GTK_OBJECT(minicard2->card),
"full_name", &fname2,
NULL);
return strcmp(fname1, fname2);
} else {
return 0;
}
}

13
addressbook/gui/widgets/e-minicard.h
View File

@ -22,7 +22,7 @@
#define __E_MINICARD_H__
#include <gnome.h>
#include "e-table-model.h"
#include "e-card.h"
#ifdef __cplusplus
extern "C" {
@ -37,10 +37,6 @@ extern "C" {
* --------------------------------------------------------------------------------
* width double RW width of the card
* height double R height of the card
* model ETableModel RW model to read from
* row int RW ETableModel row to read from
*
* Later:
* card ECard* RW Pointer to the ECard
*/
@ -72,8 +68,7 @@ struct _EMinicard
GnomeCanvasItem *header_text;
GList *fields; /* Of type GnomeCanvasItem. */
ETableModel *model;
int row;
ECard *card;
guint needs_remodeling : 1;
gboolean has_focus;
@ -90,7 +85,9 @@ struct _EMinicardClass
};
GtkType e_minicard_get_type (void);
GtkType e_minicard_get_type (void);
char *e_minicard_get_card_id (EMinicard *minicard);
int e_minicard_compare (EMinicard *minicard1, EMinicard *minicard2);
#ifdef __cplusplus
}

107
widgets/e-minicard/test-reflow.c → addressbook/gui/widgets/test-minicard-view.c
View File

@ -15,46 +15,37 @@
* GNU General Public License for more details.
*/
#define TEST_VCARD \
"BEGIN:VCARD
" \
"FN:Nat
" \
"N:Friedman;Nat;D;Mr.
" \
"BDAY:1977-08-06
" \
"TEL;WORK:617 679 1984
" \
"TEL;CELL:123 456 7890
" \
"EMAIL;INTERNET:nat@nat.org
" \
"EMAIL;INTERNET:nat@helixcode.com
" \
"ADR;WORK;POSTAL:P.O. Box 101;;;Any Town;CA;91921-1234;
" \
"ADR;HOME;POSTAL;INTL:P.O. Box 202;;;Any Town 2;MI;12344-4321;USA
" \
"END:VCARD
" \
"
"
#include "config.h"
#include <gnome.h>
#include <libgnorba/gnorba.h>
#include <bonobo.h>
#include "e-canvas.h"
#include "e-reflow.h"
#include "e-minicard.h"
#include "e-minicard-view.h"
/* This is a horrible thing to do, but it is just a test. */
GnomeCanvasItem *reflow;
GnomeCanvasItem *rect;
GtkAllocation last_alloc;
CORBA_Environment ev;
CORBA_ORB orb;
static void
init_bonobo (int argc, char **argv)
{
gnome_CORBA_init_with_popt_table (
"Reflow Test", VERSION,
&argc, argv, NULL, 0, NULL, GNORBA_INIT_SERVER_FUNC, &ev);
orb = gnome_CORBA_ORB ();
if (bonobo_init (orb, NULL, NULL) == FALSE)
g_error (_("Could not initialize Bonobo"));
}
static void destroy_callback(GtkWidget *app, gpointer data)
{
exit(0);
@ -115,18 +106,51 @@ static void about_callback( GtkWidget *widget, gpointer data )
}
#endif
static void
book_open_cb (EBook *book, EBookStatus status, gpointer closure)
{
if (status == E_BOOK_STATUS_SUCCESS)
gnome_canvas_item_set(reflow,
"book", book,
NULL);
}
static guint
ebook_create (void)
{
EBook *book;
book = e_book_new ();
if (!book) {
printf ("%s: %s(): Couldn't create EBook, bailing.\n",
__FILE__,
__FUNCTION__);
return FALSE;
}
if (! e_book_load_uri (book, "file:/tmp/test.db", book_open_cb, NULL)) {
printf ("error calling load_uri!\n");
}
return FALSE;
}
int main( int argc, char *argv[] )
{
GtkWidget *app;
GtkWidget *canvas;
GtkWidget *vbox;
GtkWidget *scrollbar;
int i;
/* bindtextdomain (PACKAGE, GNOMELOCALEDIR);
textdomain (PACKAGE);*/
gnome_init( "Reflow Test", VERSION, argc, argv);
CORBA_exception_init (&ev);
init_bonobo (argc, argv);
app = gnome_app_new("Reflow Test", NULL);
vbox = gtk_vbox_new(FALSE, 0);
@ -141,25 +165,14 @@ int main( int argc, char *argv[] )
"fill_color", "white",
NULL );
reflow = gnome_canvas_item_new( gnome_canvas_root( GNOME_CANVAS( canvas ) ),
e_reflow_get_type(),
"x", (double) 0,
"y", (double) 0,
e_minicard_view_get_type(),
"height", (double) 100,
"minimum_width", (double) 100,
NULL );
gtk_signal_connect( GTK_OBJECT( canvas ), "reflow",
GTK_SIGNAL_FUNC( resize ),
( gpointer ) app);
for ( i = 0; i < 200; i++ )
{
GnomeCanvasItem *item;
ECard *card = e_card_new (TEST_VCARD);
item = gnome_canvas_item_new( GNOME_CANVAS_GROUP(reflow),
e_minicard_get_type(),
"card", card,
NULL);
e_reflow_add_item(E_REFLOW(reflow), item);
}
gnome_canvas_set_scroll_region ( GNOME_CANVAS( canvas ),
0, 0,
100, 100 );
@ -184,7 +197,9 @@ int main( int argc, char *argv[] )
gtk_widget_show_all( app );
gdk_window_set_back_pixmap( GTK_LAYOUT(canvas)->bin_window, NULL, FALSE);
gtk_main();
gtk_idle_add ((GtkFunction) ebook_create, NULL);
bonobo_main ();
/* Not reached. */
return 0;

28
addressbook/gui/widgets/test-reflow.c
View File

@ -16,6 +16,32 @@
*/
#define TEST_VCARD \
"BEGIN:VCARD
" \
"FN:Nat
" \
"N:Friedman;Nat;D;Mr.
" \
"BDAY:1977-08-06
" \
"TEL;WORK:617 679 1984
" \
"TEL;CELL:123 456 7890
" \
"EMAIL;INTERNET:nat@nat.org
" \
"EMAIL;INTERNET:nat@helixcode.com
" \
"ADR;WORK;POSTAL:P.O. Box 101;;;Any Town;CA;91921-1234;
" \
"ADR;HOME;POSTAL;INTL:P.O. Box 202;;;Any Town 2;MI;12344-4321;USA
" \
"END:VCARD
" \
"
"
#include "config.h"
@ -127,8 +153,10 @@ int main( int argc, char *argv[] )
for ( i = 0; i < 200; i++ )
{
GnomeCanvasItem *item;
ECard *card = e_card_new (TEST_VCARD);
item = gnome_canvas_item_new( GNOME_CANVAS_GROUP(reflow),
e_minicard_get_type(),
"card", card,
NULL);
e_reflow_add_item(E_REFLOW(reflow), item);
}

10
widgets/e-minicard/.cvsignore
View File

@ -1,10 +0,0 @@
.deps
.libs
Makefile
Makefile.in
*.lo
*.la
minicard-label-test
minicard-test
minicard-view-test
reflow-test

76
widgets/e-minicard/Makefile.am
View File

@ -1,76 +0,0 @@
INCLUDES = \
-I$(top_srcdir)/addressbook/backend/ebook \
-I$(top_srcdir)/widgets/e-text \
-I$(top_srcdir)/e-util \
$(GNOME_INCLUDEDIR)
noinst_LIBRARIES = \
libeminicard.a
libeminicard_a_SOURCES = \
e-minicard.c \
e-minicard.h \
e-minicard-label.c \
e-minicard-label.h \
e-minicard-view.c \
e-minicard-view.h \
e-reflow-sorted.c \
e-reflow-sorted.h \
e-reflow.c \
e-reflow.h
noinst_PROGRAMS = \
minicard-label-test \
minicard-test \
reflow-test \
minicard-view-test
minicard_label_test_SOURCES = \
test-minicard-label.c
minicard_label_test_LDADD = \
$(EXTRA_GNOME_LIBS) \
$(GNOMEGNORBA_LIBS) \
libeminicard.a \
-lbonobo \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/widgets/e-text/libetext.a
minicard_test_SOURCES = \
test-minicard.c
minicard_test_LDADD = \
$(EXTRA_GNOME_LIBS) \
$(GNOMEGNORBA_LIBS) \
libeminicard.a \
-lbonobo \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/addressbook/backend/ebook/libebook.la \
$(top_builddir)/libversit/libversit.la \
$(top_builddir)/widgets/e-text/libetext.a
reflow_test_SOURCES = \
test-reflow.c
reflow_test_LDADD = \
$(EXTRA_GNOME_LIBS) \
$(GNOMEGNORBA_LIBS) \
libeminicard.a \
-lbonobo \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/addressbook/backend/ebook/libebook.la \
$(top_builddir)/libversit/libversit.la \
$(top_builddir)/widgets/e-text/libetext.a
minicard_view_test_SOURCES = \
test-minicard-view.c
minicard_view_test_LDADD = \
$(EXTRA_GNOME_LIBS) \
$(GNOMEGNORBA_LIBS) \
libeminicard.a \
-lbonobo \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/addressbook/backend/ebook/libebook.la \
$(top_builddir)/libversit/libversit.la \
$(top_builddir)/widgets/e-text/libetext.a

419
widgets/e-minicard/e-minicard-label.c
View File

@ -1,419 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* e-minicard-label.c
* Copyright (C) 2000 Helix Code, Inc.
* Author: Chris Lahey <clahey@helixcode.com>
*
* This library 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 library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <gnome.h>
#include "e-minicard-label.h"
#include "e-text.h"
#include "e-canvas.h"
#include "e-util.h"
#include "e-canvas-utils.h"
static void e_minicard_label_init (EMinicardLabel *card);
static void e_minicard_label_class_init (EMinicardLabelClass *klass);
static void e_minicard_label_set_arg (GtkObject *o, GtkArg *arg, guint arg_id);
static void e_minicard_label_get_arg (GtkObject *object, GtkArg *arg, guint arg_id);
static gboolean e_minicard_label_event (GnomeCanvasItem *item, GdkEvent *event);
static void e_minicard_label_realize (GnomeCanvasItem *item);
static void e_minicard_label_unrealize (GnomeCanvasItem *item);
static void e_minicard_label_reflow(GnomeCanvasItem *item, int flags);
static void e_minicard_label_resize_children( EMinicardLabel *e_minicard_label );
static GnomeCanvasGroupClass *parent_class = NULL;
/* The arguments we take */
enum {
ARG_0,
ARG_WIDTH,
ARG_HEIGHT,
ARG_HAS_FOCUS,
ARG_FIELD,
ARG_FIELDNAME,
ARG_TEXT_MODEL
};
GtkType
e_minicard_label_get_type (void)
{
static GtkType minicard_label_type = 0;
if (!minicard_label_type)
{
static const GtkTypeInfo minicard_label_info =
{
"EMinicardLabel",
sizeof (EMinicardLabel),
sizeof (EMinicardLabelClass),
(GtkClassInitFunc) e_minicard_label_class_init,
(GtkObjectInitFunc) e_minicard_label_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
minicard_label_type = gtk_type_unique (gnome_canvas_group_get_type (), &minicard_label_info);
}
return minicard_label_type;
}
static void
e_minicard_label_class_init (EMinicardLabelClass *klass)
{
GtkObjectClass *object_class;
GnomeCanvasItemClass *item_class;
object_class = (GtkObjectClass*) klass;
item_class = (GnomeCanvasItemClass *) klass;
parent_class = gtk_type_class (gnome_canvas_group_get_type ());
gtk_object_add_arg_type ("EMinicardLabel::width", GTK_TYPE_DOUBLE,
GTK_ARG_READWRITE, ARG_WIDTH);
gtk_object_add_arg_type ("EMinicardLabel::height", GTK_TYPE_DOUBLE,
GTK_ARG_READABLE, ARG_HEIGHT);
gtk_object_add_arg_type ("EMinicardLabel::has_focus", GTK_TYPE_BOOL,
GTK_ARG_READWRITE, ARG_HAS_FOCUS);
gtk_object_add_arg_type ("EMinicardLabel::field", GTK_TYPE_STRING,
GTK_ARG_READWRITE, ARG_FIELD);
gtk_object_add_arg_type ("EMinicardLabel::fieldname", GTK_TYPE_STRING,
GTK_ARG_READWRITE, ARG_FIELDNAME);
gtk_object_add_arg_type ("EMinicardLabel::text_model", GTK_TYPE_OBJECT,
GTK_ARG_READWRITE, ARG_TEXT_MODEL);
object_class->set_arg = e_minicard_label_set_arg;
object_class->get_arg = e_minicard_label_get_arg;
/* object_class->destroy = e_minicard_label_destroy; */
/* GnomeCanvasItem method overrides */
item_class->realize = e_minicard_label_realize;
item_class->unrealize = e_minicard_label_unrealize;
item_class->event = e_minicard_label_event;
}
static void
e_minicard_label_init (EMinicardLabel *minicard_label)
{
minicard_label->width = 10;
minicard_label->height = 10;
minicard_label->rect = NULL;
minicard_label->fieldname = NULL;
minicard_label->field = NULL;
e_canvas_item_set_reflow_callback(GNOME_CANVAS_ITEM(minicard_label), e_minicard_label_reflow);
}
static void
e_minicard_label_set_arg (GtkObject *o, GtkArg *arg, guint arg_id)
{
GnomeCanvasItem *item;
EMinicardLabel *e_minicard_label;
item = GNOME_CANVAS_ITEM (o);
e_minicard_label = E_MINICARD_LABEL (o);
switch (arg_id){
case ARG_WIDTH:
e_minicard_label->width = GTK_VALUE_DOUBLE (*arg);
e_minicard_label_resize_children(e_minicard_label);
e_canvas_item_request_reflow (item);
break;
case ARG_HAS_FOCUS:
if (e_minicard_label->field && (GTK_VALUE_ENUM(*arg) != E_FOCUS_NONE))
e_canvas_item_grab_focus(e_minicard_label->field);
break;
case ARG_FIELD:
gnome_canvas_item_set( e_minicard_label->field, "text", GTK_VALUE_STRING (*arg), NULL );
break;
case ARG_FIELDNAME:
gnome_canvas_item_set( e_minicard_label->fieldname, "text", GTK_VALUE_STRING (*arg), NULL );
break;
case ARG_TEXT_MODEL:
gnome_canvas_item_set( e_minicard_label->field, "model", GTK_VALUE_OBJECT (*arg), NULL);
break;
}
}
static void
e_minicard_label_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
EMinicardLabel *e_minicard_label;
char *temp;
ETextModel *tempmodel;
e_minicard_label = E_MINICARD_LABEL (object);
switch (arg_id) {
case ARG_WIDTH:
GTK_VALUE_DOUBLE (*arg) = e_minicard_label->width;
break;
case ARG_HEIGHT:
GTK_VALUE_DOUBLE (*arg) = e_minicard_label->height;
break;
case ARG_HAS_FOCUS:
GTK_VALUE_ENUM (*arg) = e_minicard_label->has_focus ? E_FOCUS_CURRENT : E_FOCUS_NONE;
break;
case ARG_FIELD:
gtk_object_get( GTK_OBJECT( e_minicard_label->field ), "text", &temp, NULL );
GTK_VALUE_STRING (*arg) = temp;
break;
case ARG_FIELDNAME:
gtk_object_get( GTK_OBJECT( e_minicard_label->fieldname ), "text", &temp, NULL );
GTK_VALUE_STRING (*arg) = temp;
break;
case ARG_TEXT_MODEL:
gtk_object_get( GTK_OBJECT( e_minicard_label->field ), "model", &tempmodel, NULL );
GTK_VALUE_OBJECT (*arg) = GTK_OBJECT(tempmodel);
break;
default:
arg->type = GTK_TYPE_INVALID;
break;
}
}
static void
e_minicard_label_realize (GnomeCanvasItem *item)
{
if (GNOME_CANVAS_ITEM_CLASS( parent_class )->realize)
(* GNOME_CANVAS_ITEM_CLASS( parent_class )->realize) (item);
e_canvas_item_request_reflow(item);
if (!item->canvas->aa)
{
}
}
void
e_minicard_label_construct (GnomeCanvasItem *item)
{
EMinicardLabel *e_minicard_label;
GnomeCanvasGroup *group;
static GdkFont *font = NULL;
if ( font == NULL ) {
font = gdk_font_load("lucidasans-10");
}
e_minicard_label = E_MINICARD_LABEL (item);
group = GNOME_CANVAS_GROUP( item );
e_minicard_label->rect =
gnome_canvas_item_new( group,
gnome_canvas_rect_get_type(),
"x1", (double) 0,
"y1", (double) 0,
"x2", (double) e_minicard_label->width - 1,
"y2", (double) e_minicard_label->height - 1,
"outline_color", NULL,
NULL );
e_minicard_label->fieldname =
gnome_canvas_item_new( group,
e_text_get_type(),
"anchor", GTK_ANCHOR_NW,
"clip_width", (double) ( e_minicard_label->width / 2 - 4 ),
"clip", TRUE,
"use_ellipsis", TRUE,
"font_gdk", font,
"fill_color", "black",
NULL );
e_canvas_item_move_absolute(e_minicard_label->fieldname, 2, 1);
e_minicard_label->field =
gnome_canvas_item_new( group,
e_text_get_type(),
"anchor", GTK_ANCHOR_NW,
"clip_width", (double) ( ( e_minicard_label->width + 1 ) / 2 - 4 ),
"clip", TRUE,
"use_ellipsis", TRUE,
"font_gdk", font,
"fill_color", "black",
"editable", TRUE,
NULL );
e_canvas_item_move_absolute(e_minicard_label->field, ( e_minicard_label->width / 2 + 2), 1);
e_canvas_item_request_reflow(item);
}
static void
e_minicard_label_unrealize (GnomeCanvasItem *item)
{
EMinicardLabel *e_minicard_label;
e_minicard_label = E_MINICARD_LABEL (item);
if (!item->canvas->aa)
{
}
if (GNOME_CANVAS_ITEM_CLASS( parent_class )->unrealize)
(* GNOME_CANVAS_ITEM_CLASS( parent_class )->unrealize) (item);
}
static gboolean
e_minicard_label_event (GnomeCanvasItem *item, GdkEvent *event)
{
EMinicardLabel *e_minicard_label;
e_minicard_label = E_MINICARD_LABEL (item);
switch( event->type )
{
case GDK_FOCUS_CHANGE:
{
GdkEventFocus *focus_event = (GdkEventFocus *) event;
if ( focus_event->in )
{
gnome_canvas_item_set( e_minicard_label->rect,
"outline_color", "grey50",
"fill_color", "grey90",
NULL );
e_minicard_label->has_focus = TRUE;
}
else
{
gnome_canvas_item_set( e_minicard_label->rect,
"outline_color", NULL,
"fill_color", NULL,
NULL );
e_minicard_label->has_focus = FALSE;
}
}
break;
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
case GDK_MOTION_NOTIFY:
case GDK_ENTER_NOTIFY:
case GDK_LEAVE_NOTIFY: {
gboolean return_val;
#if 0
GnomeCanvasItem *field;
ArtPoint p;
double inv[6], affine[6];
field = e_minicard_label->field;
art_affine_identity (affine);
if (field->xform != NULL) {
if (field->object.flags & GNOME_CANVAS_ITEM_AFFINE_FULL) {
art_affine_multiply (affine, affine, field->xform);
} else {
affine[4] += field->xform[0];
affine[5] += field->xform[1];
}
}
art_affine_invert (inv, affine);
switch(event->type) {
case GDK_MOTION_NOTIFY:
p.x = event->motion.x;
p.y = event->motion.y;
art_affine_point (&p, &p, inv);
event->motion.x = p.x;
event->motion.y = p.y;
break;
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
p.x = event->button.x;
p.y = event->button.y;
art_affine_point (&p, &p, inv);
event->button.x = p.x;
event->button.y = p.y;
break;
case GDK_ENTER_NOTIFY:
case GDK_LEAVE_NOTIFY:
p.x = event->crossing.x;
p.y = event->crossing.y;
art_affine_point (&p, &p, inv);
event->crossing.x = p.x;
event->crossing.y = p.y;
break;
default:
break;
}
#endif
gtk_signal_emit_by_name(GTK_OBJECT(e_minicard_label->field), "event", event, &return_val);
return return_val;
break;
}
default:
break;
}
if (GNOME_CANVAS_ITEM_CLASS( parent_class )->event)
return (* GNOME_CANVAS_ITEM_CLASS( parent_class )->event) (item, event);
else
return 0;
}
static void
e_minicard_label_resize_children(EMinicardLabel *e_minicard_label)
{
gnome_canvas_item_set( e_minicard_label->fieldname,
"clip_width", (double) ( e_minicard_label->width / 2 - 4 ),
NULL );
gnome_canvas_item_set( e_minicard_label->field,
"clip_width", (double) ( ( e_minicard_label->width + 1 ) / 2 - 4 ),
NULL );
}
static void
e_minicard_label_reflow(GnomeCanvasItem *item, int flags)
{
EMinicardLabel *e_minicard_label = E_MINICARD_LABEL(item);
gint old_height;
gdouble text_height;
old_height = e_minicard_label->height;
gtk_object_get(GTK_OBJECT(e_minicard_label->fieldname),
"text_height", &text_height,
NULL);
e_minicard_label->height = text_height;
gtk_object_get(GTK_OBJECT(e_minicard_label->field),
"text_height", &text_height,
NULL);
if (e_minicard_label->height < text_height)
e_minicard_label->height = text_height;
e_minicard_label->height += 3;
gnome_canvas_item_set( e_minicard_label->rect,
"x2", (double) e_minicard_label->width - 1,
"y2", (double) e_minicard_label->height - 1,
NULL );
e_canvas_item_move_absolute(e_minicard_label->field, ( e_minicard_label->width / 2 + 2), 1);
if (old_height != e_minicard_label->height)
e_canvas_item_request_parent_reflow(item);
}
GnomeCanvasItem *
e_minicard_label_new(GnomeCanvasGroup *parent)
{
GnomeCanvasItem *item = gnome_canvas_item_new(parent, e_minicard_label_get_type(), NULL);
e_minicard_label_construct(item);
return item;
}

82
widgets/e-minicard/e-minicard-label.h
View File

@ -1,82 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* e-minicard-label.h
* Copyright (C) 2000 Helix Code, Inc.
* Author: Chris Lahey <clahey@helixcode.com>
*
* This library 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 library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __E_MINICARD_LABEL_H__
#define __E_MINICARD_LABEL_H__
#include <gnome.h>
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus */
/* EMinicardLabel - A label doing focus with non-marching ants.
*
* The following arguments are available:
*
* name type read/write description
* --------------------------------------------------------------------------------
* width double RW width of the label
* height double R height of the label
* field string RW text in the field label
* fieldname string RW text in the fieldname label
*/
#define E_MINICARD_LABEL_TYPE (e_minicard_label_get_type ())
#define E_MINICARD_LABEL(obj) (GTK_CHECK_CAST ((obj), E_MINICARD_LABEL_TYPE, EMinicardLabel))
#define E_MINICARD_LABEL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), E_MINICARD_LABEL_TYPE, EMiniCardLabelClass))
#define E_IS_MINICARD_LABEL(obj) (GTK_CHECK_TYPE ((obj), E_MINICARD_LABEL_TYPE))
#define E_IS_MINICARD_LABEL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((obj), E_MINICARD_LABEL_TYPE))
typedef struct _EMinicardLabel EMinicardLabel;
typedef struct _EMinicardLabelClass EMinicardLabelClass;
struct _EMinicardLabel
{
GnomeCanvasGroup parent;
/* item specific fields */
double width;
double height;
GnomeCanvasItem *fieldname;
GnomeCanvasItem *field;
GnomeCanvasItem *rect;
gboolean has_focus;
};
struct _EMinicardLabelClass
{
GnomeCanvasGroupClass parent_class;
};
GtkType e_minicard_label_get_type (void);
GnomeCanvasItem *e_minicard_label_new(GnomeCanvasGroup *parent);
void e_minicard_label_construct (GnomeCanvasItem *item);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __E_MINICARD_LABEL_H__ */

551
widgets/e-minicard/e-minicard.c
View File

@ -1,551 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* e-minicard.c
* Copyright (C) 2000 Helix Code, Inc.
* Author: Chris Lahey <clahey@helixcode.com>
*
* This library 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 library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <gnome.h>
#include "e-minicard.h"
#include "e-minicard-label.h"
#include "e-text.h"
#include "e-book.h"
#include "e-canvas.h"
#include "e-util.h"
#include "e-canvas-utils.h"
static void e_minicard_init (EMinicard *card);
static void e_minicard_class_init (EMinicardClass *klass);
static void e_minicard_set_arg (GtkObject *o, GtkArg *arg, guint arg_id);
static void e_minicard_get_arg (GtkObject *object, GtkArg *arg, guint arg_id);
static void e_minicard_destroy (GtkObject *object);
static gboolean e_minicard_event (GnomeCanvasItem *item, GdkEvent *event);
static void e_minicard_realize (GnomeCanvasItem *item);
static void e_minicard_unrealize (GnomeCanvasItem *item);
static void e_minicard_reflow ( GnomeCanvasItem *item, int flags );
static void e_minicard_resize_children( EMinicard *e_minicard );
static void remodel( EMinicard *e_minicard );
static GnomeCanvasGroupClass *parent_class = NULL;
/* The arguments we take */
enum {
ARG_0,
ARG_WIDTH,
ARG_HEIGHT,
ARG_HAS_FOCUS,
ARG_CARD
};
GtkType
e_minicard_get_type (void)
{
static GtkType minicard_type = 0;
if (!minicard_type)
{
static const GtkTypeInfo minicard_info =
{
"EMinicard",
sizeof (EMinicard),
sizeof (EMinicardClass),
(GtkClassInitFunc) e_minicard_class_init,
(GtkObjectInitFunc) e_minicard_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
minicard_type = gtk_type_unique (gnome_canvas_group_get_type (), &minicard_info);
}
return minicard_type;
}
static void
e_minicard_class_init (EMinicardClass *klass)
{
GtkObjectClass *object_class;
GnomeCanvasItemClass *item_class;
object_class = (GtkObjectClass*) klass;
item_class = (GnomeCanvasItemClass *) klass;
parent_class = gtk_type_class (gnome_canvas_group_get_type ());
gtk_object_add_arg_type ("EMinicard::width", GTK_TYPE_DOUBLE,
GTK_ARG_READWRITE, ARG_WIDTH);
gtk_object_add_arg_type ("EMinicard::height", GTK_TYPE_DOUBLE,
GTK_ARG_READABLE, ARG_HEIGHT);
gtk_object_add_arg_type ("EMinicard::has_focus", GTK_TYPE_ENUM,
GTK_ARG_READWRITE, ARG_HAS_FOCUS);
gtk_object_add_arg_type ("EMinicard::card", GTK_TYPE_OBJECT,
GTK_ARG_READWRITE, ARG_CARD);
object_class->set_arg = e_minicard_set_arg;
object_class->get_arg = e_minicard_get_arg;
object_class->destroy = e_minicard_destroy;
/* GnomeCanvasItem method overrides */
item_class->realize = e_minicard_realize;
item_class->unrealize = e_minicard_unrealize;
item_class->event = e_minicard_event;
}
static void
e_minicard_init (EMinicard *minicard)
{
/* minicard->card = NULL;*/
minicard->rect = NULL;
minicard->fields = NULL;
minicard->width = 10;
minicard->height = 10;
minicard->has_focus = FALSE;
minicard->card = NULL;
e_canvas_item_set_reflow_callback(GNOME_CANVAS_ITEM(minicard), e_minicard_reflow);
}
static void
e_minicard_set_arg (GtkObject *o, GtkArg *arg, guint arg_id)
{
GnomeCanvasItem *item;
EMinicard *e_minicard;
item = GNOME_CANVAS_ITEM (o);
e_minicard = E_MINICARD (o);
switch (arg_id){
case ARG_WIDTH:
if (e_minicard->width != GTK_VALUE_DOUBLE (*arg)) {
e_minicard->width = GTK_VALUE_DOUBLE (*arg);
e_minicard_resize_children(e_minicard);
if ( GTK_OBJECT_FLAGS( e_minicard ) & GNOME_CANVAS_ITEM_REALIZED )
e_canvas_item_request_reflow(item);
}
break;
case ARG_HAS_FOCUS:
if (e_minicard->fields) {
if ( GTK_VALUE_ENUM(*arg) == E_FOCUS_START ||
GTK_VALUE_ENUM(*arg) == E_FOCUS_CURRENT) {
gnome_canvas_item_set(GNOME_CANVAS_ITEM(e_minicard->fields->data),
"has_focus", GTK_VALUE_ENUM(*arg),
NULL);
} else if ( GTK_VALUE_ENUM(*arg) == E_FOCUS_END ) {
gnome_canvas_item_set(GNOME_CANVAS_ITEM(g_list_last(e_minicard->fields)->data),
"has_focus", GTK_VALUE_ENUM(*arg),
NULL);
}
}
else
e_canvas_item_grab_focus(item);
break;
case ARG_CARD:
if (e_minicard->card)
gtk_object_unref (GTK_OBJECT(e_minicard->card));
e_minicard->card = E_CARD(GTK_VALUE_OBJECT (*arg));
if (e_minicard->card)
gtk_object_ref (GTK_OBJECT(e_minicard->card));
remodel(e_minicard);
e_canvas_item_request_reflow(item);
break;
}
}
static void
e_minicard_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
EMinicard *e_minicard;
e_minicard = E_MINICARD (object);
switch (arg_id) {
case ARG_WIDTH:
GTK_VALUE_DOUBLE (*arg) = e_minicard->width;
break;
case ARG_HEIGHT:
GTK_VALUE_DOUBLE (*arg) = e_minicard->height;
break;
case ARG_HAS_FOCUS:
GTK_VALUE_ENUM (*arg) = e_minicard->has_focus ? E_FOCUS_CURRENT : E_FOCUS_NONE;
break;
case ARG_CARD:
GTK_VALUE_OBJECT (*arg) = GTK_OBJECT(e_minicard->card);
break;
default:
arg->type = GTK_TYPE_INVALID;
break;
}
}
static void
e_minicard_destroy (GtkObject *object)
{
EMinicard *e_minicard;
g_return_if_fail (object != NULL);
g_return_if_fail (E_IS_MINICARD (object));
e_minicard = E_MINICARD (object);
if (e_minicard->card)
gtk_object_unref (GTK_OBJECT(e_minicard->card));
if (GTK_OBJECT_CLASS (parent_class)->destroy)
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}
static void
e_minicard_realize (GnomeCanvasItem *item)
{
EMinicard *e_minicard;
GnomeCanvasGroup *group;
e_minicard = E_MINICARD (item);
group = GNOME_CANVAS_GROUP( item );
if (GNOME_CANVAS_ITEM_CLASS(parent_class)->realize)
(* GNOME_CANVAS_ITEM_CLASS(parent_class)->realize) (item);
e_minicard->rect =
gnome_canvas_item_new( group,
gnome_canvas_rect_get_type(),
"x1", (double) 0,
"y1", (double) 0,
"x2", (double) e_minicard->width - 1,
"y2", (double) e_minicard->height - 1,
"outline_color", NULL,
NULL );
e_minicard->header_rect =
gnome_canvas_item_new( group,
gnome_canvas_rect_get_type(),
"x1", (double) 2,
"y1", (double) 2,
"x2", (double) e_minicard->width - 3,
"y2", (double) e_minicard->height - 3,
"fill_color", "grey70",
NULL );
e_minicard->header_text =
gnome_canvas_item_new( group,
e_text_get_type(),
"anchor", GTK_ANCHOR_NW,
"width", (double) ( e_minicard->width - 12 ),
"clip", TRUE,
"use_ellipsis", TRUE,
"font", "lucidasans-bold-10",
"fill_color", "black",
"text", "",
NULL );
e_canvas_item_move_absolute(e_minicard->header_text, 6, 6);
remodel(e_minicard);
e_canvas_item_request_reflow(item);
if (!item->canvas->aa) {
}
}
static void
e_minicard_unrealize (GnomeCanvasItem *item)
{
EMinicard *e_minicard;
e_minicard = E_MINICARD (item);
if (!item->canvas->aa)
{
}
if (GNOME_CANVAS_ITEM_CLASS(parent_class)->unrealize)
(* GNOME_CANVAS_ITEM_CLASS(parent_class)->unrealize) (item);
}
static gboolean
e_minicard_event (GnomeCanvasItem *item, GdkEvent *event)
{
EMinicard *e_minicard;
e_minicard = E_MINICARD (item);
switch( event->type )
{
case GDK_FOCUS_CHANGE:
{
GdkEventFocus *focus_event = (GdkEventFocus *) event;
if ( focus_event->in )
{
gnome_canvas_item_set( e_minicard->rect,
"outline_color", "grey50",
NULL );
gnome_canvas_item_set( e_minicard->header_rect,
"fill_color", "darkblue",
NULL );
gnome_canvas_item_set( e_minicard->header_text,
"fill_color", "white",
NULL );
e_minicard->has_focus = TRUE;
}
else
{
gnome_canvas_item_set( e_minicard->rect,
"outline_color", NULL,
NULL );
gnome_canvas_item_set( e_minicard->header_rect,
"fill_color", "grey70",
NULL );
gnome_canvas_item_set( e_minicard->header_text,
"fill_color", "black",
NULL );
e_minicard->has_focus = FALSE;
}
}
break;
case GDK_BUTTON_PRESS:
if (event->button.button == 1) {
e_canvas_item_grab_focus(item);
}
break;
case GDK_KEY_PRESS:
if (event->key.keyval == GDK_Tab ||
event->key.keyval == GDK_KP_Tab ||
event->key.keyval == GDK_ISO_Left_Tab) {
GList *list;
for (list = e_minicard->fields; list; list = list->next) {
GnomeCanvasItem *item = GNOME_CANVAS_ITEM (list->data);
EFocus has_focus;
gtk_object_get(GTK_OBJECT(item),
"has_focus", &has_focus,
NULL);
if (has_focus != E_FOCUS_NONE) {
if (event->key.state & GDK_SHIFT_MASK)
list = list->prev;
else
list = list->next;
if (list) {
item = GNOME_CANVAS_ITEM (list->data);
gnome_canvas_item_set(item,
"has_focus", (event->key.state & GDK_SHIFT_MASK) ? E_FOCUS_END : E_FOCUS_START,
NULL);
return 1;
} else {
return 0;
}
}
}
}
default:
break;
}
if (GNOME_CANVAS_ITEM_CLASS( parent_class )->event)
return (* GNOME_CANVAS_ITEM_CLASS( parent_class )->event) (item, event);
else
return 0;
}
static void
e_minicard_resize_children( EMinicard *e_minicard )
{
if ( GTK_OBJECT_FLAGS( e_minicard ) & GNOME_CANVAS_ITEM_REALIZED ) {
GList *list;
gnome_canvas_item_set( e_minicard->header_text,
"width", (double) e_minicard->width - 12,
NULL );
for ( list = e_minicard->fields; list; list = g_list_next( list ) ) {
gnome_canvas_item_set( GNOME_CANVAS_ITEM( list->data ),
"width", (double) e_minicard->width - 4.0,
NULL );
}
}
}
static void
add_field (EMinicard *e_minicard, char *fieldname, char* field)
{
GnomeCanvasItem *new_item;
GnomeCanvasGroup *group;
group = GNOME_CANVAS_GROUP( e_minicard );
new_item = e_minicard_label_new(group);
gnome_canvas_item_set( new_item,
"width", e_minicard->width - 4.0,
"fieldname", fieldname,
"field", field,
NULL );
e_minicard->fields = g_list_append( e_minicard->fields, new_item);
e_canvas_item_move_absolute(new_item, 2, e_minicard->height);
}
static void
remodel( EMinicard *e_minicard )
{
if (e_minicard->card) {
char *fname;
ECardList *address_list;
ECardList *phone_list;
ECardList *email_list;
ECardIterator *iterator;
GList *list;
for ( list = e_minicard->fields; list; list = g_list_next( list ) ) {
gtk_object_destroy( GTK_OBJECT( list->data ) );
}
g_list_free(e_minicard->fields);
e_minicard->fields = NULL;
gtk_object_get(GTK_OBJECT(e_minicard->card),
"full_name", &fname,
"address", &address_list,
"phone", &phone_list,
"email", &email_list,
NULL);
if (fname) {
add_field(e_minicard, "Name:", fname);
if (e_minicard->header_text)
gnome_canvas_item_set(e_minicard->header_text,
"text", fname,
NULL);
} else
if (e_minicard->header_text)
gnome_canvas_item_set(e_minicard->header_text,
"text", "",
NULL);
if (address_list) {
for (iterator = e_card_list_get_iterator(address_list); e_card_iterator_is_valid(iterator); e_card_iterator_next(iterator)) {
const ECardDeliveryAddress *address = e_card_iterator_get(iterator);
if (address->flags & ADDR_WORK) {
add_field(e_minicard, "Work Address:", address->city);
} else if (address->flags & ADDR_HOME) {
add_field(e_minicard, "Home Address:", address->city);
} else {
add_field(e_minicard, "Address:", address->city);
}
}
}
if (phone_list) {
for (iterator = e_card_list_get_iterator(phone_list); e_card_iterator_is_valid(iterator); e_card_iterator_next(iterator)) {
const ECardPhone *phone = e_card_iterator_get(iterator);
if (phone->flags & E_CARD_PHONE_WORK) {
add_field(e_minicard, "Work Phone:", phone->number);
} else if (phone->flags & E_CARD_PHONE_HOME) {
add_field(e_minicard, "Home Phone:", phone->number);
} else if (phone->flags & E_CARD_PHONE_CELL) {
add_field(e_minicard, "Mobile Phone:", phone->number);
} else {
add_field(e_minicard, "Phone:", phone->number);
}
}
}
if (email_list) {
for (iterator = e_card_list_get_iterator(email_list); e_card_iterator_is_valid(iterator); e_card_iterator_next(iterator)) {
add_field(e_minicard, "Email:", (char *) e_card_iterator_get(iterator));
}
}
}
}
static void
e_minicard_reflow( GnomeCanvasItem *item, int flags )
{
EMinicard *e_minicard = E_MINICARD(item);
if ( GTK_OBJECT_FLAGS( e_minicard ) & GNOME_CANVAS_ITEM_REALIZED ) {
GList *list;
gdouble text_height;
gint old_height;
old_height = e_minicard->height;
gtk_object_get( GTK_OBJECT( e_minicard->header_text ),
"text_height", &text_height,
NULL );
e_minicard->height = text_height + 10.0;
gnome_canvas_item_set( e_minicard->header_rect,
"y2", text_height + 9.0,
NULL );
for(list = e_minicard->fields; list; list = g_list_next(list)) {
gtk_object_get (GTK_OBJECT(list->data),
"height", &text_height,
NULL);
e_canvas_item_move_absolute(GNOME_CANVAS_ITEM(list->data), 2, e_minicard->height);
e_minicard->height += text_height;
}
e_minicard->height += 2;
gnome_canvas_item_set( e_minicard->rect,
"y2", (double) e_minicard->height - 1,
NULL );
gnome_canvas_item_set( e_minicard->rect,
"x2", (double) e_minicard->width - 1.0,
"y2", (double) e_minicard->height - 1.0,
NULL );
gnome_canvas_item_set( e_minicard->header_rect,
"x2", (double) e_minicard->width - 3.0,
NULL );
if (old_height != e_minicard->height)
e_canvas_item_request_parent_reflow(item);
}
}
char *
e_minicard_get_card_id (EMinicard *minicard)
{
g_return_val_if_fail(minicard != NULL, NULL);
g_return_val_if_fail(E_IS_MINICARD(minicard), NULL);
if (minicard->card) {
return e_card_get_id(minicard->card);
} else {
return NULL;
}
}
int
e_minicard_compare (EMinicard *minicard1, EMinicard *minicard2)
{
g_return_val_if_fail(minicard1 != NULL, 0);
g_return_val_if_fail(E_IS_MINICARD(minicard1), 0);
g_return_val_if_fail(minicard2 != NULL, 0);
g_return_val_if_fail(E_IS_MINICARD(minicard2), 0);
if (minicard1->card && minicard2->card) {
char *fname1, *fname2;
gtk_object_get(GTK_OBJECT(minicard1->card),
"full_name", &fname1,
NULL);
gtk_object_get(GTK_OBJECT(minicard2->card),
"full_name", &fname2,
NULL);
return strcmp(fname1, fname2);
} else {
return 0;
}
}

97
widgets/e-minicard/e-minicard.h
View File

@ -1,97 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* e-minicard.h
* Copyright (C) 2000 Helix Code, Inc.
* Author: Chris Lahey <clahey@helixcode.com>
*
* This library 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 library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __E_MINICARD_H__
#define __E_MINICARD_H__
#include <gnome.h>
#include "e-card.h"
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus */
/* EMinicard - A small card displaying information about a contact.
*
* The following arguments are available:
*
* name type read/write description
* --------------------------------------------------------------------------------
* width double RW width of the card
* height double R height of the card
* card ECard* RW Pointer to the ECard
*/
#define E_MINICARD_TYPE (e_minicard_get_type ())
#define E_MINICARD(obj) (GTK_CHECK_CAST ((obj), E_MINICARD_TYPE, EMinicard))
#define E_MINICARD_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), E_MINICARD_TYPE, EMinicardClass))
#define E_IS_MINICARD(obj) (GTK_CHECK_TYPE ((obj), E_MINICARD_TYPE))
#define E_IS_MINICARD_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((obj), E_MINICARD_TYPE))
typedef struct _EMinicard EMinicard;
typedef struct _EMinicardClass EMinicardClass;
typedef enum _EMinicardFocusType EMinicardFocusType;
enum _EMinicardFocusType {
E_MINICARD_FOCUS_TYPE_START,
E_MINICARD_FOCUS_TYPE_END
};
struct _EMinicard
{
GnomeCanvasGroup parent;
/* item specific fields */
/* ECard *card; */
GnomeCanvasItem *rect;
GnomeCanvasItem *header_rect;
GnomeCanvasItem *header_text;
GList *fields; /* Of type GnomeCanvasItem. */
ECard *card;
guint needs_remodeling : 1;
gboolean has_focus;
double width;
double height;
};
struct _EMinicardClass
{
GnomeCanvasGroupClass parent_class;
void (* resize) (EMinicard *minicard);
};
GtkType e_minicard_get_type (void);
char *e_minicard_get_card_id (EMinicard *minicard);
int e_minicard_compare (EMinicard *minicard1, EMinicard *minicard2);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __E_MINICARD_H__ */

769
widgets/e-minicard/e-reflow.c
View File

@ -1,769 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* e-reflow.c
* Copyright (C) 2000 Helix Code, Inc.
* Author: Chris Lahey <clahey@helixcode.com>
*
* This library 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 library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <gnome.h>
#include <math.h>
#include "e-reflow.h"
#include "e-canvas-utils.h"
#include "e-canvas.h"
#include "e-util.h"
static void e_reflow_init (EReflow *reflow);
static void e_reflow_class_init (EReflowClass *klass);
static void e_reflow_set_arg (GtkObject *o, GtkArg *arg, guint arg_id);
static void e_reflow_get_arg (GtkObject *object, GtkArg *arg, guint arg_id);
static void e_reflow_destroy (GtkObject *object);
static gboolean e_reflow_event (GnomeCanvasItem *item, GdkEvent *event);
static void e_reflow_realize (GnomeCanvasItem *item);
static void e_reflow_unrealize (GnomeCanvasItem *item);
static void e_reflow_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
int x, int y, int width, int height);
static void e_reflow_update (GnomeCanvasItem *item, double affine[6], ArtSVP *clip_path, gint flags);
static double e_reflow_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item);
static void e_reflow_reflow (GnomeCanvasItem *item, int flags);
static void e_reflow_real_add_item(EReflow *e_reflow, GnomeCanvasItem *item);
static void e_reflow_resize_children (GnomeCanvasItem *item);
#define E_REFLOW_DIVIDER_WIDTH 2
#define E_REFLOW_BORDER_WIDTH 7
#define E_REFLOW_FULL_GUTTER (E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH * 2)
static GnomeCanvasGroupClass *parent_class = NULL;
/* The arguments we take */
enum {
ARG_0,
ARG_MINIMUM_WIDTH,
ARG_WIDTH,
ARG_HEIGHT
};
GtkType
e_reflow_get_type (void)
{
static GtkType reflow_type = 0;
if (!reflow_type)
{
static const GtkTypeInfo reflow_info =
{
"EReflow",
sizeof (EReflow),
sizeof (EReflowClass),
(GtkClassInitFunc) e_reflow_class_init,
(GtkObjectInitFunc) e_reflow_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
reflow_type = gtk_type_unique (gnome_canvas_group_get_type (), &reflow_info);
}
return reflow_type;
}
static void
e_reflow_class_init (EReflowClass *klass)
{
GtkObjectClass *object_class;
GnomeCanvasItemClass *item_class;
object_class = (GtkObjectClass*) klass;
item_class = (GnomeCanvasItemClass *) klass;
parent_class = gtk_type_class (gnome_canvas_group_get_type ());
gtk_object_add_arg_type ("EReflow::minimum_width", GTK_TYPE_DOUBLE,
GTK_ARG_READWRITE, ARG_MINIMUM_WIDTH);
gtk_object_add_arg_type ("EReflow::width", GTK_TYPE_DOUBLE,
GTK_ARG_READABLE, ARG_WIDTH);
gtk_object_add_arg_type ("EReflow::height", GTK_TYPE_DOUBLE,
GTK_ARG_READWRITE, ARG_HEIGHT);
klass->add_item = e_reflow_real_add_item;
object_class->set_arg = e_reflow_set_arg;
object_class->get_arg = e_reflow_get_arg;
object_class->destroy = e_reflow_destroy;
/* GnomeCanvasItem method overrides */
item_class->event = e_reflow_event;
item_class->realize = e_reflow_realize;
item_class->unrealize = e_reflow_unrealize;
item_class->draw = e_reflow_draw;
item_class->update = e_reflow_update;
item_class->point = e_reflow_point;
}
static void
e_reflow_init (EReflow *reflow)
{
reflow->items = NULL;
reflow->columns = NULL;
reflow->column_width = 150;
reflow->minimum_width = 10;
reflow->width = 10;
reflow->height = 10;
reflow->idle = 0;
reflow->column_drag = FALSE;
reflow->need_height_update = FALSE;
reflow->need_column_resize = FALSE;
reflow->default_cursor_shown = TRUE;
reflow->arrow_cursor = NULL;
reflow->default_cursor = NULL;
e_canvas_item_set_reflow_callback(GNOME_CANVAS_ITEM(reflow), e_reflow_reflow);
}
static void
e_reflow_set_arg (GtkObject *o, GtkArg *arg, guint arg_id)
{
GnomeCanvasItem *item;
EReflow *e_reflow;
item = GNOME_CANVAS_ITEM (o);
e_reflow = E_REFLOW (o);
switch (arg_id){
case ARG_HEIGHT:
e_reflow->height = GTK_VALUE_DOUBLE (*arg);
e_canvas_item_request_reflow(item);
break;
case ARG_MINIMUM_WIDTH:
e_reflow->minimum_width = GTK_VALUE_DOUBLE (*arg);
e_canvas_item_request_reflow(item);
break;
}
}
static void
e_reflow_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
EReflow *e_reflow;
e_reflow = E_REFLOW (object);
switch (arg_id) {
case ARG_MINIMUM_WIDTH:
GTK_VALUE_DOUBLE (*arg) = e_reflow->minimum_width;
break;
case ARG_WIDTH:
GTK_VALUE_DOUBLE (*arg) = e_reflow->width;
break;
case ARG_HEIGHT:
GTK_VALUE_DOUBLE (*arg) = e_reflow->height;
break;
default:
arg->type = GTK_TYPE_INVALID;
break;
}
}
static void
e_reflow_destroy (GtkObject *object)
{
EReflow *reflow = E_REFLOW(object);
g_list_free(reflow->items);
}
static void
e_reflow_realize (GnomeCanvasItem *item)
{
EReflow *e_reflow;
GnomeCanvasGroup *group;
GList *list;
GtkAdjustment *adjustment;
e_reflow = E_REFLOW (item);
group = GNOME_CANVAS_GROUP( item );
if (GNOME_CANVAS_ITEM_CLASS(parent_class)->realize)
(* GNOME_CANVAS_ITEM_CLASS(parent_class)->realize) (item);
e_reflow->arrow_cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
e_reflow->default_cursor = gdk_cursor_new (GDK_LEFT_PTR);
for(list = e_reflow->items; list; list = g_list_next(list)) {
GnomeCanvasItem *item = GNOME_CANVAS_ITEM(list->data);
gnome_canvas_item_set(item,
"width", (double) e_reflow->column_width,
NULL);
}
e_canvas_item_request_reflow(item);
adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
adjustment->step_increment = (e_reflow->column_width + E_REFLOW_FULL_GUTTER) / 2;
adjustment->page_increment = adjustment->page_size - adjustment->step_increment;
gtk_adjustment_changed(adjustment);
if (!item->canvas->aa) {
}
}
static void
e_reflow_unrealize (GnomeCanvasItem *item)
{
EReflow *e_reflow;
e_reflow = E_REFLOW (item);
if (!item->canvas->aa)
{
}
gdk_cursor_destroy (e_reflow->arrow_cursor);
gdk_cursor_destroy (e_reflow->default_cursor);
e_reflow->arrow_cursor = NULL;
e_reflow->default_cursor = NULL;
g_list_free (e_reflow->columns);
e_reflow->columns = NULL;
if (GNOME_CANVAS_ITEM_CLASS(parent_class)->unrealize)
(* GNOME_CANVAS_ITEM_CLASS(parent_class)->unrealize) (item);
}
static gint
e_reflow_pick_line (EReflow *e_reflow, double x)
{
x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
x /= e_reflow->column_width + E_REFLOW_FULL_GUTTER;
return x;
}
static gboolean
e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
{
EReflow *e_reflow;
e_reflow = E_REFLOW (item);
switch( event->type )
{
case GDK_KEY_PRESS:
if (event->key.keyval == GDK_Tab ||
event->key.keyval == GDK_KP_Tab ||
event->key.keyval == GDK_ISO_Left_Tab) {
GList *list;
for (list = e_reflow->items; list; list = list->next) {
GnomeCanvasItem *item = GNOME_CANVAS_ITEM (list->data);
EFocus has_focus;
gtk_object_get(GTK_OBJECT(item),
"has_focus", &has_focus,
NULL);
if (has_focus) {
if (event->key.state & GDK_SHIFT_MASK)
list = list->prev;
else
list = list->next;
if (list) {
item = GNOME_CANVAS_ITEM(list->data);
gnome_canvas_item_set(item,
"has_focus", (event->key.state & GDK_SHIFT_MASK) ? E_FOCUS_END : E_FOCUS_START,
NULL);
return 1;
} else {
return 0;
}
}
}
}
break;
case GDK_BUTTON_PRESS:
switch(event->button.button)
{
case 1:
{
GdkEventButton *button = (GdkEventButton *) event;
double n_x;
n_x = button->x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x,(e_reflow->column_width + E_REFLOW_FULL_GUTTER));
if ( button->y >= E_REFLOW_BORDER_WIDTH && button->y <= e_reflow->height - E_REFLOW_BORDER_WIDTH && n_x < E_REFLOW_FULL_GUTTER ) {
e_reflow->which_column_dragged = e_reflow_pick_line(e_reflow, button->x);
e_reflow->start_x = e_reflow->which_column_dragged * (e_reflow->column_width + E_REFLOW_FULL_GUTTER) - E_REFLOW_DIVIDER_WIDTH / 2;
e_reflow->temp_column_width = e_reflow->column_width;
e_reflow->column_drag = TRUE;
gnome_canvas_item_grab (item,
GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
e_reflow->arrow_cursor,
button->time);
e_reflow->previous_temp_column_width = -1;
e_reflow->need_column_resize = TRUE;
gnome_canvas_item_request_update(item);
return TRUE;
}
}
break;
case 4:
{
GtkAdjustment *adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
gdouble new_value = adjustment->value;
new_value -= adjustment->step_increment;
gtk_adjustment_set_value(adjustment, new_value);
}
break;
case 5:
{
GtkAdjustment *adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
gdouble new_value = adjustment->value;
new_value += adjustment->step_increment;
if ( new_value > adjustment->upper - adjustment->page_size )
new_value = adjustment->upper - adjustment->page_size;
gtk_adjustment_set_value(adjustment, new_value);
}
break;
}
break;
case GDK_BUTTON_RELEASE:
if (e_reflow->column_drag) {
gdouble old_width = e_reflow->column_width;
GdkEventButton *button = (GdkEventButton *) event;
GtkAdjustment *adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
e_reflow->temp_column_width = e_reflow->column_width +
(button->x - e_reflow->start_x)/(e_reflow->which_column_dragged - e_reflow_pick_line(e_reflow, adjustment->value));
if ( e_reflow->temp_column_width < 50 )
e_reflow->temp_column_width = 50;
e_reflow->column_drag = FALSE;
if ( old_width != e_reflow->temp_column_width ) {
gtk_adjustment_set_value(adjustment, adjustment->value + e_reflow_pick_line(e_reflow, adjustment->value) * (e_reflow->temp_column_width - e_reflow->column_width));
e_reflow->column_width = e_reflow->temp_column_width;
adjustment->step_increment = (e_reflow->column_width + E_REFLOW_FULL_GUTTER) / 2;
adjustment->page_increment = adjustment->page_size - adjustment->step_increment;
gtk_adjustment_changed(adjustment);
e_reflow_resize_children(item);
e_canvas_item_request_reflow(item);
}
e_reflow->need_column_resize = TRUE;
gnome_canvas_item_request_update(item);
gnome_canvas_item_ungrab (item, button->time);
return TRUE;
}
break;
case GDK_MOTION_NOTIFY:
if (e_reflow->column_drag) {
double old_width = e_reflow->temp_column_width;
GdkEventMotion *motion = (GdkEventMotion *) event;
GtkAdjustment *adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
e_reflow->temp_column_width = e_reflow->column_width +
(motion->x - e_reflow->start_x)/(e_reflow->which_column_dragged - e_reflow_pick_line(e_reflow, adjustment->value));
if (e_reflow->temp_column_width < 50)
e_reflow->temp_column_width = 50;
if (old_width != e_reflow->temp_column_width) {
e_reflow->need_column_resize = TRUE;
gnome_canvas_item_request_update(item);
}
return TRUE;
} else {
GdkEventMotion *motion = (GdkEventMotion *) event;
double n_x;
n_x = motion->x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x,(e_reflow->column_width + E_REFLOW_FULL_GUTTER));
if ( motion->y >= E_REFLOW_BORDER_WIDTH && motion->y <= e_reflow->height - E_REFLOW_BORDER_WIDTH && n_x < E_REFLOW_FULL_GUTTER ) {
if ( e_reflow->default_cursor_shown ) {
gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, e_reflow->arrow_cursor);
e_reflow->default_cursor_shown = FALSE;
}
} else
if ( ! e_reflow->default_cursor_shown ) {
gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, e_reflow->default_cursor);
e_reflow->default_cursor_shown = TRUE;
}
}
break;
case GDK_ENTER_NOTIFY:
if (!e_reflow->column_drag) {
GdkEventCrossing *crossing = (GdkEventCrossing *) event;
double n_x;
n_x = crossing->x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x,(e_reflow->column_width + E_REFLOW_FULL_GUTTER));
if ( crossing->y >= E_REFLOW_BORDER_WIDTH && crossing->y <= e_reflow->height - E_REFLOW_BORDER_WIDTH && n_x < E_REFLOW_FULL_GUTTER ) {
if ( e_reflow->default_cursor_shown ) {
gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, e_reflow->arrow_cursor);
e_reflow->default_cursor_shown = FALSE;
}
}
}
break;
case GDK_LEAVE_NOTIFY:
if (!e_reflow->column_drag) {
GdkEventCrossing *crossing = (GdkEventCrossing *) event;
double n_x;
n_x = crossing->x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x,(e_reflow->column_width + E_REFLOW_FULL_GUTTER));
if ( !( crossing->y >= E_REFLOW_BORDER_WIDTH && crossing->y <= e_reflow->height - E_REFLOW_BORDER_WIDTH && n_x < E_REFLOW_FULL_GUTTER ) ) {
if ( ! e_reflow->default_cursor_shown ) {
gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, e_reflow->default_cursor);
e_reflow->default_cursor_shown = TRUE;
}
}
}
break;
default:
break;
}
if (GNOME_CANVAS_ITEM_CLASS( parent_class )->event)
return (* GNOME_CANVAS_ITEM_CLASS( parent_class )->event) (item, event);
else
return 0;
}
static void
e_reflow_real_add_item(EReflow *e_reflow, GnomeCanvasItem *item)
{
e_reflow->items = g_list_append(e_reflow->items, item);
if ( GTK_OBJECT_FLAGS( e_reflow ) & GNOME_CANVAS_ITEM_REALIZED ) {
gnome_canvas_item_set(item,
"width", (double) e_reflow->column_width,
NULL);
e_canvas_item_request_reflow(item);
}
}
static void e_reflow_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
int x, int y, int width, int height)
{
int x_rect, y_rect, width_rect, height_rect;
gdouble running_width;
EReflow *e_reflow = E_REFLOW(item);
int i;
double column_width;
if (GNOME_CANVAS_ITEM_CLASS(parent_class)->draw)
GNOME_CANVAS_ITEM_CLASS(parent_class)->draw (item, drawable, x, y, width, height);
column_width = e_reflow->column_width;
running_width = E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
x_rect = running_width;
y_rect = E_REFLOW_BORDER_WIDTH;
width_rect = E_REFLOW_DIVIDER_WIDTH;
height_rect = e_reflow->height - (E_REFLOW_BORDER_WIDTH * 2);
/* Compute first column to draw. */
i = x;
i /= column_width + E_REFLOW_FULL_GUTTER;
running_width += i * (column_width + E_REFLOW_FULL_GUTTER);
for ( ; i < e_reflow->column_count; i++) {
if ( running_width > x + width )
break;
x_rect = running_width;
gtk_paint_flat_box(GTK_WIDGET(item->canvas)->style,
drawable,
GTK_STATE_ACTIVE,
GTK_SHADOW_NONE,
NULL,
GTK_WIDGET(item->canvas),
"reflow",
x_rect - x,
y_rect - y,
width_rect,
height_rect);
running_width += E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
}
if (e_reflow->column_drag) {
int start_line = e_reflow_pick_line(e_reflow,
gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas))->value);
i = x - start_line * (column_width + E_REFLOW_FULL_GUTTER);
running_width = start_line * (column_width + E_REFLOW_FULL_GUTTER);
column_width = e_reflow->temp_column_width;
running_width -= start_line * (column_width + E_REFLOW_FULL_GUTTER);
i += start_line * (column_width + E_REFLOW_FULL_GUTTER);
running_width += E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
x_rect = running_width;
y_rect = E_REFLOW_BORDER_WIDTH;
width_rect = E_REFLOW_DIVIDER_WIDTH;
height_rect = e_reflow->height - (E_REFLOW_BORDER_WIDTH * 2);
/* Compute first column to draw. */
i /= column_width + E_REFLOW_FULL_GUTTER;
running_width += i * (column_width + E_REFLOW_FULL_GUTTER);
for ( ; i < e_reflow->column_count; i++) {
if ( running_width > x + width )
break;
x_rect = running_width;
gdk_draw_rectangle(drawable,
GTK_WIDGET(item->canvas)->style->fg_gc[GTK_STATE_NORMAL],
TRUE,
x_rect - x,
y_rect - y,
width_rect - 1,
height_rect - 1);
running_width += E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
}
}
}
static void
e_reflow_update (GnomeCanvasItem *item, double affine[6], ArtSVP *clip_path, gint flags)
{
EReflow *e_reflow;
double x0, x1, y0, y1;
e_reflow = E_REFLOW (item);
if (GNOME_CANVAS_ITEM_CLASS(parent_class)->update)
GNOME_CANVAS_ITEM_CLASS(parent_class)->update (item, affine, clip_path, flags);
x0 = item->x1;
y0 = item->y1;
x1 = item->x2;
y1 = item->y2;
if ( x1 < x0 + e_reflow->width )
x1 = x0 + e_reflow->width;
if ( y1 < y0 + e_reflow->height )
y1 = y0 + e_reflow->height;
item->x2 = x1;
item->y2 = y1;
if (e_reflow->need_height_update) {
x0 = item->x1;
y0 = item->y1;
x1 = item->x2;
y1 = item->y2;
if ( x0 > 0 )
x0 = 0;
if ( y0 > 0 )
y0 = 0;
if ( x1 < E_REFLOW(item)->width )
x1 = E_REFLOW(item)->width;
if ( x1 < E_REFLOW(item)->height )
x1 = E_REFLOW(item)->height;
gnome_canvas_request_redraw(item->canvas, x0, y0, x1, y1);
e_reflow->need_height_update = FALSE;
} else if (e_reflow->need_column_resize) {
int x_rect, y_rect, width_rect, height_rect;
int start_line = e_reflow_pick_line(e_reflow,
gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas))->value);
gdouble running_width;
int i;
double column_width;
if ( e_reflow->previous_temp_column_width != -1 ) {
running_width = start_line * (e_reflow->column_width + E_REFLOW_FULL_GUTTER);
column_width = e_reflow->previous_temp_column_width;
running_width -= start_line * (column_width + E_REFLOW_FULL_GUTTER);
running_width += E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
y_rect = E_REFLOW_BORDER_WIDTH;
width_rect = E_REFLOW_DIVIDER_WIDTH;
height_rect = e_reflow->height - (E_REFLOW_BORDER_WIDTH * 2);
for ( i = 0; i < e_reflow->column_count; i++) {
x_rect = running_width;
gnome_canvas_request_redraw(item->canvas, x_rect, y_rect, x_rect + width_rect, y_rect + height_rect);
running_width += E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
}
}
if ( e_reflow->temp_column_width != -1 ) {
running_width = start_line * (e_reflow->column_width + E_REFLOW_FULL_GUTTER);
column_width = e_reflow->temp_column_width;
running_width -= start_line * (column_width + E_REFLOW_FULL_GUTTER);
running_width += E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
y_rect = E_REFLOW_BORDER_WIDTH;
width_rect = E_REFLOW_DIVIDER_WIDTH;
height_rect = e_reflow->height - (E_REFLOW_BORDER_WIDTH * 2);
for ( i = 0; i < e_reflow->column_count; i++) {
x_rect = running_width;
gnome_canvas_request_redraw(item->canvas, x_rect, y_rect, x_rect + width_rect, y_rect + height_rect);
running_width += E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
}
}
e_reflow->previous_temp_column_width = e_reflow->temp_column_width;
e_reflow->need_column_resize = FALSE;
}
}
static void
e_reflow_resize_children (GnomeCanvasItem *item)
{
GList *list;
EReflow *e_reflow;
e_reflow = E_REFLOW (item);
for ( list = e_reflow->items; list; list = list->next ) {
GnomeCanvasItem *child = GNOME_CANVAS_ITEM(list->data);
gnome_canvas_item_set(child,
"width", (double) e_reflow->column_width,
NULL);
}
}
static double
e_reflow_point (GnomeCanvasItem *item,
double x, double y, int cx, int cy,
GnomeCanvasItem **actual_item)
{
double distance = 1;
if (GNOME_CANVAS_ITEM_CLASS(parent_class)->point)
distance = GNOME_CANVAS_ITEM_CLASS(parent_class)->point (item, x, y, cx, cy, actual_item);
if (*actual_item)
return 0;
*actual_item = item;
return 0;
#if 0
if (y >= E_REFLOW_BORDER_WIDTH && y <= e_reflow->height - E_REFLOW_BORDER_WIDTH) {
float n_x;
n_x = x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x, (e_reflow->column_width + E_REFLOW_FULL_GUTTER));
if (n_x < E_REFLOW_FULL_GUTTER) {
*actual_item = item;
return 0;
}
}
return distance;
#endif
}
static void
_reflow( EReflow *e_reflow )
{
gdouble running_height;
GList *list;
double item_height;
if (e_reflow->columns) {
g_list_free (e_reflow->columns);
e_reflow->columns = NULL;
}
e_reflow->column_count = 0;
if (e_reflow->items == NULL) {
e_reflow->columns = NULL;
e_reflow->column_count = 1;
return;
}
list = e_reflow->items;
gtk_object_get (GTK_OBJECT(list->data),
"height", &item_height,
NULL);
running_height = E_REFLOW_BORDER_WIDTH + item_height + E_REFLOW_BORDER_WIDTH;
e_reflow->columns = g_list_append (e_reflow->columns, list);
e_reflow->column_count = 1;
list = g_list_next(list);
for ( ; list; list = g_list_next(list)) {
gtk_object_get (GTK_OBJECT(list->data),
"height", &item_height,
NULL);
if (running_height + item_height + E_REFLOW_BORDER_WIDTH > e_reflow->height) {
running_height = E_REFLOW_BORDER_WIDTH + item_height + E_REFLOW_BORDER_WIDTH;
e_reflow->columns = g_list_append (e_reflow->columns, list);
e_reflow->column_count ++;
} else {
running_height += item_height + E_REFLOW_BORDER_WIDTH;
}
}
}
static void
e_reflow_reflow( GnomeCanvasItem *item, int flags )
{
EReflow *e_reflow = E_REFLOW(item);
if ( GTK_OBJECT_FLAGS( e_reflow ) & GNOME_CANVAS_ITEM_REALIZED ) {
gdouble old_width;
gdouble running_width;
_reflow (e_reflow);
old_width = e_reflow->width;
running_width = E_REFLOW_BORDER_WIDTH;
if (e_reflow->items == NULL) {
} else {
GList *list;
GList *next_column;
gdouble item_height;
gdouble running_height;
running_height = E_REFLOW_BORDER_WIDTH;
list = e_reflow->items;
gtk_object_get (GTK_OBJECT(list->data),
"height", &item_height,
NULL);
e_canvas_item_move_absolute(GNOME_CANVAS_ITEM(list->data),
(double) running_width,
(double) running_height);
running_height += item_height + E_REFLOW_BORDER_WIDTH;
next_column = g_list_next(e_reflow->columns);
list = g_list_next(list);
for( ; list; list = g_list_next(list)) {
gtk_object_get (GTK_OBJECT(list->data),
"height", &item_height,
NULL);
if (next_column && (next_column->data == list)) {
next_column = g_list_next (next_column);
running_height = E_REFLOW_BORDER_WIDTH;
running_width += e_reflow->column_width + E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH;
}
e_canvas_item_move_absolute(GNOME_CANVAS_ITEM(list->data),
(double) running_width,
(double) running_height);
running_height += item_height + E_REFLOW_BORDER_WIDTH;
}
}
e_reflow->width = running_width + e_reflow->column_width + E_REFLOW_BORDER_WIDTH;
if ( e_reflow->width < e_reflow->minimum_width )
e_reflow->width = e_reflow->minimum_width;
if (old_width != e_reflow->width)
e_canvas_item_request_parent_reflow(item);
}
}
void
e_reflow_add_item(EReflow *e_reflow, GnomeCanvasItem *item)
{
if (E_REFLOW_CLASS(GTK_OBJECT(e_reflow)->klass)->add_item)
(E_REFLOW_CLASS(GTK_OBJECT(e_reflow)->klass)->add_item) (e_reflow, item);
}

106
widgets/e-minicard/e-reflow.h
View File

@ -1,106 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* e-reflow.h
* Copyright (C) 2000 Helix Code, Inc.
* Author: Chris Lahey <clahey@helixcode.com>
*
* This library 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 library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __E_REFLOW_H__
#define __E_REFLOW_H__
#include <gnome.h>
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus */
/* EReflow - A canvas item container.
*
* The following arguments are available:
*
* name type read/write description
* --------------------------------------------------------------------------------
* minimum_width double RW minimum width of the reflow. width >= minimum_width
* width double R width of the reflow
* height double RW height of the reflow
*/
#define E_REFLOW_TYPE (e_reflow_get_type ())
#define E_REFLOW(obj) (GTK_CHECK_CAST ((obj), E_REFLOW_TYPE, EReflow))
#define E_REFLOW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), E_REFLOW_TYPE, EReflowClass))
#define E_IS_REFLOW(obj) (GTK_CHECK_TYPE ((obj), E_REFLOW_TYPE))
#define E_IS_REFLOW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((obj), E_REFLOW_TYPE))
typedef struct _EReflow EReflow;
typedef struct _EReflowClass EReflowClass;
struct _EReflow
{
GnomeCanvasGroup parent;
/* item specific fields */
GList *items; /* Of type GnomeCanvasItem */
GList *columns; /* Of type GList of type GnomeCanvasItem (points into items) */
gint column_count; /* Number of columnns */
double minimum_width;
double width;
double height;
double column_width;
int idle;
/* These are all for when the column is being dragged. */
gboolean column_drag;
gdouble start_x;
gint which_column_dragged;
double temp_column_width;
double previous_temp_column_width;
guint need_height_update : 1;
guint need_column_resize : 1;
guint default_cursor_shown : 1;
GdkCursor *arrow_cursor;
GdkCursor *default_cursor;
};
struct _EReflowClass
{
GnomeCanvasGroupClass parent_class;
/* Virtual methods. */
void (* add_item) (EReflow *reflow, GnomeCanvasItem *item);
};
/*
* To be added to a reflow, an item must have the argument "width" as
* a Read/Write argument and "height" as a Read Only argument. It
* should also do an ECanvas parent reflow request if its size
* changes.
*/
void e_reflow_add_item(EReflow *e_reflow, GnomeCanvasItem *item);
GtkType e_reflow_get_type (void);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __E_REFLOW_H__ */

128
widgets/e-minicard/test-minicard-label.c
View File

@ -1,128 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* test-minicard-label.c
*
* Copyright (C) 2000 Helix Code, Inc.
* Author: Chris Lahey <clahey@helixcode.com>
*
* 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, 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.
*/
#include "config.h"
#include <gnome.h>
#include "e-minicard-label.h"
#include "e-canvas.h"
/* This is a horrible thing to do, but it is just a test. */
GnomeCanvasItem *label;
GnomeCanvasItem *rect;
static void destroy_callback(GtkWidget *app, gpointer data)
{
exit(0);
}
static void allocate_callback(GtkWidget *canvas, GtkAllocation *allocation, gpointer data)
{
gnome_canvas_set_scroll_region(GNOME_CANVAS( canvas ), 0, 0, allocation->width, allocation->height );
gnome_canvas_item_set( label,
"width", (double) allocation->width,
"height", (double) allocation->height,
NULL );
gnome_canvas_item_set( rect,
"x2", (double) allocation->width,
"y2", (double) allocation->height,
NULL );
}
#if 0
static void about_callback( GtkWidget *widget, gpointer data )
{
const gchar *authors[] =
{
"Christopher James Lahey <clahey@umich.edu>",
NULL
};
GtkWidget *about =
gnome_about_new ( _( "Minicard Label Test" ), VERSION,
_( "Copyright (C) 2000, Helix Code, Inc." ),
authors,
_( "This should test the minicard label canvas item" ),
NULL);
gtk_widget_show (about);
}
#endif
static void button_press_callback( GtkWidget *widget, gpointer data )
{
gnome_canvas_item_grab_focus( label );
}
int main( int argc, char *argv[] )
{
GtkWidget *app;
GtkWidget *canvas;
/* bindtextdomain (PACKAGE, GNOMELOCALEDIR);
textdomain (PACKAGE);*/
gnome_init( "Minicard Label Test", VERSION, argc, argv);
app = gnome_app_new("Minicard Label Test", NULL);
canvas = e_canvas_new();
rect = gnome_canvas_item_new( gnome_canvas_root( GNOME_CANVAS( canvas ) ),
gnome_canvas_rect_get_type(),
"x1", (double) 0,
"y1", (double) 0,
"x2", (double) 100,
"y2", (double) 100,
"fill_color", "white",
NULL );
label = e_minicard_label_new(gnome_canvas_root( GNOME_CANVAS( canvas ) ));
gnome_canvas_item_set( label,
"x", (double) 0,
"y", (double) 0,
"width", (double) 100,
"height", (double) 100,
"fieldname", "Full Name:",
"field", "Christopher James Lahey",
NULL );
gnome_canvas_set_scroll_region ( GNOME_CANVAS( canvas ),
0, 0,
100, 100 );
gnome_app_set_contents( GNOME_APP( app ), canvas );
/* Connect the signals */
gtk_signal_connect( GTK_OBJECT( app ), "destroy",
GTK_SIGNAL_FUNC( destroy_callback ),
( gpointer ) app );
gtk_signal_connect( GTK_OBJECT( canvas ), "size_allocate",
GTK_SIGNAL_FUNC( allocate_callback ),
( gpointer ) app );
gtk_signal_connect( GTK_OBJECT( canvas ), "button_press_event",
GTK_SIGNAL_FUNC( button_press_callback ),
( gpointer ) app );
gtk_widget_show_all( app );
gtk_main();
/* Not reached. */
return 0;
}

117
widgets/e-minicard/test-minicard.c
View File

@ -1,117 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* test-minicard.c
*
* Copyright (C) 2000 Helix Code, Inc.
* Author: Chris Lahey <clahey@helixcode.com>
*
* 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, 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.
*/
#include "config.h"
#include <gnome.h>
#include "e-minicard.h"
/* This is a horrible thing to do, but it is just a test. */
GnomeCanvasItem *card;
GnomeCanvasItem *rect;
static void destroy_callback(GtkWidget *app, gpointer data)
{
exit(0);
}
static void allocate_callback(GtkWidget *canvas, GtkAllocation *allocation, gpointer data)
{
gnome_canvas_set_scroll_region(GNOME_CANVAS( canvas ), 0, 0, allocation->width, allocation->height );
gnome_canvas_item_set( card,
"width", (double) allocation->width,
NULL );
gnome_canvas_item_set( rect,
"x2", (double) allocation->width,
"y2", (double) allocation->height,
NULL );
}
#if 0
static void about_callback( GtkWidget *widget, gpointer data )
{
const gchar *authors[] =
{
"Christopher James Lahey <clahey@umich.edu>",
NULL
};
GtkWidget *about =
gnome_about_new ( _( "Minicard Test" ), VERSION,
_( "Copyright (C) 2000, Helix Code, Inc." ),
authors,
_( "This should test the minicard canvas item" ),
NULL);
gtk_widget_show (about);
}
#endif
int main( int argc, char *argv[] )
{
GtkWidget *app;
GtkWidget *canvas;
int i;
/* bindtextdomain (PACKAGE, GNOMELOCALEDIR);
textdomain (PACKAGE);*/
gnome_init( "Minicard Test", VERSION, argc, argv);
app = gnome_app_new("Minicard Test", NULL);
canvas = gnome_canvas_new();
rect = gnome_canvas_item_new( gnome_canvas_root( GNOME_CANVAS( canvas ) ),
gnome_canvas_rect_get_type(),
"x1", (double) 0,
"y1", (double) 0,
"x2", (double) 100,
"y2", (double) 100,
"fill_color", "white",
NULL );
for ( i = 0; i < 1; i++ )
{
card = gnome_canvas_item_new( gnome_canvas_root( GNOME_CANVAS( canvas ) ),
e_minicard_get_type(),
"x", (double) 0,
"y", (double) 0,
"width", (double) 100,
NULL );
}
gnome_canvas_set_scroll_region ( GNOME_CANVAS( canvas ),
0, 0,
100, 100 );
gnome_app_set_contents( GNOME_APP( app ), canvas );
/* Connect the signals */
gtk_signal_connect( GTK_OBJECT( app ), "destroy",
GTK_SIGNAL_FUNC( destroy_callback ),
( gpointer ) app );
gtk_signal_connect( GTK_OBJECT( canvas ), "size_allocate",
GTK_SIGNAL_FUNC( allocate_callback ),
( gpointer ) app );
gtk_widget_show_all( app );
gtk_main();
/* Not reached. */
return 0;
}

185
widgets/e-reflow/e-reflow-sorted.c Normal file
View File

@ -0,0 +1,185 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* e-reflow-sorted.c
* Copyright (C) 2000 Helix Code, Inc.
* Author: Chris Lahey <clahey@helixcode.com>
*
* This library 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 library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <gnome.h>
#include <math.h>
#include "e-reflow-sorted.h"
#include "e-canvas-utils.h"
#include "e-canvas.h"
#include "e-util.h"
#include <glib.h>
static void e_reflow_sorted_init (EReflowSorted *card);
static void e_reflow_sorted_class_init (EReflowSortedClass *klass);
static void e_reflow_sorted_set_arg (GtkObject *o, GtkArg *arg, guint arg_id);
static void e_reflow_sorted_get_arg (GtkObject *object, GtkArg *arg, guint arg_id);
static void e_reflow_sorted_add_item(EReflow *e_reflow, GnomeCanvasItem *item);
static EReflowClass *parent_class = NULL;
/* The arguments we take */
enum {
ARG_0,
ARG_COMPARE_FUNC,
ARG_STRING_FUNC
};
GtkType
e_reflow_sorted_get_type (void)
{
static GtkType reflow_type = 0;
if (!reflow_type)
{
static const GtkTypeInfo reflow_info =
{
"EReflowSorted",
sizeof (EReflowSorted),
sizeof (EReflowSortedClass),
(GtkClassInitFunc) e_reflow_sorted_class_init,
(GtkObjectInitFunc) e_reflow_sorted_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
reflow_type = gtk_type_unique (e_reflow_get_type (), &reflow_info);
}
return reflow_type;
}
static void
e_reflow_sorted_class_init (EReflowSortedClass *klass)
{
GtkObjectClass *object_class;
EReflowClass *reflow_class;
object_class = (GtkObjectClass*) klass;
reflow_class = E_REFLOW_CLASS (klass);
parent_class = gtk_type_class (e_reflow_get_type ());
gtk_object_add_arg_type ("EReflowSorted::compare_func", GTK_TYPE_POINTER,
GTK_ARG_READWRITE, ARG_COMPARE_FUNC);
gtk_object_add_arg_type ("EReflowSorted::string_func", GTK_TYPE_POINTER,
GTK_ARG_READWRITE, ARG_STRING_FUNC);
reflow_class->add_item = e_reflow_sorted_add_item;
object_class->set_arg = e_reflow_sorted_set_arg;
object_class->get_arg = e_reflow_sorted_get_arg;
}
static void
e_reflow_sorted_init (EReflowSorted *reflow)
{
reflow->compare_func = NULL;
reflow->string_func = NULL;
}
static void
e_reflow_sorted_set_arg (GtkObject *o, GtkArg *arg, guint arg_id)
{
GnomeCanvasItem *item;
EReflowSorted *e_reflow_sorted;
item = GNOME_CANVAS_ITEM (o);
e_reflow_sorted = E_REFLOW_SORTED (o);
switch (arg_id){
case ARG_COMPARE_FUNC:
e_reflow_sorted->compare_func = GTK_VALUE_POINTER (*arg);
break;
case ARG_STRING_FUNC:
e_reflow_sorted->string_func = GTK_VALUE_POINTER (*arg);
break;
}
}
static void
e_reflow_sorted_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
EReflowSorted *e_reflow_sorted;
e_reflow_sorted = E_REFLOW_SORTED (object);
switch (arg_id) {
case ARG_COMPARE_FUNC:
GTK_VALUE_POINTER (*arg) = e_reflow_sorted->compare_func;
break;
case ARG_STRING_FUNC:
GTK_VALUE_POINTER (*arg) = e_reflow_sorted->string_func;
break;
default:
arg->type = GTK_TYPE_INVALID;
break;
}
}
void
e_reflow_sorted_remove_item(EReflowSorted *e_reflow_sorted, const gchar *id)
{
if (e_reflow_sorted->string_func) {
EReflow *reflow = E_REFLOW(e_reflow_sorted);
GList *list;
for (list = reflow->items; list; list = g_list_next(list)) {
GnomeCanvasItem *item = list->data;
char *string = e_reflow_sorted->string_func (item);
if (string && !strcmp(string, id)) {
reflow->items = g_list_remove_link(reflow->items, list);
g_list_free_1(list);
gtk_object_destroy(GTK_OBJECT(item));
if ( GTK_OBJECT_FLAGS( e_reflow_sorted ) & GNOME_CANVAS_ITEM_REALIZED ) {
e_canvas_item_request_reflow(item);
}
return;
}
}
}
}
void
e_reflow_sorted_replace_item(EReflowSorted *e_reflow_sorted, GnomeCanvasItem *item)
{
if (e_reflow_sorted->string_func) {
char *string = e_reflow_sorted->string_func (item);
e_reflow_sorted_remove_item(e_reflow_sorted, string);
e_reflow_sorted_add_item(E_REFLOW(e_reflow_sorted), item);
}
}
static void
e_reflow_sorted_add_item(EReflow *reflow, GnomeCanvasItem *item)
{
EReflowSorted *e_reflow_sorted = E_REFLOW_SORTED(reflow);
if ( e_reflow_sorted->compare_func ) {
reflow->items = g_list_insert_sorted(reflow->items, item, e_reflow_sorted->compare_func);
if ( GTK_OBJECT_FLAGS( e_reflow_sorted ) & GNOME_CANVAS_ITEM_REALIZED ) {
gnome_canvas_item_set(item,
"width", (double) reflow->column_width,
NULL);
e_canvas_item_request_reflow(item);
}
}
}

87
widgets/e-reflow/e-reflow-sorted.h Normal file
View File

@ -0,0 +1,87 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* e-reflow-sorted.h
* Copyright (C) 2000 Helix Code, Inc.
* Author: Chris Lahey <clahey@helixcode.com>
*
* This library 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 library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __E_REFLOW_SORTED_H__
#define __E_REFLOW_SORTED_H__
#include <e-reflow.h>
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus */
/* EReflowSorted - A canvas item container.
*
* The following arguments are available:
*
* name type read/write description
* --------------------------------------------------------------------------------
* compare_func GCompareFunc RW compare function
* string_func EReflowStringFunc RW string function
*
* From EReflow:
* minimum_width double RW minimum width of the reflow. width >= minimum_width
* width double R width of the reflow
* height double RW height of the reflow
*/
#define E_REFLOW_SORTED_TYPE (e_reflow_sorted_get_type ())
#define E_REFLOW_SORTED(obj) (GTK_CHECK_CAST ((obj), E_REFLOW_SORTED_TYPE, EReflowSorted))
#define E_REFLOW_SORTED_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), E_REFLOW_SORTED_TYPE, EReflowSortedClass))
#define E_IS_REFLOW_SORTED(obj) (GTK_CHECK_TYPE ((obj), E_REFLOW_SORTED_TYPE))
#define E_IS_REFLOW_SORTED_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((obj), E_REFLOW_SORTED_TYPE))
typedef char * (* EReflowStringFunc) (GnomeCanvasItem *);
typedef struct _EReflowSorted EReflowSorted;
typedef struct _EReflowSortedClass EReflowSortedClass;
/* FIXME: Try reimplementing this as a hash table with key as string
and change EReflow to use a GTree. */
struct _EReflowSorted
{
EReflow parent;
/* item specific fields */
GCompareFunc compare_func;
EReflowStringFunc string_func;
};
struct _EReflowSortedClass
{
EReflowClass parent_class;
};
/*
* To be added to a reflow, an item must have the argument "width" as
* a Read/Write argument and "height" as a Read Only argument. It
* should also do an ECanvas parent reflow request if its size
* changes.
*/
void e_reflow_sorted_remove_item (EReflowSorted *sorted, const char *id);
void e_reflow_sorted_replace_item (EReflowSorted *sorted, GnomeCanvasItem *item);
GtkType e_reflow_sorted_get_type (void);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __E_REFLOW_SORTED_H__ */

36
widgets/e-reflow/e-reflow.c
View File

@ -26,10 +26,11 @@
#include "e-canvas-utils.h"
#include "e-canvas.h"
#include "e-util.h"
static void e_reflow_init (EReflow *card);
static void e_reflow_init (EReflow *reflow);
static void e_reflow_class_init (EReflowClass *klass);
static void e_reflow_set_arg (GtkObject *o, GtkArg *arg, guint arg_id);
static void e_reflow_get_arg (GtkObject *object, GtkArg *arg, guint arg_id);
static void e_reflow_destroy (GtkObject *object);
static gboolean e_reflow_event (GnomeCanvasItem *item, GdkEvent *event);
static void e_reflow_realize (GnomeCanvasItem *item);
static void e_reflow_unrealize (GnomeCanvasItem *item);
@ -38,6 +39,7 @@ static void e_reflow_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
static void e_reflow_update (GnomeCanvasItem *item, double affine[6], ArtSVP *clip_path, gint flags);
static double e_reflow_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item);
static void e_reflow_reflow (GnomeCanvasItem *item, int flags);
static void e_reflow_real_add_item(EReflow *e_reflow, GnomeCanvasItem *item);
static void e_reflow_resize_children (GnomeCanvasItem *item);
@ -97,10 +99,12 @@ e_reflow_class_init (EReflowClass *klass)
GTK_ARG_READABLE, ARG_WIDTH);
gtk_object_add_arg_type ("EReflow::height", GTK_TYPE_DOUBLE,
GTK_ARG_READWRITE, ARG_HEIGHT);
klass->add_item = e_reflow_real_add_item;
object_class->set_arg = e_reflow_set_arg;
object_class->get_arg = e_reflow_get_arg;
/* object_class->destroy = e_reflow_destroy; */
object_class->set_arg = e_reflow_set_arg;
object_class->get_arg = e_reflow_get_arg;
object_class->destroy = e_reflow_destroy;
/* GnomeCanvasItem method overrides */
item_class->event = e_reflow_event;
@ -114,7 +118,6 @@ e_reflow_class_init (EReflowClass *klass)
static void
e_reflow_init (EReflow *reflow)
{
/* reflow->card = NULL;*/
reflow->items = NULL;
reflow->columns = NULL;
reflow->column_width = 150;
@ -180,6 +183,14 @@ e_reflow_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
}
}
static void
e_reflow_destroy (GtkObject *object)
{
EReflow *reflow = E_REFLOW(object);
g_list_free(reflow->items);
}
static void
e_reflow_realize (GnomeCanvasItem *item)
{
@ -228,9 +239,11 @@ e_reflow_unrealize (GnomeCanvasItem *item)
gdk_cursor_destroy (e_reflow->arrow_cursor);
gdk_cursor_destroy (e_reflow->default_cursor);
e_reflow->arrow_cursor = NULL;
e_reflow->default_cursor = NULL;
g_list_free (e_reflow->items);
g_list_free (e_reflow->columns);
e_reflow->columns = NULL;
if (GNOME_CANVAS_ITEM_CLASS(parent_class)->unrealize)
(* GNOME_CANVAS_ITEM_CLASS(parent_class)->unrealize) (item);
@ -428,8 +441,8 @@ e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
return 0;
}
void
e_reflow_add_item(EReflow *e_reflow, GnomeCanvasItem *item)
static void
e_reflow_real_add_item(EReflow *e_reflow, GnomeCanvasItem *item)
{
e_reflow->items = g_list_append(e_reflow->items, item);
if ( GTK_OBJECT_FLAGS( e_reflow ) & GNOME_CANVAS_ITEM_REALIZED ) {
@ -747,3 +760,10 @@ e_reflow_reflow( GnomeCanvasItem *item, int flags )
e_canvas_item_request_parent_reflow(item);
}
}
void
e_reflow_add_item(EReflow *e_reflow, GnomeCanvasItem *item)
{
if (E_REFLOW_CLASS(GTK_OBJECT(e_reflow)->klass)->add_item)
(E_REFLOW_CLASS(GTK_OBJECT(e_reflow)->klass)->add_item) (e_reflow, item);
}

16
widgets/e-reflow/e-reflow.h
View File

@ -54,10 +54,8 @@ struct _EReflow
GnomeCanvasGroup parent;
/* item specific fields */
/* EBook *book; */
GList *items; /* Of type GnomeCanvasItem */
GList *columns; /* Of type GList pointing to type GnomeCanvasItem (points into items) */
GList *columns; /* Of type GList of type GnomeCanvasItem (points into items) */
gint column_count; /* Number of columnns */
double minimum_width;
@ -87,12 +85,16 @@ struct _EReflowClass
{
GnomeCanvasGroupClass parent_class;
void (* resize) (EReflow *reflow);
/* Virtual methods. */
void (* add_item) (EReflow *reflow, GnomeCanvasItem *item);
};
/* To be added to a reflow, an item must have the arguments "x", "y",
and "width" as Read/Write arguments and "height" as a Read Only
argument. It must also have a "resize" signal. */
/*
* To be added to a reflow, an item must have the argument "width" as
* a Read/Write argument and "height" as a Read Only argument. It
* should also do an ECanvas parent reflow request if its size
* changes.
*/
void e_reflow_add_item(EReflow *e_reflow, GnomeCanvasItem *item);
GtkType e_reflow_get_type (void);

36
widgets/misc/e-reflow.c
View File

@ -26,10 +26,11 @@
#include "e-canvas-utils.h"
#include "e-canvas.h"
#include "e-util.h"
static void e_reflow_init (EReflow *card);
static void e_reflow_init (EReflow *reflow);
static void e_reflow_class_init (EReflowClass *klass);
static void e_reflow_set_arg (GtkObject *o, GtkArg *arg, guint arg_id);
static void e_reflow_get_arg (GtkObject *object, GtkArg *arg, guint arg_id);
static void e_reflow_destroy (GtkObject *object);
static gboolean e_reflow_event (GnomeCanvasItem *item, GdkEvent *event);
static void e_reflow_realize (GnomeCanvasItem *item);
static void e_reflow_unrealize (GnomeCanvasItem *item);
@ -38,6 +39,7 @@ static void e_reflow_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
static void e_reflow_update (GnomeCanvasItem *item, double affine[6], ArtSVP *clip_path, gint flags);
static double e_reflow_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item);
static void e_reflow_reflow (GnomeCanvasItem *item, int flags);
static void e_reflow_real_add_item(EReflow *e_reflow, GnomeCanvasItem *item);
static void e_reflow_resize_children (GnomeCanvasItem *item);
@ -97,10 +99,12 @@ e_reflow_class_init (EReflowClass *klass)
GTK_ARG_READABLE, ARG_WIDTH);
gtk_object_add_arg_type ("EReflow::height", GTK_TYPE_DOUBLE,
GTK_ARG_READWRITE, ARG_HEIGHT);
klass->add_item = e_reflow_real_add_item;
object_class->set_arg = e_reflow_set_arg;
object_class->get_arg = e_reflow_get_arg;
/* object_class->destroy = e_reflow_destroy; */
object_class->set_arg = e_reflow_set_arg;
object_class->get_arg = e_reflow_get_arg;
object_class->destroy = e_reflow_destroy;
/* GnomeCanvasItem method overrides */
item_class->event = e_reflow_event;
@ -114,7 +118,6 @@ e_reflow_class_init (EReflowClass *klass)
static void
e_reflow_init (EReflow *reflow)
{
/* reflow->card = NULL;*/
reflow->items = NULL;
reflow->columns = NULL;
reflow->column_width = 150;
@ -180,6 +183,14 @@ e_reflow_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
}
}
static void
e_reflow_destroy (GtkObject *object)
{
EReflow *reflow = E_REFLOW(object);
g_list_free(reflow->items);
}
static void
e_reflow_realize (GnomeCanvasItem *item)
{
@ -228,9 +239,11 @@ e_reflow_unrealize (GnomeCanvasItem *item)
gdk_cursor_destroy (e_reflow->arrow_cursor);
gdk_cursor_destroy (e_reflow->default_cursor);
e_reflow->arrow_cursor = NULL;
e_reflow->default_cursor = NULL;
g_list_free (e_reflow->items);
g_list_free (e_reflow->columns);
e_reflow->columns = NULL;
if (GNOME_CANVAS_ITEM_CLASS(parent_class)->unrealize)
(* GNOME_CANVAS_ITEM_CLASS(parent_class)->unrealize) (item);
@ -428,8 +441,8 @@ e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
return 0;
}
void
e_reflow_add_item(EReflow *e_reflow, GnomeCanvasItem *item)
static void
e_reflow_real_add_item(EReflow *e_reflow, GnomeCanvasItem *item)
{
e_reflow->items = g_list_append(e_reflow->items, item);
if ( GTK_OBJECT_FLAGS( e_reflow ) & GNOME_CANVAS_ITEM_REALIZED ) {
@ -747,3 +760,10 @@ e_reflow_reflow( GnomeCanvasItem *item, int flags )
e_canvas_item_request_parent_reflow(item);
}
}
void
e_reflow_add_item(EReflow *e_reflow, GnomeCanvasItem *item)
{
if (E_REFLOW_CLASS(GTK_OBJECT(e_reflow)->klass)->add_item)
(E_REFLOW_CLASS(GTK_OBJECT(e_reflow)->klass)->add_item) (e_reflow, item);
}

16
widgets/misc/e-reflow.h
View File

@ -54,10 +54,8 @@ struct _EReflow
GnomeCanvasGroup parent;
/* item specific fields */
/* EBook *book; */
GList *items; /* Of type GnomeCanvasItem */
GList *columns; /* Of type GList pointing to type GnomeCanvasItem (points into items) */
GList *columns; /* Of type GList of type GnomeCanvasItem (points into items) */
gint column_count; /* Number of columnns */
double minimum_width;
@ -87,12 +85,16 @@ struct _EReflowClass
{
GnomeCanvasGroupClass parent_class;
void (* resize) (EReflow *reflow);
/* Virtual methods. */
void (* add_item) (EReflow *reflow, GnomeCanvasItem *item);
};
/* To be added to a reflow, an item must have the arguments "x", "y",
and "width" as Read/Write arguments and "height" as a Read Only
argument. It must also have a "resize" signal. */
/*
* To be added to a reflow, an item must have the argument "width" as
* a Read/Write argument and "height" as a Read Only argument. It
* should also do an ECanvas parent reflow request if its size
* changes.
*/
void e_reflow_add_item(EReflow *e_reflow, GnomeCanvasItem *item);
GtkType e_reflow_get_type (void);