dw_viewport.c

飞漫公司的minigui的1.6.8收费增值版本的demon等示例程序

   return callback_data.widget;
}


/*************
 *           *
 *  Anchors  *
 *           *
 *************/

/*
 * Add or change an anchor.
 * The widget is responsible for storing a copy of name.
 * 
 * todo: Currently, no horizontal scrolling is done. This is generally
 * possible, DW_HPOS_INTO_VIEW should be used for this, but it is
 * rather complicated to determine the width of an anchor. This would
 * be the lenght of the region between <a> and </a>, the page widget
 * would have to have two kinds of content types (opening and closing
 * anchor), and some changes in the HTML parser are necessary.
 */
void p_Dw_viewport_put_anchor (DwWidget *widget,
                                   gchar *name,
                                   gint32 y)
{
   DwViewport *viewport;
   DwViewportAnchor *anchor;

   viewport = (DwViewport *) widget->viewport;
   _MSG("  name(%p)=[%s]\n", name, name);
   if (!g_hash_table_lookup_extended (viewport->anchors_table, name, NULL,
                                      (gpointer*)&anchor)) {
      anchor = g_new (DwViewportAnchor, 1);
      g_hash_table_insert (viewport->anchors_table, name, anchor);
   }

   anchor->widget = widget;
   anchor->y = y;

   Dw_viewport_update_anchor (viewport);
}

/*
 * Called when possibly the scroll position has to be changed because
 * of anchors.
 */
void Dw_viewport_update_anchor (DwViewport *viewport)
{
   DwViewportAnchor *anchor;

   if (viewport->anchor &&
       g_hash_table_lookup_extended (viewport->anchors_table, viewport->anchor,
                                     NULL, (gpointer*)&anchor)) {
      Dw_viewport_scroll_to (viewport, DW_HPOS_NO_CHANGE, DW_VPOS_TOP,
                                 0, anchor->y + anchor->widget->allocation.y,
                                 0, 0);
   }
}


/*
 * Sets the anchor to scroll to.
 */
void a_Dw_viewport_set_anchor (DwViewport *viewport,
                                   const gchar *anchor)
{
   Dw_viewport_remove_anchor (viewport);

   if (anchor) {
      viewport->anchor = g_strdup (anchor);
      Dw_viewport_update_anchor (viewport);
   } else {
      viewport->anchor = NULL;
      viewport->world_y = 0;
      SetScrollPos (viewport->hwnd, SB_VERT, 0);
   }
}

/*
 * Used by Dw_viewport_update_anchor_idle.
 */
static gboolean Dw_viewport_calc_into (gint32 requested_value,
                                           gint32 requested_size,
                                           gint32 current_value,
                                           gint32 size,
                                           gint32 *return_value)
{
   if (requested_size > size) {
      /* The viewport size is smaller than the size of the region which will
       * be shown. If the region is already visible, do not change the
       * position. Otherwise, show the left/upper border, this is most likely
       * what is needed. */
      if (current_value >= requested_value &&
          current_value + size < requested_value + requested_size)
         return FALSE;
      else
         requested_size = size;
   }

   if (requested_value < current_value) {
      *return_value = requested_value;
      return TRUE;
   } else if (requested_value + requested_size > current_value + size) {
      *return_value = requested_value - size + requested_size;
      return TRUE;
   } else
      return FALSE;
}

/*
 * See Dw_viewport_scroll_to.
 */
static gint Dw_viewport_update_anchor_idle (DwViewport *viewport)
{
   gint32 vp_width, vp_height, x = 0, y = 0;
   gboolean change_x, change_y;

   vp_width = viewport->allocation.width;
   vp_height = viewport->allocation.height;

   change_x = TRUE;
   switch (viewport->anchor_pos.hpos) {
   case DW_HPOS_LEFT:
      x = viewport->anchor_pos.x;
      break;
   case DW_HPOS_CENTER:
      x = viewport->anchor_pos.x - (vp_width - viewport->anchor_pos.width) / 2;
      break;
   case DW_HPOS_RIGHT:
      x = viewport->anchor_pos.x - (vp_width - viewport->anchor_pos.width);
      break;
   case DW_HPOS_INTO_VIEW:
      change_x = Dw_viewport_calc_into (viewport->anchor_pos.x,
                                            viewport->anchor_pos.width,
                                            viewport->world_x, vp_width, &x);
      break;
   case DW_HPOS_NO_CHANGE:
      change_x = FALSE;
      break;
   }

   change_y = TRUE;
   switch (viewport->anchor_pos.vpos) {
   case DW_VPOS_TOP:
      y = viewport->anchor_pos.y;
      break;
   case DW_VPOS_CENTER:
      y = viewport->anchor_pos.y -
         (vp_height - viewport->anchor_pos.height) / 2;
      break;
   case DW_VPOS_BOTTOM:
      y = viewport->anchor_pos.y - (vp_height - viewport->anchor_pos.height);
      break;
   case DW_VPOS_INTO_VIEW:
      change_y = Dw_viewport_calc_into (viewport->anchor_pos.y,
                                            viewport->anchor_pos.height,
                                            viewport->world_y, vp_height, &y);
   case DW_VPOS_NO_CHANGE:
      change_y = FALSE;
      break;
   }

   if (change_x) {
      MGD_scroll_to_x (viewport, x);
   }

   if (change_y) {
      MGD_scroll_to_y (viewport, y);
   }

   return FALSE;
}

/*
 * Sets the position to scroll to. The current anchor will be removed.
 */
