schedule-widget.c

一个功能全面的电子邮件客户端

  ScheduleChild *child = schedule_child_new (schedule);
  GtkStyle *style = GTK_WIDGET (schedule)->style;

  child->x = 64 + CONFLICT;
  child->y =
    (schedule_time_to_row (1, schedule, start, stop) * schedule->row_height) + 1;
  child->width = schedule->width - 66 - CONFLICT;
  child->height =
    (schedule_time_to_row (0, schedule, start, stop) * schedule->row_height) - child->y;
  child->data = data;
  child->start = start;
  child->stop = stop;
  child->color = style->bg_gc[GTK_STATE_SELECTED];

  if (text)
    gtk_text_insert (GTK_TEXT (child->widget), NULL, NULL, NULL,
		     text, strlen (text));

  schedule->child_count++;
  schedule_child_show (schedule, child);
}


static void
schedule_child_show (Schedule * schedule, ScheduleChild * child)
{
  if (!child->window)
    schedule_child_realize (schedule, child);
  schedule_child_map (schedule, child);
  gtk_widget_show (child->widget);
  schedule_child_paint (child);
}


static void
schedule_child_realize (Schedule * schedule, ScheduleChild * child)
{
  GdkWindowAttr attributes;
  gint attributes_mask;
  GtkWidget *widget = GTK_WIDGET (schedule);

  attributes.window_type = GDK_WINDOW_CHILD;
  attributes.window_type = GDK_WINDOW_CHILD;
  attributes.x = child->x;
  attributes.y = child->y;
  attributes.width = child->width - child->decor_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 = schedule->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
			   | GDK_KEY_PRESS_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 (child->widget, GTK_WIDGET (schedule));

  schedule_child_handle_text (schedule, child);
}


static void
schedule_child_handle_text (Schedule * schedule, ScheduleChild * child)
{
  GtkAllocation allocation;
  int has_focus;
  int handle_size;

  has_focus = GTK_WIDGET_HAS_FOCUS (child->widget);

  handle_size = HANDLE_SIZE;

  if (child->width > 400)
    child->width = 400;
  allocation.x = child->x + HANDLE_SIZE;
  allocation.y = child->y + has_focus * HANDLE_SIZE;

  allocation.width = child->width - HANDLE_SIZE;
  allocation.height = child->height - 2 * (has_focus * HANDLE_SIZE);

  gtk_widget_size_request (child->widget, NULL);
  gtk_widget_size_allocate (child->widget, &allocation);
}


static void
schedule_child_map (Schedule * schedule, ScheduleChild * child)
{
  gdk_window_show (child->window);
  gtk_widget_show (child->widget);
  gtk_widget_draw (child->widget, NULL);
}


static void
schedule_child_paint (ScheduleChild * child)
{
  GdkRectangle rectangle;
  GtkStyle *style = GTK_WIDGET (child->widget)->style;

  rectangle.x = 0;
  rectangle.y = 0;
  rectangle.width = HANDLE_SIZE - 1;
  rectangle.height = child->height - 1;
#if HANDLEBAR
  gtk_draw_handle (GTK_WIDGET (child->schedule)->style,
		   child->window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
		   rectangle.x, rectangle.y, rectangle.width,
		   rectangle.height, GTK_ORIENTATION_VERTICAL);
#else
  gdk_draw_rectangle (child->window, child->color,
		      TRUE, rectangle.x,
		      rectangle.y, rectangle.width, rectangle.height);
  gdk_draw_rectangle (child->window, style->black_gc, FALSE,
		      rectangle.x, rectangle.y, rectangle.width,
		      rectangle.height);
#endif


  if (child->flags & CHILD_HAS_FOCUS)
    {
      rectangle.x = HANDLE_SIZE;
      rectangle.y = 0;
      rectangle.width = child->width - HANDLE_SIZE - 1;
      rectangle.height = HANDLE_SIZE - 1;
#if HANDLEBAR
      gtk_draw_handle (GTK_WIDGET (child->schedule)->style,
		       child->window, GTK_STATE_NORMAL,
		       GTK_SHADOW_OUT, rectangle.x, rectangle.y,
		       rectangle.width, rectangle.height,
		       GTK_ORIENTATION_VERTICAL);
#else
      gdk_draw_rectangle (child->window,
			  child->color, TRUE, rectangle.x,
			  rectangle.y, rectangle.width, rectangle.height);
      gdk_draw_rectangle (child->window, style->black_gc, FALSE,
			  rectangle.x, rectangle.y, rectangle.width,
			  rectangle.height);
#endif

      rectangle.x = HANDLE_SIZE;
      rectangle.y = child->height - HANDLE_SIZE;
      rectangle.width = child->width - HANDLE_SIZE - 1;
      rectangle.height = HANDLE_SIZE - 1;
#if HANDLEBAR
      gtk_draw_handle (GTK_WIDGET (child->schedule)->style,
		       child->window, GTK_STATE_NORMAL,
		       GTK_SHADOW_OUT, rectangle.x, rectangle.y,
		       rectangle.width, rectangle.height,
		       GTK_ORIENTATION_VERTICAL);
#else
      gdk_draw_rectangle (child->window,
			  child->color, TRUE, rectangle.x,
			  rectangle.y, rectangle.width, rectangle.height);
      gdk_draw_rectangle (child->window, style->black_gc, FALSE,
			  rectangle.x, rectangle.y, rectangle.width,
			  rectangle.height);
#endif
    }
}

