dw_viewport.c

嵌入式下基于MiniGUI的Web Browser

      
      return anchor->name;
   }
}


/*
 * Assign a position for an already existing anchor.
 */
void p_Dw_viewport_change_anchor (DwWidget *widget,
                                      gchar *name,
                                      gint32 y)
{
   DwViewport *viewport;
   DwViewportAnchor *anchor;
   gpointer tmp_anchor;
   gboolean exists;

   _MSG("changing anchor %p/'%s' -> %d\n", widget, name, y);

   g_return_if_fail (widget->viewport != NULL);
   viewport = DW_VIEWPORT (widget->viewport);

   exists =
      g_hash_table_lookup_extended (viewport->anchors_table, name, NULL,
                                    &tmp_anchor);
   g_return_if_fail(exists);

   anchor = tmp_anchor;
   g_return_if_fail(anchor->widget == widget);

   anchor->y = y;

   Dw_viewport_update_anchor (viewport);
}


/*
 * Remove an anchor from the table in the viewport. Notice that "name"
 * is freed here.
 */
void p_Dw_viewport_remove_anchor (DwWidget *widget,
                                      gchar *name)
{
   DwViewport *viewport;
   DwViewportAnchor *anchor;
   gpointer tmp_anchor;
   gboolean exists;

   _MSG("removing anchor %p/'%s'\n", widget, name);

   g_return_if_fail (widget->viewport != NULL);
   viewport = DW_VIEWPORT (widget->viewport);

   exists = 
      g_hash_table_lookup_extended (viewport->anchors_table, name, NULL,
                                    &tmp_anchor);
   g_return_if_fail(exists);

   anchor = tmp_anchor;
   g_return_if_fail(anchor->widget == widget);
   
   g_hash_table_remove (viewport->anchors_table, name);
   g_free (anchor->name);
   g_free (anchor);
}


/*
 * 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;
   }
}

/*
 * Drawing and resizing is done in this idle function.
 */
gint a_Dw_viewport_draw_resize (DwViewport *viewport)
{
   DwRectangle viewport_area, world_area;
   RECT redraw_area;
   int i;

   for (i = 0; i < viewport->num_draw_areas; i++) {

      viewport_area.x = viewport->world_x;
      viewport_area.y = viewport->world_y;
      viewport_area.width = viewport->allocation.width;
      viewport_area.height = viewport->allocation.height;

      if (p_Dw_rectangle_intersect (&viewport->draw_areas[i],
                                    &viewport_area, &world_area)) {
         redraw_area.left = world_area.x - viewport_area.x;
         redraw_area.top = world_area.y - viewport_area.y;
         redraw_area.right = redraw_area.left + world_area.width;
         redraw_area.bottom = redraw_area.top + world_area.height;
         InvalidateRect (viewport->hwnd, &redraw_area, TRUE);
      }
   }

   /* No more areas to be drawn. */
   viewport->num_draw_areas = 0;

   if (viewport->draw_resize_action == DW_VIEWPORT_RESIZE)
      Dw_viewport_calc_size (viewport);

   return 0;
}

/*
 * 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)
{
   MSG msg;
   DwRectangle area;
   int i;

   if (!PeekPostMessage (&msg, viewport->hwnd, MGD_RESIZE, 
                           MGD_RESIZE, PM_NOREMOVE)) {
      PostMessage (viewport->hwnd, MGD_RESIZE, DW_VIEWPORT_DRAW, 
                      (LPARAM)viewport);
   }

   if (viewport->draw_resize_action != DW_VIEWPORT_RESIZE) {
      viewport->draw_resize_action = DW_VIEWPORT_DRAW;
   }

   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.
    */
   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;
}

/*
 * 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)
{
   MSG msg;

   /* Resizing always overrides drawing. */
   viewport->draw_resize_action = DW_VIEWPORT_RESIZE;
   
   if (!PeekPostMessage (&msg, viewport->hwnd, MGD_RESIZE, 
                           MGD_RESIZE, PM_NOREMOVE)) {
      PostMessage (viewport->hwnd, MGD_RESIZE, DW_VIEWPORT_RESIZE, 
                      (LPARAM)viewport);
   }
}

/*
 * 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;   
}