dw_gtk_scrolled_frame.c

微型浏览器

 */
static gint Dw_gtk_scrolled_frame_expose(GtkWidget * widget, GdkEventExpose * event)
{
	gint ret_val;

	ret_val = (*(GTK_WIDGET_CLASS(parent_class)->expose_event)) (widget, event);
	Dw_gtk_scrolled_frame_paint_shadow(widget, &(event->area));

	return ret_val;
}


/*
 * Standard Gtk+ function
 */
static gint Dw_gtk_scrolled_frame_key_press(GtkWidget * widget, GdkEventKey * event)
{
	/* todo:
	 * A idle function (like in button 2 dragging) would work better.
	 */
	GtkContainer *container;
	GtkDwScrolledFrame *frame;

	container = GTK_CONTAINER(widget);
	frame = GTK_DW_SCROLLED_FRAME(widget);

	switch (event->keyval) {
	case GDK_Up:
		Dw_gtk_scrolled_frame_set_vadjustment_value(frame, frame->vadjustment->value - frame->vadjustment->step_increment);
		return TRUE;

	case GDK_Down:
		Dw_gtk_scrolled_frame_set_vadjustment_value(frame, frame->vadjustment->value + frame->vadjustment->step_increment);
		return TRUE;

	case GDK_Left:
		Dw_gtk_scrolled_frame_set_hadjustment_value(frame, frame->hadjustment->value - frame->hadjustment->step_increment);
		return TRUE;

	case GDK_Right:
		Dw_gtk_scrolled_frame_set_hadjustment_value(frame, frame->hadjustment->value + frame->hadjustment->step_increment);
		return TRUE;

	case GDK_Tab:
		if (event->state & GDK_SHIFT_MASK)
			return gtk_container_focus(container, GTK_DIR_TAB_BACKWARD);
		else
			return gtk_container_focus(container, GTK_DIR_TAB_FORWARD);

	case GDK_Page_Up:
		if (event->state & GDK_CONTROL_MASK)
			Dw_gtk_scrolled_frame_set_hadjustment_value(frame, frame->hadjustment->value - frame->hadjustment->page_increment);
		else
			Dw_gtk_scrolled_frame_set_vadjustment_value(frame, frame->vadjustment->value - frame->vadjustment->page_increment);
		return TRUE;

	case GDK_Page_Down:
		if (event->state & GDK_CONTROL_MASK)
			Dw_gtk_scrolled_frame_set_hadjustment_value(frame, frame->hadjustment->value + frame->hadjustment->page_increment);
		else
			Dw_gtk_scrolled_frame_set_vadjustment_value(frame, frame->vadjustment->value + frame->vadjustment->page_increment);
		return TRUE;

	case GDK_Home:
		if (event->state & GDK_CONTROL_MASK)
			Dw_gtk_scrolled_frame_set_hadjustment_value(frame, 0);
		else
			Dw_gtk_scrolled_frame_set_vadjustment_value(frame, 0);
		return TRUE;

	case GDK_End:
		if (event->state & GDK_CONTROL_MASK)
			Dw_gtk_scrolled_frame_set_hadjustment_value(frame, 0x7fffffff);
		else
			Dw_gtk_scrolled_frame_set_vadjustment_value(frame, 0x7fffffff);
		return TRUE;

	default:
		return FALSE;
	}
}


/*
 * Standard Gtk+ function
 */
static gint Dw_gtk_scrolled_frame_focus_in(GtkWidget * widget, GdkEventFocus * event)
{
	GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
	gtk_widget_draw_focus(widget);
	return FALSE;
}


/*
 * Standard Gtk+ function
 */
static gint Dw_gtk_scrolled_frame_focus_out(GtkWidget * widget, GdkEventFocus * event)
{
	GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS);
	gtk_widget_draw_focus(widget);
	return FALSE;
}


/*
 * Standard Gtk+ function
 */