static void
schedule_child_key_press (GtkWidget * widget, GdkEventKey * event,
			  gpointer data)
{
  if (event->keyval != GDK_Escape)
    return;
  gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
  gtk_widget_grab_focus (widget->parent);
}


static void
schedule_child_focus_in (GtkWidget * widget, GdkEventFocus * event,
			 gpointer data)
{
  ScheduleChild *child = (ScheduleChild *) data;
  char *text;

  if (child)
    {
      text = gtk_editable_get_chars (GTK_EDITABLE (widget), 0, -1);
      if (child->window)
	{
	  child->height += HANDLE_SIZE * 2;
	  child->y -= HANDLE_SIZE;
	  gdk_window_move_resize (child->window, child->x,
				  child->y, child->width, child->height);
	  child->flags |= CHILD_HAS_FOCUS;
	  gtk_signal_emit (GTK_OBJECT (GTK_WIDGET (child->schedule)),
			   schedule_signals[CHILD_SELECTED], text,
			   child->data, child->start, child->stop);
	  schedule_child_paint (child);
	}
    }
}


static void
schedule_child_focus_out (GtkWidget * widget, GdkEventFocus * event,
			  gpointer data)
{
  ScheduleChild *child = (ScheduleChild *) data;
  char *text = gtk_editable_get_chars (GTK_EDITABLE (child->widget),
				       0, -1);

  if (child->window)
    {
      child->height -= HANDLE_SIZE * 2;
      child->y += HANDLE_SIZE;
      gdk_window_move_resize (child->window, child->x,
			      child->y, child->width, child->height);
      child->flags &= ~CHILD_HAS_FOCUS;
      schedule_child_paint (child);
      gdk_pointer_ungrab (GDK_CURRENT_TIME);
      if (info)
	{
	  g_free (info);
	  info = NULL;
	}
      gtk_signal_emit (GTK_OBJECT (GTK_WIDGET (child->schedule)),
		       schedule_signals[CHILD_CHANGED],
		       text, child->data, child->start, child->stop);
    }
}


static void
child_changed (Schedule * schedule, char *text, gpointer data, time_t start,
	       time_t stop)
{
}

static void
child_selected (Schedule * schedule, char *text, gpointer data, time_t start,
		time_t stop)
{
}


static void
child_double_clicked (Schedule * schedule, char *text, gpointer data,
		      time_t start, time_t stop)
{
}


static void
child_right_clicked (Schedule * schedule, char *text, gpointer data,
		     time_t start, time_t stop)
{
  GList *seek = schedule->children;
  int count = 0;
  ScheduleChild *child;

  schedule->depth_count++;
  if (schedule->depth_count > schedule->child_count)
    schedule->depth_count = 1;

  while (seek)
  {
    count++;

    if (count == schedule->depth_count)
      {
        child = seek->data;

        gdk_window_hide (child->window);
        gtk_widget_hide (child->widget);

        gdk_window_show (child->window);
        gtk_widget_show (child->widget);
      }

    seek = g_list_next (seek);
  }
}


static void
row_selected (Schedule * schedule, int row, time_t index)
{
}


