dw_gtk_scrolled_window.c

浏览器的源代码,可移植到嵌入式设备.

/*
 * File: dw_gtk_scrolled_window.c
 *
 * Copyright (C) 2001  Sebastian Geerken <[e-mail]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <stddef.h>

#include "dw_gtk_scrolled_window.h"
#include "dw_gtk_scrolled_frame.h"
#include "dw_gtk_viewport.h"
#include "findtext.h"
#include <gtk/gtk.h>

#include "debug.h"

static GtkScrolledWindowClass *parent_class = NULL;

static void Dw_gtk_scrolled_window_init      (GtkDwScrolledWindow *scrolled);
static void Dw_gtk_scrolled_window_class_init(GtkDwScrolledWindowClass *klass);

static void Dw_gtk_scrolled_window_destroy       (GtkObject *object);
static void Dw_gtk_scrolled_window_map           (GtkWidget *widget);
static void Dw_gtk_scrolled_window_unmap         (GtkWidget *widget);
static void Dw_gtk_scrolled_window_draw          (GtkWidget *widget,
                                                  GdkRectangle *area);
static void Dw_gtk_scrolled_window_size_allocate (GtkWidget *widget,
                                                  GtkAllocation *allocation);

static void Dw_gtk_scrolled_window_remove         (GtkContainer *container,
                                                   GtkWidget *widget);
static void Dw_gtk_scrolled_window_forall        (GtkContainer *container,
                                                  gboolean include_internals,
                                                  GtkCallback callback,
                                                  gpointer callback_data);

static void Dw_gtk_scrolled_window_changed1  (GtkDwScrolledWindow *scrolled);
static void Dw_gtk_scrolled_window_changed2  (GtkDwScrolledWindow *scrolled);


/*
 * Standard Gtk+ function
 */
GtkType a_Dw_gtk_scrolled_window_get_type (void)
{
   static GtkType type = 0;

   if (!type) {
      GtkTypeInfo info = {
         "GtkDwScrolledWindow",
         sizeof (GtkDwScrolledWindow),
         sizeof (GtkDwScrolledWindowClass),
         (GtkClassInitFunc) Dw_gtk_scrolled_window_class_init,
         (GtkObjectInitFunc) Dw_gtk_scrolled_window_init,
         (GtkArgSetFunc) NULL,
         (GtkArgGetFunc) NULL,
         (GtkClassInitFunc) NULL
      };

      type = gtk_type_unique (GTK_TYPE_SCROLLED_WINDOW, &info);
   }

   return type;
}


/*
 * Standard Gtk+ function
 */
GtkWidget* a_Dw_gtk_scrolled_window_new (void)
{
   return gtk_widget_new (GTK_TYPE_DW_SCROLLED_WINDOW, NULL);
}


/*
 * Standard Gtk+ function
 */
static void Dw_gtk_scrolled_window_init (GtkDwScrolledWindow *scrolled)
{
   GtkAdjustment *hadjustment, *vadjustment;
   GtkWidget *frame, *viewport;
   size_t i;
   char *signals[] = {
      "button_press_event",
      "button_release_event",
      "motion_notify_event",
      "key_press_event"         /* although the scrollbars are not focused */
   };

   hadjustment =
      GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 10.0, 0.0, 0.0));
   vadjustment =
      GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 10.0, 0.0, 0.0));

   gtk_scrolled_window_set_hadjustment (GTK_SCROLLED_WINDOW (scrolled),
                                        hadjustment);
   gtk_scrolled_window_set_vadjustment (GTK_SCROLLED_WINDOW (scrolled),
                                        vadjustment);

   frame = a_Dw_gtk_scrolled_frame_new (hadjustment, vadjustment);
   gtk_container_add (GTK_CONTAINER (scrolled), frame);
   gtk_widget_show (frame);

   viewport = a_Dw_gtk_viewport_new (hadjustment, vadjustment);
   gtk_container_add (GTK_CONTAINER (frame), viewport);
   gtk_widget_show (viewport);

   scrolled->vadjustment = vadjustment;
   scrolled->old_vadjustment_value = vadjustment->value;
   scrolled->gadget = NULL;

   /*
    * For anchors, we need to recognize when the *user* changes the
    * viewport and distiguish them from changes caused by the program.
    * Instead of using the "change" signal and checking where it came
    * from, the following code connects all possible events by which
    * users could change the scrollbar adjustments. ...
    */
   for (i = 0; i < sizeof (signals) / sizeof (signals[0]); i++) {
      gtk_signal_connect_object
         (GTK_OBJECT (GTK_SCROLLED_WINDOW(scrolled)->vscrollbar),
          signals[i],  GTK_SIGNAL_FUNC (Dw_gtk_scrolled_window_changed1),
          GTK_OBJECT (scrolled));
      gtk_signal_connect_object_after
         (GTK_OBJECT (GTK_SCROLLED_WINDOW(scrolled)->vscrollbar),
          signals[i],  GTK_SIGNAL_FUNC (Dw_gtk_scrolled_window_changed2),
          GTK_OBJECT (scrolled));
   }

   /* ... The GtkDwScrolledFrame has a signal for this. */
   gtk_signal_connect_object (GTK_OBJECT (frame), "user_vchanged",
                              GTK_SIGNAL_FUNC (Dw_gtk_viewport_remove_anchor),
                              GTK_OBJECT (viewport));