static gint Dw_gtk_scrolled_frame_button_press(GtkWidget * widget, GdkEventButton * event)
{
	GtkDwScrolledFrame *frame;

	if (!GTK_WIDGET_HAS_FOCUS(widget))
		gtk_widget_grab_focus(widget);

	if (event->button == 2) {
		/* todo: a new cursor? */
		frame = GTK_DW_SCROLLED_FRAME(widget);

		g_return_val_if_fail(frame->hadjustment != NULL, TRUE);
		g_return_val_if_fail(frame->vadjustment != NULL, TRUE);

		frame->button2_pressed = TRUE;
		frame->start_mx = event->x;
		frame->start_my = event->y;
		frame->start_ax = frame->hadjustment->value;
		frame->start_ay = frame->vadjustment->value;

		gdk_pointer_grab(widget->window, FALSE, GDK_BUTTON_RELEASE_MASK | GDK_BUTTON2_MOTION_MASK, NULL, frame->drag_cursor, event->time);

	}

	return TRUE;
}


/*
 * Standard Gtk+ function
 */
static gint Dw_gtk_scrolled_frame_button_release(GtkWidget * widget, GdkEventButton * event)
{
	GTK_DW_SCROLLED_FRAME(widget)->button2_pressed = FALSE;
	gdk_pointer_ungrab(event->time);
	return TRUE;
}


/*
 * This idle function helps to avoid to handle too much motion notify events.
 */
static gint Dw_gtk_scrolled_frame_drag_idle(gpointer data)
{
	GtkDwScrolledFrame *frame;
	gfloat dx, dy;

	frame = GTK_DW_SCROLLED_FRAME(data);

	g_return_val_if_fail(frame->hadjustment != NULL, FALSE);
	g_return_val_if_fail(frame->vadjustment != NULL, FALSE);

	dx = frame->current_mx - frame->start_mx;
	dy = frame->current_my - frame->start_my;
	Dw_gtk_scrolled_frame_set_hadjustment_value(frame, frame->start_ax - dx);
	Dw_gtk_scrolled_frame_set_vadjustment_value(frame, frame->start_ay - dy);

	frame->drag_idle_id = -1;
	return FALSE;
}

/*
 * Standard Gtk+ function
 */
static gint Dw_gtk_scrolled_frame_motion_notify(GtkWidget * widget, GdkEventMotion * event)
{
	GtkDwScrolledFrame *frame;

	frame = GTK_DW_SCROLLED_FRAME(widget);

	/* frame->button2_pressed makes sure that the button was pressed
	   in the GtkDwScrolledFrame */
	if ((event->state & GDK_BUTTON2_MASK) && frame->button2_pressed) {
		frame->current_mx = event->x;
		frame->current_my = event->y;

		if (frame->drag_idle_id == -1)
			frame->drag_idle_id = gtk_idle_add(Dw_gtk_scrolled_frame_drag_idle, (gpointer) frame);
	}

	return TRUE;
}


/**************************
 *                        *
 *  GtkContainer methods  *
 *                        *
 **************************/

/*
 * Standard Gtk+ function
 */
static void Dw_gtk_scrolled_frame_add(GtkContainer * container, GtkWidget * widget)
{
	GtkDwScrolledFrame *frame;

	(*(GTK_CONTAINER_CLASS(parent_class)->add)) (container, widget);

	frame = GTK_DW_SCROLLED_FRAME(container);
	if (!gtk_widget_set_scroll_adjustments(GTK_WIDGET(container), frame->hadjustment, frame->vadjustment))
		g_warning("Dw_gtk_scrolled_frame_set_scroll_adjustments(): " "child is non scrollable");
}


/*
 * Standard Gtk+ function
 */