static gint
schedule_motion_notify_event (GtkWidget * widget, GdkEventMotion * event)
{
  Schedule *schedule = SCHEDULE (widget);
  float gran;

  if (info)
    {
      switch (schedule->granularity)
	{
	case SCHEDULE_15M:
	  gran = 2.0;
	  break;
	case SCHEDULE_30M:
	  gran = 1.0;
	  break;
	case SCHEDULE_60M:
	  gran = 0.5;
	  break;
	}

      if (info->type == DRAG_MOVE)
	{
	  if (event->y - info->start_y > -HANDLE_SIZE)
	    info->child->y = event->y - info->start_y;
	  else
	    info->child->y = -HANDLE_SIZE;
	}
      if (info->type == DRAG_SIZEUP)
	{
	  if (event->y <
	      info->child->y + info->child->height - (schedule->row_height +
						      HANDLE_SIZE * 2))
	    {
	      if (event->y > -HANDLE_SIZE)
		{
		  int tmpy = info->child->y;
		  info->child->y = event->y + info->start_y;
		  schedule_child_find_best (info->child);
		  info->child->height += tmpy - info->child->y;
		}
	      else
		{
		  int tmpy = info->child->y;
		  if (info->child->y > -HANDLE_SIZE)
		    {
		      info->child->y = -HANDLE_SIZE;
		      schedule_child_find_best (info->child);
		      info->child->height += tmpy + HANDLE_SIZE * 2;
		    }
		}
	    }
	  else
	    {
	      int ty = info->child->height + info->child->y;
	      info->child->y = ty - (schedule->row_height + HANDLE_SIZE * 2);
	      schedule_child_find_best (info->child);
	      info->child->height = (schedule->row_height + HANDLE_SIZE * 2);
	    }
	  schedule_child_find_best (info->child);
	  gdk_window_move_resize (info->child->window,
				  info->child->x,
				  info->child->y,
				  info->child->width, info->child->height);
	  schedule_child_handle_text (schedule, info->child);
	  return TRUE;
	}
      if (info->type == DRAG_SIZEDOWN)
	{
	  if (event->y >
	      info->child->y + (schedule->row_height + HANDLE_SIZE * 2))
	    info->child->height = event->y - info->child->y;
	  else
	    info->child->height = schedule->row_height + HANDLE_SIZE * 2;
	}
      schedule_child_find_best (info->child);
      gdk_window_move_resize (info->child->window,
			      info->child->x,
			      info->child->y,
			      info->child->width, info->child->height);
      schedule_child_handle_text (schedule, info->child);
    }
  return TRUE;
}


static void
schedule_child_find_best (ScheduleChild * child)
{
  int tmpy, h = child->schedule->row_height;
  Schedule *schedule = child->schedule;
  float gran = 0;

  g_return_if_fail (child != NULL);

  switch (schedule->granularity)
    {
    case SCHEDULE_15M:
      gran = 15;
      break;
    case SCHEDULE_30M:
      gran = 30;
      break;
    case SCHEDULE_60M:
      gran = 60;
      break;
    }

  tmpy = (child->y + HANDLE_SIZE) / h;
  child->y = (tmpy * h) - HANDLE_SIZE + 1;
  tmpy = (child->y + child->height);
  tmpy = tmpy / h;
  tmpy = tmpy * h;
  child->height = tmpy - child->y + HANDLE_SIZE;
  if (child->y > 2)
    child->start = ((child->y / h) + 1) * (gran * 60) + schedule->upper;
  else
    child->start = schedule->upper;
  child->stop =
    (((child->y + child->height) + 1) / h) * (gran * 60) + schedule->upper;
}


void
schedule_set_upper (Schedule * schedule, time_t upper)
{
  g_return_if_fail (schedule != NULL);
  schedule->upper = upper;
}


void
schedule_child_get_time (Schedule * schedule, gpointer seek_data,
			 time_t * start, time_t * stop)
{
  GList *seek;
  ScheduleChild *child;
  g_return_if_fail (schedule != NULL);
  g_return_if_fail (start != NULL);
  g_return_if_fail (stop != NULL);
  for (seek = schedule->children; seek; seek = seek->next)
    {
      child = seek->data;
      if (child->data == seek_data)
	{
	  *start = child->start;
	  *stop = child->stop;
	}
    }
}


void
schedule_time_set (Schedule * schedule, ScheduleTime format)
{
  schedule->time_style = format;

  schedule_paint (GTK_WIDGET (schedule));
}


void
schedule_time_toggle (Schedule * schedule)
{
  ScheduleTime format = schedule->time_style;

  if (format == SCHEDULE_AMPM)
    {
      schedule->time_style = SCHEDULE_24HR;
    }
  else
    {
      schedule->time_style = SCHEDULE_AMPM;
    }

  schedule_paint (GTK_WIDGET (schedule));
}


void
schedule_granularity_set (Schedule * schedule,
			  ScheduleGranularity granularity)
{
  GtkWidget *widget = GTK_WIDGET (schedule);

  schedule->granularity = granularity;

  gtk_widget_hide (widget);
  gtk_widget_show (widget);
}


void
schedule_set_work_day (Schedule * schedule, int start, int stop)
{
  schedule->day_start_row = start;
  schedule->day_end_row = stop;

  schedule_paint (GTK_WIDGET (schedule));
}


void
schedule_child_set_color (ScheduleChild * child, GdkGC * color)
{
  child->color = color;

  schedule_paint (GTK_WIDGET (child->schedule));
}


void
schedule_set_background_color (Schedule * schedule, GdkGC * dark,
			       GdkGC * light)
{
  schedule->dark = dark;
  schedule->light = light;

  schedule_paint (GTK_WIDGET (schedule));
}


#endif /* _SCHEDULE_C_ */