#include <stdio.h>

#include <gdk/gdkprivate.h>

#include <gtk/gtk.h>

#include "eel-canvas.h"

#include "eel-marshal.h"

static void eel_canvas_request_update (EelCanvas *canvas);

static void group_add (EelCanvasGroup *group,

EelCanvasItem *item);

enum

{

ITEM_EVENT,

ITEM_LAST_SIGNAL

};

static guint item_signals[ITEM_LAST_SIGNAL];

static gpointer accessible_item_parent_class;

static gpointer accessible_parent_class;

(GInstanceInitFunc) eel_canvas_item_init

};

}

return canvas_item_type;

item->canvas = NULL;

}

G_OBJECT_CLASS (item_parent_class)->dispose (object);

}

/* Realize handler for canvas items */

static void

GValue *value,

GParamSpec *pspec);

static void eel_canvas_group_update (EelCanvasItem *item,

double i2w_dx,

static void eel_canvas_group_unrealize (EelCanvasItem *item);

static void eel_canvas_group_map (EelCanvasItem *item);

static void eel_canvas_group_unmap (EelCanvasItem *item);

static void eel_canvas_group_draw (EelCanvasItem *item, GdkDrawable *drawable,

GdkEventExpose *expose);

static double eel_canvas_group_point (EelCanvasItem *item, double x, double y,

int cx, int cy,

EelCanvasItem **actual_item);

eel_canvas_group_class_init (EelCanvasGroupClass *klass)

{

GObjectClass *gobject_class;

EelCanvasItemClass *item_class;

gobject_class = (GObjectClass *) klass;

item_class = (EelCanvasItemClass *) klass;

group_parent_class = g_type_class_peek_parent (klass);

-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,

G_PARAM_READWRITE));

item_class->update = eel_canvas_group_update;

item_class->unrealize = eel_canvas_group_unrealize;

item_class->map = eel_canvas_group_map;

/* Destroy handler for canvas groups */

static void

{

EelCanvasGroup *group;

EelCanvasItem *child;

child = list->data;

list = list->next;

}

}

/* Update handler for canvas groups */

/* Draw handler for canvas groups */

static void

eel_canvas_group_draw (EelCanvasItem *item, GdkDrawable *drawable,

GdkEventExpose *expose)

{

EelCanvasGroup *group;

GList *list;

child_rect.width = child->x2 - child->x1 + 1;

child_rect.height = child->y2 - child->y1 + 1;

if (gdk_region_rect_in (expose->region, &child_rect) != GDK_OVERLAP_RECTANGLE_OUT)

(* EEL_CANVAS_ITEM_GET_CLASS (child)->draw) (child, drawable, expose);

}

}

}

static void

group_add (EelCanvasGroup *group, EelCanvasItem *item)

{

g_object_ref_sink (item);

if (!group->item_list)

{

static void eel_canvas_class_init (EelCanvasClass *klass);

static void eel_canvas_init (EelCanvas *canvas);

static void eel_canvas_destroy (GtkObject *object);

static void eel_canvas_map (GtkWidget *widget);

static void eel_canvas_unmap (GtkWidget *widget);

static void eel_canvas_realize (GtkWidget *widget);

GdkEventButton *event);

static gint eel_canvas_motion (GtkWidget *widget,

GdkEventMotion *event);

static gint eel_canvas_expose (GtkWidget *widget,

GdkEventExpose *event);

static gint eel_canvas_key (GtkWidget *widget,

GdkEventKey *event);

static gint eel_canvas_crossing (GtkWidget *widget,

GdkEventFocus *event);

static void eel_canvas_request_update_real (EelCanvas *canvas);

static void eel_canvas_draw_background (EelCanvas *canvas,

int x,

int y,

int width,

int height);

static GtkLayoutClass *canvas_parent_class;

ATK_OBJECT_CLASS (accessible_parent_class)->initialize (obj, data);

canvas = EEL_CANVAS (data);

"value_changed",

G_CALLBACK (eel_canvas_accessible_adjustment_changed),

obj);