void a_Dw_viewport_set_scrolling_position (DwViewport *viewport,
                                               gint32 x,
                                               gint32 y)
{
   Dw_viewport_remove_anchor (viewport);
   Dw_viewport_scroll_to (viewport, DW_HPOS_LEFT, DW_VPOS_TOP, x, y, 0, 0);
}

/*
 * Scrolls the viewport, so that the region [x, y, width, height] (world
 * coordinates) is seen, according to hpos and vpos.
 *
 * The actual scrolling is done in an idle function.
 */
void Dw_viewport_scroll_to (DwViewport *viewport,
                                DwHPosition hpos,
                                DwVPosition vpos,
                                gint32 x,
                                gint32 y,
                                gint32 width,
                                gint32 height)
{
   viewport->anchor_pos.hpos = hpos;
   viewport->anchor_pos.vpos = vpos;
   viewport->anchor_pos.x = x;
   viewport->anchor_pos.y = y;
   viewport->anchor_pos.width = width;
   viewport->anchor_pos.height = height;

   DBG_OBJ_SET_NUM (viewport, "anchor_pos.hpos", viewport->anchor_pos.hpos);
   DBG_OBJ_SET_NUM (viewport, "anchor_pos.vpos", viewport->anchor_pos.vpos);
   DBG_OBJ_SET_NUM (viewport, "anchor_pos.x", viewport->anchor_pos.x);
   DBG_OBJ_SET_NUM (viewport, "anchor_pos.y", viewport->anchor_pos.y);
   DBG_OBJ_SET_NUM (viewport, "anchor_pos.width", viewport->anchor_pos.width);
   DBG_OBJ_SET_NUM (viewport, "anchor_pos.height",
                    viewport->anchor_pos.height);

   Dw_viewport_update_anchor_idle (viewport);
}

/*
 * Remove anchor and idle function.
 */
void Dw_viewport_remove_anchor (DwViewport *viewport)
{
   if (viewport->anchor) {
      g_free (viewport->anchor);
      viewport->anchor = NULL;
   }
}

/*
 * Queue an area for drawing. This function is called by
 * p_Dw_widget_queue_draw_area. x and y are passed in world coordinates.
 */
void Dw_viewport_queue_draw (DwViewport *viewport,
                                 gint32 x,
                                 gint32 y,
                                 gint32 width,
                                 gint32 height)
{
#if 0
   DwRectangle area;
   int i;

   if (viewport->draw_resize_idle_id == 0) {
      viewport->draw_resize_action = DW_GTK_VIEWPORT_DRAW;
      viewport->draw_resize_idle_id =
         idle_add (Dw_viewport_draw_resize_idle, (gpointer)viewport);
   } else if (viewport->draw_resize_action == DW_GTK_VIEWPORT_RESIZE)
      /* Drawing is always overridden by resizing. */
      return;

   area.x = x;
   area.y = y;
   area.width = width;
   area.height = height;

   /* First, try to keep the list as clean as possible. Check whether other
    * rectangles interfer with this one in some way. */
   /* An idea for optimization: The list could be sorted, and so the part of
    * the list we have to consider here, may be reduced, the start may be
    * found via linear search. However, this probably makes balanced binary
    * trees necessary, since moving elements within the array may be quite
    * time-consuming.
    */
   _MSG("  num_draw_areas = %d\n", viewport->num_draw_areas);
   for (i = 0; i < viewport->num_draw_areas; i++) {
      if (p_Dw_rectangle_is_subset (&area, &viewport->draw_areas[i]))
         /* First case: area is a subset of an already queued rectangle
          * -> nothing to do. */
         return;
      else if (p_Dw_rectangle_is_subset (&viewport->draw_areas[i], &area)) {
         /* Second case: area is a subset of an already queued rectangle
          * -> replace the other one with area. */
         viewport->draw_areas[i] = area;
         return;
      }
      /* Maybe some more tests: if both areas may exactly be combined to a
       * rectangle? Very unlikely case ... */
   }

   /* No interference: add  the new area to the list. */
   viewport->num_draw_areas++;
   a_List_add (viewport->draw_areas, viewport->num_draw_areas,
               viewport->num_draw_areas_max);
   viewport->draw_areas[viewport->num_draw_areas - 1] = area;
#else
    //printf ("Dw_viewport_queue_draw called.\n");
#endif
}

/*
 * Start the resizing idle. This function is called by
 * p_Dw_widget_queue_resize, after the appropriate attributes have been set in
 * the widgets, where necessary.
 */
void Dw_viewport_queue_resize (DwViewport *viewport)
{
#if 0
   /* Resizing always overrides drawing. */
   viewport->draw_resize_action = DW_GTK_VIEWPORT_RESIZE;
   viewport->num_draw_areas = 0;
   
   if (viewport->draw_resize_idle_id == 0)
      viewport->draw_resize_idle_id =
         idle_add (Dw_viewport_draw_resize_idle, (gpointer)viewport);
#else
    //printf ("Dw_viewport_queue_resize called.\n");
#endif
}


/*
 * Return the DwWidget which is at position (vx, vy) in viewport coordinates.
 */
DwWidget* a_Dw_viewport_widget_at_viewport_point (DwViewport *viewport,
                                                      gint32 vx,
                                                      gint32 vy)
{
   gint32 world_x, world_y;

   if (viewport->child) {
      world_x = vx + viewport->world_x;
      world_y = vy + viewport->world_y;
      return Dw_viewport_widget_at_point (viewport, world_x, world_y);
   } else
      return NULL;   
}