diff options
Diffstat (limited to 'calendar/gncal-full-day.c')
| -rw-r--r-- | calendar/gncal-full-day.c | 902 |
1 files changed, 831 insertions, 71 deletions
diff --git a/calendar/gncal-full-day.c b/calendar/gncal-full-day.c index ba646d5a2e..b6a61a3a9d 100644 --- a/calendar/gncal-full-day.c +++ b/calendar/gncal-full-day.c @@ -6,26 +6,453 @@ */ #include <gtk/gtkdrawingarea.h> +#include <gtk/gtktext.h> #include "gncal-full-day.h" +#include "view-utils.h" #define TEXT_BORDER 2 +#define HANDLE_SIZE 3 #define MIN_WIDTH 200 +#define XOR_RECT_WIDTH 2 + + +typedef struct { + iCalObject *ico; + GtkWidget *widget; + GdkWindow *window; + int lower_row; /* zero is first displayed row */ + int rows_used; + int x; /* coords of child's window */ + int y; + int width; + int height; +} Child; + +struct layout_row { + int intersections; + int *slots; +}; + +struct drag_info { + Child *child; + enum { + DRAG_MOVE, + DRAG_SIZE + } drag_mode; + int new_y; + int new_height; +}; + + +static void gncal_full_day_class_init (GncalFullDayClass *class); +static void gncal_full_day_init (GncalFullDay *fullday); +static void gncal_full_day_destroy (GtkObject *object); +static void gncal_full_day_map (GtkWidget *widget); +static void gncal_full_day_unmap (GtkWidget *widget); +static void gncal_full_day_realize (GtkWidget *widget); +static void gncal_full_day_unrealize (GtkWidget *widget); +static void gncal_full_day_draw (GtkWidget *widget, + GdkRectangle *area); +static void gncal_full_day_size_request (GtkWidget *widget, + GtkRequisition *requisition); +static void gncal_full_day_size_allocate (GtkWidget *widget, + GtkAllocation *allocation); +static gint gncal_full_day_button_press (GtkWidget *widget, + GdkEventButton *event); +static gint gncal_full_day_button_release (GtkWidget *widget, + GdkEventButton *event); +static gint gncal_full_day_motion (GtkWidget *widget, + GdkEventMotion *event); +static gint gncal_full_day_expose (GtkWidget *widget, + GdkEventExpose *event); +static void gncal_full_day_foreach (GtkContainer *container, + GtkCallback callback, + gpointer callback_data); -static void gncal_full_day_class_init (GncalFullDayClass *class); -static void gncal_full_day_init (GncalFullDay *fullday); -static void gncal_full_day_realize (GtkWidget *widget); -static void gncal_full_day_size_request (GtkWidget *widget, - GtkRequisition *requisition); -static void gncal_full_day_size_allocate (GtkWidget *widget, - GtkAllocation *allocation); -static gint gncal_full_day_expose (GtkWidget *widget, - GdkEventExpose *event); +static GtkContainerClass *parent_class; -static GtkContainerClass *parent_class; +static void +get_tm_range (GncalFullDay *fullday, + time_t time_lower, time_t time_upper, + struct tm *lower, struct tm *upper, + int *lower_row, int *rows_used) +{ + struct tm tm_lower, tm_upper; + int lmin, umin; + int lrow; + + /* Lower */ + + tm_lower = *localtime (&time_lower); + + if ((tm_lower.tm_min % fullday->interval) != 0) { + tm_lower.tm_min -= tm_lower.tm_min % fullday->interval; /* round down */ + mktime (&tm_lower); + } + + /* Upper */ + + tm_upper = *localtime (&time_upper); + + if ((tm_upper.tm_min % fullday->interval) != 0) { + tm_upper.tm_min += fullday->interval - (tm_upper.tm_min % fullday->interval); /* round up */ + mktime (&tm_upper); + } + + if (lower) + *lower = tm_lower; + + if (upper) + *upper = tm_upper; + + lmin = 60 * tm_lower.tm_hour + tm_lower.tm_min; + umin = 60 * tm_upper.tm_hour + tm_upper.tm_min; + + if (umin == 0) /* midnight of next day? */ + umin = 60 * 24; + + lrow = lmin / fullday->interval; + + if (lower_row) + *lower_row = lrow; + + if (rows_used) + *rows_used = (umin - lmin) / fullday->interval; +} + +static void +child_map (GncalFullDay *fullday, Child *child) +{ + gdk_window_show (child->window); + + if (GTK_WIDGET_VISIBLE (child->widget) && !GTK_WIDGET_MAPPED (child->widget)) + gtk_widget_map (child->widget); +} + +static void +child_unmap (GncalFullDay *fullday, Child *child) +{ + gdk_window_hide (child->window); + + if (GTK_WIDGET_VISIBLE (child->widget) && GTK_WIDGET_MAPPED (child->widget)) + gtk_widget_unmap (child->widget); +} + +static void +child_move_text (Child *child) +{ + GtkAllocation allocation; + + allocation.x = 0; + allocation.y = HANDLE_SIZE; + allocation.width = child->width; + allocation.height = child->height - 2 * HANDLE_SIZE; + + gtk_widget_size_request (child->widget, &child->widget->requisition); /* FIXME: is this needed? */ + gtk_widget_size_allocate (child->widget, &allocation); +} + +static void +child_realize (GncalFullDay *fullday, Child *child) +{ + GdkWindowAttr attributes; + gint attributes_mask; + GtkWidget *widget; + + widget = GTK_WIDGET (fullday); + + attributes.window_type = GDK_WINDOW_CHILD; + attributes.x = child->x; + attributes.y = child->y; + attributes.width = child->width; + attributes.height = child->height; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gtk_widget_get_visual (widget); + attributes.colormap = gtk_widget_get_colormap (widget); + attributes.cursor = fullday->up_down_cursor; + attributes.event_mask = (GDK_EXPOSURE_MASK + | GDK_BUTTON_PRESS_MASK + | GDK_BUTTON_RELEASE_MASK + | GDK_BUTTON_MOTION_MASK + | GDK_POINTER_MOTION_HINT_MASK); + + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP | GDK_WA_CURSOR; + + child->window = gdk_window_new (widget->window, &attributes, attributes_mask); + gdk_window_set_user_data (child->window, widget); + + gtk_style_set_background (widget->style, child->window, GTK_STATE_NORMAL); + + gtk_widget_set_parent_window (child->widget, child->window); + + child_move_text (child); +} + +static void +child_unrealize (GncalFullDay *fullday, Child *child) +{ + gdk_window_set_user_data (child->window, NULL); + gdk_window_destroy (child->window); + child->window = NULL; +} + +static void +child_draw (GncalFullDay *fullday, Child *child, GdkRectangle *area, int draw_child) +{ + GdkRectangle arect, rect, dest; + gint w, h; + + gdk_window_get_size (child->window, &w, &h); + + if (!area) { + arect.x = 0; + arect.y = 0; + + arect.width = w; + arect.height = h; + + area = &arect; + } + + /* Top handle */ + + rect.x = 0; + rect.y = 0; + rect.width = w; + rect.height = HANDLE_SIZE; + + if (gdk_rectangle_intersect (&rect, area, &dest)) + view_utils_draw_textured_frame (GTK_WIDGET (fullday), child->window, &rect, GTK_SHADOW_OUT); + + /* Bottom handle */ + + rect.y = h - HANDLE_SIZE; + + if (gdk_rectangle_intersect (&rect, area, &dest)) + view_utils_draw_textured_frame (GTK_WIDGET (fullday), child->window, &rect, GTK_SHADOW_OUT); + + if (draw_child) { + area->y -= HANDLE_SIZE; + gtk_widget_draw (child->widget, area); + } +} + +static void +child_set_beam_cursor (GtkWidget *widget, gpointer data) +{ + GncalFullDay *fullday = data; + + gdk_window_set_cursor (widget->window, fullday->beam_cursor); +} + +static Child * +child_new (GncalFullDay *fullday, iCalObject *ico) +{ + Child *child; + struct tm start, end; + int lower_row, rows_used; + int f_lower_row; + + child = g_new (Child, 1); + + child->ico = ico; + child->widget = gtk_text_new (NULL, NULL); + child->window = NULL; + child->x = 0; + child->y = 0; + child->width = 0; + child->height = 0; + + /* Calc display range for event */ + + get_tm_range (fullday, child->ico->dtstart, child->ico->dtend, &start, &end, &lower_row, &rows_used); + get_tm_range (fullday, fullday->lower, fullday->upper, NULL, NULL, &f_lower_row, NULL); + + child->lower_row = lower_row - f_lower_row; + child->rows_used = rows_used; + + /* Finish setup */ + + gtk_signal_connect (GTK_OBJECT (child->widget), "realize", + (GtkSignalFunc) child_set_beam_cursor, + fullday); + + gtk_text_set_editable (GTK_TEXT (child->widget), TRUE); + gtk_text_set_word_wrap (GTK_TEXT (child->widget), TRUE); + gtk_widget_set_parent (child->widget, GTK_WIDGET (fullday)); + gtk_widget_show (child->widget); + + return child; +} + +static void +child_destroy (GncalFullDay *fullday, Child *child) +{ + /* FIXME */ +} + +static void +child_set_pos (GncalFullDay *fullday, Child *child, int x, int y, int width, int height) +{ + child->x = x; + child->y = y; + child->width = width; + child->height = height; + + if (!GTK_WIDGET_REALIZED (fullday)) + return; + + child_move_text (child); + gdk_window_move_resize (child->window, x, y, width, height); +} + +static struct layout_row * +layout_get_rows (GncalFullDay *fullday) +{ + struct layout_row *rows; + int max_i; + int f_rows; + GList *children; + Child *child; + int i, n; + + get_tm_range (fullday, fullday->lower, fullday->upper, NULL, NULL, NULL, &f_rows); + + rows = g_new0 (struct layout_row, f_rows); + max_i = 0; + + for (children = fullday->children; children; children = children->next) { + child = children->data; + + for (i = 0; i < child->rows_used; i++) { + n = child->lower_row + i; + + rows[n].intersections++; + + if (rows[n].intersections > max_i) + max_i = rows[n].intersections; + } + } + + for (i = 0; i < f_rows; i++) + rows[i].slots = g_new0 (int, max_i); + + return rows; +} + +static void +layout_get_child_intersections (Child *child, struct layout_row *rows, int *min, int *max) +{ + int i, n; + int imin, imax; + + imax = 0; + + for (i = 0; i < child->rows_used; i++) { + n = child->lower_row + i; + + if (rows[n].intersections > imax) + imax = rows[n].intersections; + } + + imin = imax; + + for (i = 0; i < child->rows_used; i++) { + n = child->lower_row + i; + + if (rows[n].intersections < imin) + imin = rows[n].intersections; + } + + if (min) + *min = imin; + + if (max) + *max = imax; +} + +static int +calc_labels_width (GncalFullDay *fullday) +{ + struct tm cur, upper; + time_t tim, time_upper; + int width, max_w; + char buf[256]; + + get_tm_range (fullday, fullday->lower, fullday->upper, &cur, &upper, NULL, NULL); + + max_w = 0; + + tim = mktime (&cur); + time_upper = mktime (&upper); + + while (tim < time_upper) { + strftime (buf, 256, "%X", &cur); + + width = gdk_string_width (GTK_WIDGET (fullday)->style->font, buf); + + if (width > max_w) + max_w = width; + + cur.tm_min += fullday->interval; + tim = mktime (&cur); + } + + return max_w; +} + +static void +layout_child (GncalFullDay *fullday, Child *child, struct layout_row *rows) +{ + int c_x, c_y, c_width, c_height; + GtkWidget *widget; + int labels_width; + int height, f_rows; + int row_height; + + /* Calculate child position */ + + widget = GTK_WIDGET (fullday); + + labels_width = calc_labels_width (fullday); /* FIXME: this is expensive to do for each child */ + + get_tm_range (fullday, fullday->lower, fullday->upper, NULL, NULL, NULL, &f_rows); + + height = widget->allocation.height - 2 * widget->style->klass->ythickness; + row_height = height / f_rows; + + c_x = 2 * (widget->style->klass->xthickness + TEXT_BORDER) + labels_width; + c_y = widget->style->klass->ythickness; + + /* FIXME: for now, the children overlap. Make it layout them nicely. */ + + c_width = widget->allocation.width - (widget->style->klass->xthickness + c_x); + + c_y += child->lower_row * row_height; + c_height = child->rows_used * row_height; + + /* Position child */ + + child_set_pos (fullday, child, c_x, c_y, c_width, c_height); +} + +static void +layout_children (GncalFullDay *fullday) +{ + struct layout_row *rows; + GList *children; + + rows = layout_get_rows (fullday); + + for (children = fullday->children; children; children = children->next) + layout_child (fullday, children->data, rows); + + g_free (rows); +} guint gncal_full_day_get_type (void) @@ -52,18 +479,31 @@ gncal_full_day_get_type (void) static void gncal_full_day_class_init (GncalFullDayClass *class) { + GtkObjectClass *object_class; GtkWidgetClass *widget_class; GtkContainerClass *container_class; + object_class = (GtkObjectClass *) class; widget_class = (GtkWidgetClass *) class; container_class = (GtkContainerClass *) class; parent_class = gtk_type_class (gtk_container_get_type ()); + object_class->destroy = gncal_full_day_destroy; + + widget_class->map = gncal_full_day_map; + widget_class->unmap = gncal_full_day_unmap; widget_class->realize = gncal_full_day_realize; + widget_class->unrealize = gncal_full_day_unrealize; + widget_class->draw = gncal_full_day_draw; widget_class->size_request = gncal_full_day_size_request; widget_class->size_allocate = gncal_full_day_size_allocate; + widget_class->button_press_event = gncal_full_day_button_press; + widget_class->button_release_event = gncal_full_day_button_release; + widget_class->motion_notify_event = gncal_full_day_motion; widget_class->expose_event = gncal_full_day_expose; + + container_class->foreach = gncal_full_day_foreach; } static void @@ -76,6 +516,29 @@ gncal_full_day_init (GncalFullDay *fullday) fullday->lower = 0; fullday->upper = 0; fullday->interval = 30; /* 30 minutes by default */ + + fullday->children = NULL; + fullday->drag_info = g_new (struct drag_info, 1); + + fullday->up_down_cursor = NULL; + fullday->beam_cursor = NULL; +} + +static void +gncal_full_day_destroy (GtkObject *object) +{ + GncalFullDay *fullday; + + g_return_if_fail (object != NULL); + g_return_if_fail (GNCAL_IS_FULL_DAY (object)); + + fullday = GNCAL_FULL_DAY (object); + + g_list_free (fullday->children); + g_free (fullday->drag_info); + + if (GTK_OBJECT_CLASS (parent_class)->destroy) + (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); } GtkWidget * @@ -95,16 +558,58 @@ gncal_full_day_new (GnomeCalendar *calendar, time_t lower, time_t upper) } static void +gncal_full_day_map (GtkWidget *widget) +{ + GncalFullDay *fullday; + GList *children; + + g_return_if_fail (widget != NULL); + g_return_if_fail (GNCAL_IS_FULL_DAY (widget)); + + GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED); + + fullday = GNCAL_FULL_DAY (widget); + + gdk_window_show (widget->window); + + for (children = fullday->children; children; children = children->next) + child_map (fullday, children->data); +} + +static void +gncal_full_day_unmap (GtkWidget *widget) +{ + GncalFullDay *fullday; + GList *children; + + g_return_if_fail (widget != NULL); + g_return_if_fail (GNCAL_IS_FULL_DAY (widget)); + + GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED); + + fullday = GNCAL_FULL_DAY (widget); + + gdk_window_hide (widget->window); + + for (children = fullday->children; children; children = children->next) + child_unmap (fullday, children->data); +} + +static void gncal_full_day_realize (GtkWidget *widget) { + GncalFullDay *fullday; GdkWindowAttr attributes; gint attributes_mask; + GList *children; g_return_if_fail (widget != NULL); g_return_if_fail (GNCAL_IS_FULL_DAY (widget)); GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED); + fullday = GNCAL_FULL_DAY (widget); + attributes.window_type = GDK_WINDOW_CHILD; attributes.x = widget->allocation.x; attributes.y = widget->allocation.y; @@ -123,75 +628,53 @@ gncal_full_day_realize (GtkWidget *widget) widget->style = gtk_style_attach (widget->style, widget->window); gdk_window_set_background (widget->window, &widget->style->bg[GTK_STATE_PRELIGHT]); -} -static int -get_tm_bounds (GncalFullDay *fullday, struct tm *lower, struct tm *upper) -{ - struct tm tm_lower, tm_upper; - int lmin, umin; - - /* Lower */ - - tm_lower = *localtime (&fullday->lower); - - if ((tm_lower.tm_min % fullday->interval) != 0) { - tm_lower.tm_min -= tm_lower.tm_min % fullday->interval; /* round down */ - mktime (&tm_lower); - } + fullday->up_down_cursor = gdk_cursor_new (GDK_DOUBLE_ARROW); + fullday->beam_cursor = gdk_cursor_new (GDK_XTERM); - /* Upper */ + for (children = fullday->children; children; children = children->next) + child_realize (fullday, children->data); +} - tm_upper = *localtime (&fullday->upper); +static void +gncal_full_day_unrealize (GtkWidget *widget) +{ + GncalFullDay *fullday; + GList *children; - if ((tm_upper.tm_min % fullday->interval) != 0) { - tm_upper.tm_min += fullday->interval - (tm_upper.tm_min % fullday->interval); /* round up */ - mktime (&tm_upper); - } + g_return_if_fail (widget != NULL); + g_return_if_fail (GNCAL_IS_FULL_DAY (widget)); - if (lower) - *lower = tm_lower; + fullday = GNCAL_FULL_DAY (widget); - if (upper) - *upper = tm_upper; + for (children = fullday->children; children; children = children->next) + child_unrealize (fullday, children->data); - lmin = 60 * tm_lower.tm_hour + tm_lower.tm_min; - umin = 60 * tm_upper.tm_hour + tm_upper.tm_min; + gdk_cursor_destroy (fullday->up_down_cursor); + fullday->up_down_cursor = NULL; - if (umin == 0) /* midnight of next day? */ - umin = 60 * 24; + gdk_cursor_destroy (fullday->beam_cursor); + fullday->beam_cursor = NULL; - return (umin - lmin) / fullday->interval; /* number of rows in view */ + if (GTK_WIDGET_CLASS (parent_class)->unrealize) + (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget); } -static int -calc_labels_width (GncalFullDay *fullday) +static void +gncal_full_day_draw (GtkWidget *widget, GdkRectangle *area) { - struct tm cur, upper; - time_t tim, time_upper; - int width, max_w; - char buf[256]; - - get_tm_bounds (fullday, &cur, &upper); - - max_w = 0; - - tim = mktime (&cur); - time_upper = mktime (&upper); - - while (tim < time_upper) { - strftime (buf, 256, "%X", &cur); + GncalFullDay *fullday; - width = gdk_string_width (GTK_WIDGET (fullday)->style->font, buf); + g_return_if_fail (widget != NULL); + g_return_if_fail (GNCAL_IS_FULL_DAY (widget)); + g_return_if_fail (area != NULL); - if (width > max_w) - max_w = width; + if (!GTK_WIDGET_DRAWABLE (widget)) + return; - cur.tm_min += fullday->interval; - tim = mktime (&cur); - } + fullday = GNCAL_FULL_DAY (widget); - return max_w; + /* FIXME */ } static void @@ -216,7 +699,7 @@ gncal_full_day_size_request (GtkWidget *widget, GtkRequisition *requisition) /* Rows */ - rows = get_tm_bounds (fullday, NULL, NULL); + get_tm_range (fullday, fullday->lower, fullday->upper, NULL, NULL, NULL, &rows); requisition->height += (rows * (2 * TEXT_BORDER + widget->style->font->ascent + widget->style->font->descent) + (rows - 1)); /* division lines */ @@ -225,18 +708,220 @@ gncal_full_day_size_request (GtkWidget *widget, GtkRequisition *requisition) static void gncal_full_day_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { + GncalFullDay *fullday; + g_return_if_fail (widget != NULL); g_return_if_fail (GNCAL_IS_FULL_DAY (widget)); g_return_if_fail (allocation != NULL); widget->allocation = *allocation; + fullday = GNCAL_FULL_DAY (widget); + if (GTK_WIDGET_REALIZED (widget)) gdk_window_move_resize (widget->window, allocation->x, allocation->y, allocation->width, allocation->height); - /* FIXME: adjust children */ + layout_children (fullday); +} + +static Child * +find_child_by_window (GncalFullDay *fullday, GdkWindow *window) +{ + GList *children; + Child *child; + + for (children = fullday->children; children; children = children->next) { + child = children->data; + + if (child->window == window) + return child; + } + + return NULL; +} + +static void +draw_xor_rect (GncalFullDay *fullday) +{ + GtkWidget *widget; + struct drag_info *di; + int i; + + widget = GTK_WIDGET (fullday); + + gdk_gc_set_function (widget->style->white_gc, GDK_INVERT); + gdk_gc_set_subwindow (widget->style->white_gc, GDK_INCLUDE_INFERIORS); + + di = fullday->drag_info; + + for (i = 0; i < XOR_RECT_WIDTH; i++) + gdk_draw_rectangle (widget->window, + widget->style->white_gc, + FALSE, + di->child->x + i, + di->new_y + i, + di->child->width - 2 * i - 1, + di->new_height - 2 * i - 1); + + gdk_gc_set_function (widget->style->white_gc, GDK_COPY); + gdk_gc_set_subwindow (widget->style->white_gc, GDK_CLIP_BY_CHILDREN); +} + +static gint +gncal_full_day_button_press (GtkWidget *widget, GdkEventButton *event) +{ + GncalFullDay *fullday; + Child *child; + struct drag_info *di; + gint y; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GNCAL_IS_FULL_DAY (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + fullday = GNCAL_FULL_DAY (widget); + + if (event->window == widget->window) + return FALSE; /* FIXME: do range selection thing */ + else { + child = find_child_by_window (fullday, event->window); + + if (!child) + return FALSE; + + di = fullday->drag_info; + + di->child = child; + + gtk_widget_get_pointer (widget, NULL, &y); + + if (event->y < HANDLE_SIZE) + di->drag_mode = DRAG_MOVE; + else + di->drag_mode = DRAG_SIZE; + + di->new_y = child->y; + di->new_height = child->height; + + gdk_pointer_grab (child->window, FALSE, + (GDK_BUTTON_MOTION_MASK + | GDK_POINTER_MOTION_HINT_MASK + | GDK_BUTTON_RELEASE_MASK), + NULL, + NULL, + event->time); + + draw_xor_rect (fullday); + } + + return FALSE; +} + +static void +recompute_motion (GncalFullDay *fullday, int y) +{ + GtkWidget *widget; + struct drag_info *di; + int rows, row_height; + int ythickness; + + widget = GTK_WIDGET (fullday); + + get_tm_range (fullday, fullday->lower, fullday->upper, NULL, NULL, NULL, &rows); + + ythickness = widget->style->klass->ythickness; + + row_height = (widget->allocation.height - 2 * ythickness) / rows; + + y -= ythickness; + y = (y + row_height / 2) / row_height; /* round to nearest bound */ + y = y * row_height + ythickness; + + di = fullday->drag_info; + + switch (di->drag_mode) { + case DRAG_MOVE: + if (y < ythickness) + y = ythickness; + else if (y >= (ythickness + rows * row_height - di->new_height)) + y = ythickness + rows * row_height - di->new_height; + + di->new_y = y; + + break; + + case DRAG_SIZE: + if (y <= di->child->y) + y = di->child->y + row_height; + else if (y >= (ythickness + rows * row_height)) + y = ythickness + rows * row_height; + + di->new_height = y - di->new_y; + + break; + + default: + g_assert_not_reached (); + } +} + +static gint +gncal_full_day_button_release (GtkWidget *widget, GdkEventButton *event) +{ + GncalFullDay *fullday; + struct drag_info *di; + gint y; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GNCAL_IS_FULL_DAY (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + fullday = GNCAL_FULL_DAY (widget); + + di = fullday->drag_info; + + if (!di->child || (event->window != di->child->window)) + return FALSE; + + gtk_widget_get_pointer (widget, NULL, &y); + + draw_xor_rect (fullday); + recompute_motion (fullday, y); + gdk_pointer_ungrab (event->time); + + /* FIXME: update child, notify, etc. */ + + di->child = NULL; + + return FALSE; +} + +static gint +gncal_full_day_motion (GtkWidget *widget, GdkEventMotion *event) +{ + GncalFullDay *fullday; + struct drag_info *di; + gint y; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GNCAL_IS_FULL_DAY (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + fullday = GNCAL_FULL_DAY (widget); + di = fullday->drag_info; + + if (!di->child || (event->window != di->child->window)) + return FALSE; + + gtk_widget_get_pointer (widget, NULL, &y); + + draw_xor_rect (fullday); + recompute_motion (fullday, y); + draw_xor_rect (fullday); + + return FALSE; } static void @@ -296,11 +981,11 @@ paint_back (GncalFullDay *fullday, GdkRectangle *area) /* Horizontal divisions */ - rows = get_tm_bounds (fullday, &tm, NULL); + get_tm_range (fullday, fullday->lower, fullday->upper, &tm, NULL, NULL, &rows); - row_height = height / rows; /* includes division line */ + row_height = height / rows; /* includes division line at bottom of row */ - y = row_height; + y = y1 + row_height - 1; for (i = 1; i < rows; i++) { gdk_draw_line (widget->window, @@ -315,6 +1000,8 @@ paint_back (GncalFullDay *fullday, GdkRectangle *area) y = y1 + ((row_height - 1) - (widget->style->font->ascent + widget->style->font->descent)) / 2; + rect.height = row_height - 1; + for (i = 0; i < rows; i++) { mktime (&tm); @@ -340,6 +1027,8 @@ static gint gncal_full_day_expose (GtkWidget *widget, GdkEventExpose *event) { GncalFullDay *fullday; + GList *children; + Child *child; g_return_val_if_fail (widget != NULL, FALSE); g_return_val_if_fail (GNCAL_IS_FULL_DAY (widget), FALSE); @@ -352,19 +1041,90 @@ gncal_full_day_expose (GtkWidget *widget, GdkEventExpose *event) if (event->window == widget->window) paint_back (fullday, &event->area); - - /* FIXME: paint handles in windows if event->window == blah blah */ + else + for (children = fullday->children; children; children = children->next) { + child = children->data; + + if (event->window == child->window) { + child_draw (fullday, child, &event->area, FALSE); + break; + } + } return FALSE; } +static void +gncal_full_day_foreach (GtkContainer *container, GtkCallback callback, gpointer callback_data) +{ + GncalFullDay *fullday; + GList *children; + Child *child; + + g_return_if_fail (container != NULL); + g_return_if_fail (GNCAL_IS_FULL_DAY (container)); + g_return_if_fail (callback != NULL); + + fullday = GNCAL_FULL_DAY (container); + + for (children = fullday->children; children; children = children->next) { + child = children->data; + + (*callback) (child->widget, callback_data); + } +} + void gncal_full_day_update (GncalFullDay *fullday) { + GList *children; + GList *l_events, *events; + Child *child; + g_return_if_fail (fullday != NULL); g_return_if_fail (GNCAL_IS_FULL_DAY (fullday)); - /* FIXME */ + if (!fullday->calendar->cal) + return; + + l_events = calendar_get_events_in_range (fullday->calendar->cal, + fullday->lower, + fullday->upper, + calendar_compare_by_dtstart); + + /* FIXME: this is expensive and looks ugly -- use some form of cache? */ + + for (children = fullday->children; children; children = children->next) + child_destroy (fullday, children->data); + + g_list_free (fullday->children); + + children = NULL; + + for (events = l_events; events; events = events->next) { + child = child_new (fullday, events->data); + children = g_list_append (children, child); + } + + g_list_free (l_events); + + fullday->children = g_list_first (children); + + layout_children (fullday); + + /* Realize and map children */ + + for (children = fullday->children; children; children = children->next) { + if (GTK_WIDGET_REALIZED (fullday)) + child_realize (fullday, children->data); + + if (GTK_WIDGET_MAPPED (fullday)) + child_map (fullday, children->data); + } + + /* FIXME: paint or something */ + + gtk_widget_draw (GTK_WIDGET (fullday), NULL); } void |