"value_changed",

G_CALLBACK (eel_canvas_accessible_adjustment_changed),

obj);

eel_canvas_class_init (EelCanvasClass *klass)

{

GObjectClass *gobject_class;

GtkWidgetClass *widget_class;

gobject_class = (GObjectClass *)klass;

widget_class = (GtkWidgetClass *) klass;

canvas_parent_class = g_type_class_peek_parent (klass);

gobject_class->set_property = eel_canvas_set_property;

gobject_class->get_property = eel_canvas_get_property;

widget_class->map = eel_canvas_map;

widget_class->unmap = eel_canvas_unmap;

widget_class->realize = eel_canvas_realize;

widget_class->button_press_event = eel_canvas_button;

widget_class->button_release_event = eel_canvas_button;

widget_class->motion_notify_event = eel_canvas_motion;

widget_class->expose_event = eel_canvas_expose;

widget_class->key_press_event = eel_canvas_key;

widget_class->key_release_event = eel_canvas_key;

widget_class->enter_notify_event = eel_canvas_crossing;

canvas_signals[DRAW_BACKGROUND] =

g_signal_new ("draw_background",

G_SIGNAL_RUN_LAST,

G_STRUCT_OFFSET (EelCanvasClass, draw_background),

NULL, NULL,

eel_marshal_VOID__INT_INT_INT_INT,

G_TYPE_NONE, 4,

G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT);

atk_registry_set_factory_type (atk_get_default_registry (),

EEL_TYPE_CANVAS,

* never ever do this, so we panic if this happens.

*/

static void

{

g_error ("Eeeek, root item %p of canvas %p was destroyed!", object, data);

}

canvas->scroll_x1 = 0.0;

canvas->scroll_y1 = 0.0;

&width, &height);

canvas->scroll_x2 = width;

canvas->scroll_y2 = height;

canvas->pick_event.crossing.x = 0;

canvas->pick_event.crossing.y = 0;

/* Create the root item as a special case */

canvas->root = EEL_CANVAS_ITEM (g_object_new (eel_canvas_group_get_type (), NULL));

canvas->root->canvas = canvas;

g_object_ref_sink (canvas->root);

canvas->root_destroy_id = g_signal_connect (G_OBJECT (canvas->root),

"destroy", G_CALLBACK (panic_root_destroyed), canvas);

/* Destroy handler for EelCanvas */

static void

eel_canvas_destroy (GtkObject *object)

{

EelCanvas *canvas;

{

EelCanvasItem *root = canvas->root;

canvas->root = NULL;

g_object_unref (root);

}

shutdown_transients (canvas);

if (GTK_OBJECT_CLASS (canvas_parent_class)->destroy)

(* GTK_OBJECT_CLASS (canvas_parent_class)->destroy) (object);

}

/**

canvas = EEL_CANVAS (widget);

| GDK_EXPOSURE_MASK

| GDK_BUTTON_PRESS_MASK

| GDK_BUTTON_RELEASE_MASK

/* Create our own temporary pixmap gc and realize all the items */

(* EEL_CANVAS_ITEM_GET_CLASS (canvas->root)->realize) (canvas->root);

}

(* EEL_CANVAS_ITEM_GET_CLASS (canvas->root)->unrealize) (canvas->root);

if (GTK_WIDGET_CLASS (canvas_parent_class)->unrealize)

(* GTK_WIDGET_CLASS (canvas_parent_class)->unrealize) (widget);

}

gtk_widget_queue_draw (GTK_WIDGET (canvas));

}

if (((int) gtk_adjustment_get_value (hadjustment)) != cx)