#if 0
   /* This does not seem to work for GtkLayout's (see also dw_embed_gtk.c): */
   gtk_container_set_focus_hadjustment (GTK_CONTAINER (viewport),
                                        hadjustment);
   gtk_container_set_focus_vadjustment (GTK_CONTAINER (viewport),
                                        vadjustment);
#endif
}


/*
 * Standard Gtk+ function
 */
static void Dw_gtk_scrolled_window_class_init (GtkDwScrolledWindowClass *klass)
{
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkContainerClass *container_class;

   object_class = (GtkObjectClass*) klass;
   widget_class = (GtkWidgetClass*) klass;
   container_class = (GtkContainerClass*) klass;
   parent_class = gtk_type_class (GTK_TYPE_SCROLLED_WINDOW);

   object_class->destroy = Dw_gtk_scrolled_window_destroy;

   widget_class->map = Dw_gtk_scrolled_window_map;
   widget_class->unmap = Dw_gtk_scrolled_window_unmap;
   widget_class->draw = Dw_gtk_scrolled_window_draw;
   widget_class->size_allocate = Dw_gtk_scrolled_window_size_allocate;

   container_class->remove = Dw_gtk_scrolled_window_remove;
   container_class->forall = Dw_gtk_scrolled_window_forall;
}

/*
 * Standard Gtk+ function
 */
static void Dw_gtk_scrolled_window_destroy (GtkObject *object)
{
   GtkDwScrolledWindow *scrolled = GTK_DW_SCROLLED_WINDOW (object);

   if (scrolled->gadget)
      gtk_widget_destroy (scrolled->gadget);

   GTK_OBJECT_CLASS(parent_class)->destroy (object);
}

/*
 * Standard Gtk+ function
 */
static void Dw_gtk_scrolled_window_map (GtkWidget *widget)
{
   GtkDwScrolledWindow *scrolled = GTK_DW_SCROLLED_WINDOW (widget);

   GTK_WIDGET_CLASS(parent_class)->map (widget);

   if (scrolled->gadget && GTK_WIDGET_VISIBLE (scrolled->gadget) &&
       !GTK_WIDGET_MAPPED (scrolled->gadget))
      gtk_widget_map (scrolled->gadget);
}

/*
 * Standard Gtk+ function
 */
static void Dw_gtk_scrolled_window_unmap (GtkWidget *widget)
{
   GtkDwScrolledWindow *scrolled = GTK_DW_SCROLLED_WINDOW (widget);

   GTK_WIDGET_CLASS(parent_class)->unmap (widget);

   if (scrolled->gadget && GTK_WIDGET_MAPPED (scrolled->gadget))
      gtk_widget_unmap (scrolled->gadget);
}

/*
 * Standard Gtk+ function
 */
static void Dw_gtk_scrolled_window_draw (GtkWidget *widget,
                                         GdkRectangle *area)
{
   GtkDwScrolledWindow *scrolled = GTK_DW_SCROLLED_WINDOW (widget);
   GdkRectangle child_area;

   GTK_WIDGET_CLASS(parent_class)->draw (widget, area);

   if (scrolled->gadget && GTK_WIDGET_VISIBLE (scrolled->gadget) &&
       gtk_widget_intersect (scrolled->gadget, area, &child_area))
      gtk_widget_draw (scrolled->gadget, &child_area);
}


/*
 * Standard Gtk+ function
 */
static void Dw_gtk_scrolled_window_size_allocate (GtkWidget *widget,
                                                  GtkAllocation *allocation)
{
   GtkDwViewport *viewport;
   GtkAllocation old_allocation = widget->allocation, child_allocation;
   GtkRequisition child_requisition;
   GtkDwScrolledWindow *scrolled;
   GtkWidget *hscrollbar, *vscrollbar;
   gint gx, gy;