static void eel_canvas_rect_finalize (GObject *object);

static void eel_canvas_rect_realize (EelCanvasItem *item);

static void eel_canvas_rect_draw (EelCanvasItem *item, GdkDrawable *drawable, GdkEventExpose *expose);

static double eel_canvas_rect_point (EelCanvasItem *item, double x, double y, int cx, int cy,

EelCanvasItem **actual_item);

#define DASH_ON 0.8

#define DASH_OFF 1.7

static void

eel_canvas_rect_draw (EelCanvasItem *item, GdkDrawable *drawable, GdkEventExpose *expose)

{

EelCanvasRE *re;

double x1, y1, x2, y2;

int cx1, cy1, cx2, cy2;

double i2w_dx, i2w_dy;

return;

}

gdk_cairo_region (cr, expose->region);

cairo_clip (cr);

if (re->fill_set)

{

cairo_stroke (cr);

}

cairo_destroy (cr);

}

static double

static void eel_canvas_ellipse_class_init (EelCanvasEllipseClass *klass);

static void eel_canvas_ellipse_draw (EelCanvasItem *item, GdkDrawable *drawable, GdkEventExpose *expose);

static double eel_canvas_ellipse_point (EelCanvasItem *item, double x, double y, int cx, int cy,

EelCanvasItem **actual_item);

}

static void

eel_canvas_ellipse_draw (EelCanvasItem *item, GdkDrawable *drawable, GdkEventExpose *expose)

{

EelCanvasRE *re;

int x1, y1, x2, y2;

double i2w_dx, i2w_dy;

re = EEL_CANVAS_RE (item);

re->y2 + i2w_dy,

&x2, &y2);

gdk_cairo_region (cr, expose->region);

cairo_clip (cr);

cairo_save (cr);

cairo_translate (cr, (x1 + x2) / 2., (y1 + y2) / 2.);

cairo_stroke_preserve (cr);

}

cairo_destroy (cr);

}

static double

#include <gdk/gdkprivate.h>

#include <gtk/gtk.h>

#include <glib/gi18n-lib.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);

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);

/* 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;

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

}

}

}

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;

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;

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,

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,

{

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

gdk_cairo_set_source_color (cr, &gtk_widget_get_style (GTK_WIDGET (canvas))->bg[GTK_STATE_NORMAL]);

cairo_destroy (cr);

}

static void

do_update (EelCanvas *canvas)

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);

* coordinates of the drawable, a temporary pixmap, where things get

* drawn. (width, height) are the dimensions of the drawable.

*/

void (* draw) (EelCanvasItem *item, GdkDrawable *drawable, GdkEventExpose *expose);

/* Calculate the distance from an item to the specified point. It also

* returns a canvas item which is the item itself in the case of the

/* Draw the background for the area given.

*/

void (* draw_background) (EelCanvas *canvas,

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

/* Private Virtual methods for groping the canvas inside matecomponent */

void (* request_update) (EelCanvas *canvas);