{

/* Recenter the view, if appropriate */

gtk_adjustment_set_page_size (hadjustment, allocation->width);

gtk_adjustment_set_page_increment (hadjustment, allocation->width / 2);

while (item && !finished)

{

g_signal_emit (

G_OBJECT (item), item_signals[ITEM_EVENT], 0,

&ev, &finished);

parent = item->parent;

item = parent;

}

* dispatch normally regardless of the event's window if an item has

* has a pointer grab in effect

*/

return retval;

switch (event->button)

canvas = EEL_CANVAS (widget);

return FALSE;

canvas->state = event->state;

canvas = EEL_CANVAS (widget);

return FALSE;

canvas->state = event->state;

return FALSE;

}

/* Expose handler for the canvas */

static gint

eel_canvas_expose (GtkWidget *widget, GdkEventExpose *event)

{

if (!gtk_widget_is_drawable (widget) || (event->window != gtk_layout_get_bin_window (&canvas->layout))) return FALSE;

#endif

/* If there are any outstanding items that need updating, do them now */

if (canvas->idle_id)

/* Hmmm. Would like to queue antiexposes if the update marked

anything that is gonna get redrawn as invalid */

g_signal_emit (G_OBJECT (canvas), canvas_signals[DRAW_BACKGROUND], 0,

event->area.x, event->area.y,

event->area.width, event->area.height);

if (canvas->root->flags & EEL_CANVAS_ITEM_MAPPED)

/* Chain up to get exposes on child widgets */

GTK_WIDGET_CLASS (canvas_parent_class)->expose_event (widget, event);

return FALSE;

}

static void

eel_canvas_draw_background (EelCanvas *canvas,

int x, int y, int width, int height)

{

/* By default, we use the style background. */

}

static void

do_update (EelCanvas *canvas)

* Set the new scrolling region. If possible, do not move the visible contents of the

* canvas.

*/

eel_canvas_c2w (canvas,

gtk_adjustment_get_value (hadjustment) + canvas->zoom_xofs,

canvas->center_scroll_region = center_scroll_region != 0;

scroll_to (canvas,

gtk_adjustment_get_value (hadjustment),

center_y = allocation.height / 2;

/* Find the coordinates of the screen center in units. */

cx = (gtk_adjustment_get_value (hadjustment) + center_x) / canvas->pixels_per_unit + canvas->scroll_x1 + canvas->zoom_xofs;

cy = (gtk_adjustment_get_value (vadjustment) + center_y) / canvas->pixels_per_unit + canvas->scroll_y1 + canvas->zoom_yofs;

attributes.height = allocation.height;

attributes.wclass = GDK_INPUT_OUTPUT;

attributes.visual = gtk_widget_get_visual (widget);

attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;

attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;

window = gdk_window_new (gtk_widget_get_parent_window (widget),

&attributes, attributes_mask);

gdk_window_set_back_pixmap (window, NULL, FALSE);

gdk_window_set_user_data (window, widget);

gdk_window_show (window);

g_return_if_fail (EEL_IS_CANVAS (canvas));

if (cx)

*cx = gtk_adjustment_get_value (hadjustment);

bbox.width = x2 - x1;

bbox.height = y2 - y1;

&bbox, FALSE);

}

int

eel_canvas_get_color (EelCanvas *canvas, const char *spec, GdkColor *color)

{

g_return_val_if_fail (EEL_IS_CANVAS (canvas), FALSE);

g_return_val_if_fail (color != NULL, FALSE);

gdk_color_parse (spec, color);

return TRUE;

}

static gboolean

boolean_handled_accumulator (GSignalInvocationHint *ihint,

GValue *return_accu,

GTypeInfo tinfo = { 0 };

factory = atk_registry_get_factory (atk_get_default_registry(),

if (!factory)

{

return G_TYPE_INVALID;

G_TYPE_BOOLEAN, 1,

GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);

klass->realize = eel_canvas_item_realize;

klass->unrealize = eel_canvas_item_unrealize;

klass->map = eel_canvas_item_map;