static gint Dw_gtk_scrolled_frame_focus(GtkContainer * container, GtkDirectionType direction)
{
	/* todo:
	 * 1. This crashed if the child is not a container (what will never happen
	 *    in dillo, where GtkDwScrolledFrame always contains a GtkDwViewport).
	 * 2. Does not work correctly yet.
	 */
	GtkDwScrolledFrame *frame;

	frame = GTK_DW_SCROLLED_FRAME(container);

	switch (direction) {
	case GTK_DIR_TAB_FORWARD:
	case GTK_DIR_RIGHT:
	case GTK_DIR_DOWN:
		if (container->focus_child == NULL && !GTK_WIDGET_HAS_FOCUS(container)) {
			/* no focus of the GtkDwScrolledFrame or a child widget -> focus */
			gtk_widget_grab_focus(GTK_WIDGET(container));
			return TRUE;
		} else
			/* deliver to child */
			return gtk_container_focus(GTK_CONTAINER(GTK_BIN(container)->child), direction);

	case GTK_DIR_TAB_BACKWARD:
	case GTK_DIR_LEFT:
	case GTK_DIR_UP:
		if (GTK_WIDGET_HAS_FOCUS(container))
			/* will focus the widget "before" */
			return FALSE;
		else {
			if (!gtk_container_focus(GTK_CONTAINER(GTK_BIN(container)->child), GTK_DIR_TAB_BACKWARD))
				/* first child of the child unfocussed */
				gtk_widget_grab_focus(GTK_WIDGET(container));

			return TRUE;
		}
		break;

	default:
		/* make compiler happy (1) */
		return FALSE;
	}

	/* make compiler happy (2) */
	return FALSE;
}


/******************************
 *                            *
 *  GtkDwScrolledFrame methods  *
 *                            *
 ******************************/

/*
 * Standard Gtk+ function
 */
static void Dw_gtk_scrolled_frame_set_scroll_adjustments(GtkDwScrolledFrame * frame, GtkAdjustment * hadjustment, GtkAdjustment * vadjustment)
{
	GtkBin *bin;

	frame->hadjustment = hadjustment;
	frame->vadjustment = vadjustment;

	bin = GTK_BIN(frame);
	if (bin->child) {
		if (!gtk_widget_set_scroll_adjustments(bin->child, hadjustment, vadjustment))
			g_warning("Dw_gtk_scrolled_frame_set_scroll_adjustments(): " "child is non scrollable");
	}
}


/*
 * Called by Dw_gtk_scrolled_frame_set_[vh]adjustment_value.
 */
static gint Dw_gtk_scrolled_frame_set_adjustment_value(GtkDwScrolledFrame * frame, GtkAdjustment * adj, gfloat pos)
{
	gfloat set_pos;

	/* The normal gtk_adjustment_set_value does not work as expected. */
	if (pos < adj->lower)
		set_pos = adj->lower;
	else if (pos > adj->upper - adj->page_size)
		set_pos = adj->upper - adj->page_size;
	else
		set_pos = pos;

	if (set_pos != adj->value) {
		gtk_adjustment_set_value(adj, set_pos);
		if (adj == frame->hadjustment)
			gtk_signal_emit(GTK_OBJECT(frame), frame_signals[USER_HCHANGED]);
		else if (adj == frame->vadjustment)
			gtk_signal_emit(GTK_OBJECT(frame), frame_signals[USER_VCHANGED]);
		else
			g_warning("Wrong adjustment");
	}

	return pos == set_pos;
}


/*
 * Set hadjustment value and emit "user_hchanged" signal.
 */
static gint Dw_gtk_scrolled_frame_set_hadjustment_value(GtkDwScrolledFrame * frame, gfloat pos)
{
	return Dw_gtk_scrolled_frame_set_adjustment_value(frame, frame->hadjustment, pos);
}


/*
 * Set vadjustment value and emit "user_vchanged" signal.
 */
static gint Dw_gtk_scrolled_frame_set_vadjustment_value(GtkDwScrolledFrame * frame, gfloat pos)
{
	return Dw_gtk_scrolled_frame_set_adjustment_value(frame, frame->vadjustment, pos);
}