CSIM

/* Copyright 1997 Acorn Computers Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/***************************************************/
/* File   : CSIM.c                                 */
/*                                                 */
/* Purpose: Client-side image map support.         */
/*                                                 */
/* Author : A.D.Hodgkinson                         */
/*                                                 */
/* History: 13-Nov-97: Created.                    */
/***************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "swis.h"

#include "HTMLLib.h" /* HTML library API, Which will include html2_ext.h, tags.h and struct.h */

#include "wimp.h"
#include "wimplib.h"
#include "event.h"

#include "svcprint.h"
#include "Global.h"
#include "FromROSLib.h"
#include "MiscDefs.h"
#include "Utils.h"

#include "Fetch.h"
#include "Redraw.h"

#include "CSIM.h"

/* Local structures */

typedef struct csim_polygon_vertex
{
  int x;
  int y;
}
csim_polygon_vertex;

/*************************************************/
/* csim_within()                                 */
/*                                               */
/* Given a token representing an A tag with      */
/* associated AREA-like information and x and y  */
/* coordinates in the same coordinate space as   */
/* the A tag, works out if those coordinates lie */
/* within the area the A tag describes.          */
/*                                               */
/* Parameters: Pointer to the token;             */
/*                                               */
/*             X coordinate;                     */
/*                                               */
/*             Y coordinate.                     */
/*                                               */
/* Returns:    1 if the coordinates lie within   */
/*             the area described by the token,  */
/*             2 if they lie within it because   */
/*             the item is the DEFAULT area, and */
/*             0 if the coordinates do not lie   */
/*             within the area.                  */
/*                                               */
/* Assumes:    The token represents an anchor    */
/*             with associated coordinate info.  */
/*************************************************/

int csim_within(HStream * t, int relx, int rely)
{
  areashape type;
  int       n;

  if (!t->coords) return 0;

  /* Find the shape type and number of coordinates */

  type = (areashape) t->coords[0];
  n    = t->coords[1];

  /* Deal with each type */

  switch (type)
  {
    /* Rectangles must have four coordinates */

    case areashape_RECT:
    {
      if (n != 4) return 0;

      return (
               relx >= t->coords[2] && /* xmin */
               rely >= t->coords[3] && /* ymin */
               relx <= t->coords[4] && /* xmax */
               rely <= t->coords[5]    /* ymax */
             );
    }
    break;

    /* Circles need 3 coordinates (x, y, r) */

    case areashape_CIRCLE:
    {
      if (n != 3) return 0;

      relx -= t->coords[2];
      rely -= t->coords[3];

      return (
               relx         * relx         +
               rely         * rely         <
               t->coords[4] * t->coords[4]
             );
    }
    break;

    /* A polygon needs at least 3 coordinate pairs, and we must */
    /* have an even number of them.                             */

    case areashape_POLY:
    {
      /* Check we've the right number of coordinates */

      if (n < 6 || n % 2) return 0;
      else
      {
        /* Adapted from clientmaps.c (S.Brodie), which was in */
        /* turn from imagemap.c, (Rob McCool).                */

        int                               crossings = 0;
        int                               xflag0;
        int                               y;

        const csim_polygon_vertex * const v0        = (csim_polygon_vertex *) (&(t->coords[2]));
        const csim_polygon_vertex * const vlast     = (csim_polygon_vertex *) (&(t->coords[n])); /* (Since coord 1 starts at array index 2) */

        const int                 *       stop      = ((int *) v0) + n;
        const int                 *       p;

        y = vlast->y;
        p = &v0->y;

        /* Does the given y coordinate lie between the first and last vertex y positions? */

        if ((y >= rely) != (*p >= rely))
        {
          /* Set xflag0 if the given x coordinate is left of the last vertex x position */

          xflag0 = vlast->x >= relx;

          /* Compare whether this against whether or not the given x coordinate is left */
          /* of the first vertex x position.                                            */

          if (xflag0 == (v0->x >= relx))
          {
            /* If xflag0 is set here, the given x coordinate is left of both the first */
            /* and last vertex x positions - increment 'crossings'. Else it is right   */
            /* of them both.                                                           */

            if (xflag0) ++crossings;
          }
          else
          {
            /* If we reach here, the given x coordinate is neither wholly to the left */
            /* of the first and last vertex x positions, or to the right; so it must  */
            /* lie between them.                                                      */

            crossings += (
                           vlast->x -
                           (
                             ((y - rely) * (v0->x - vlast->x)) / (*p - y)
                           )
                         )
                         >= relx;
          }
        }

        /* Start with y pointing to the first vertex y coordinate, */
        /* then increment p to point to the next y coordinate.     */
        /* We can thus go round the polygon comparing coordinate   */
        /* pairs (sides of the polygon) against the given coords.  */

        for (y = *p, p += 2; p < stop; y = *p, p += 2)
        {
          if (y >= rely)
          {
            /* If the given y coordinate lies left of the current vertex */
            /* y coordinate, skip 'p' along until it points to another   */
            /* y coordinate right of the given one.                      */

            while (p < stop && (*p >= rely)) p += 2;
          }
          else
          {
            /* ...Or if the given y coordinate lies to the right of the */
            /* current vertex, skip 'p' long until it points to a y     */
            /* coordinate right of the given one.                       */

            while (p < stop && (*p < rely)) p += 2;
          }

          /* If p is no longer in the vertex array, then there is no vertex */
          /* to the right of the given y coordinate and the given point     */
          /* cannot lie in the polygon.                                     */

          if (p >= stop) break;

          /* So 'p' points to the second y coordinate of a pair of vertices; */
          /* 'p - 3' thus points to the first x coordinate, and so-on. So,   */
          /* set xflag0 if the first vertex x coordinate is right of the     */
          /* given x coordinate.                                             */

          xflag0 = (*(p - 3) >= relx);

          /* Compare this against whether or not the second vertex x coordinate */
          /* is in the same position relative to (i.e. left or right of) the    */
          /* given x coordinate.                                                */

          if (xflag0 == (*(p - 1) >= relx))
          {
            /* If xflag0 is set, then, then the given x coordinate lies to the left of */
            /* both of the vertices (increment crossings). Else it's to the right.     */

            if (xflag0) ++crossings;
          }
          else
          {
            /* If we reach here, the given x coordinate is between the two vertices' */
            /* x coordinates.                                                        */

            crossings += (
                           *(p - 3) -
                           (
                             ((*(p - 2) - rely) * (*(p - 1) - *(p - 3))) / (*p - *(p - 2))
                           )
                         )
                         >= relx;
          }
        }

        return (crossings & 1);
      }
    }
    break;

    /* For DEFAULT areas, the coordinates always lie in it... */

    case areashape_DEFAULT:
    {
      return 2;
    }
    break;
  }

  return 0;
}

/*************************************************/
/* csim_return_info                              */
/*                                               */
/* The high level interface. Given a browser,    */
/* token and relative coordinates from the top   */
/* left of the image the token represents,       */
/* returns a URL and target - the token must     */
/* represent an Object, which is an image with   */
/* image map details attached.                   */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the map;              */
/*                                               */
/*             Pointer to an HStream struct      */
/*             representing an Object, which is  */
/*             an image with an attached client  */
/*             side map;                         */
/*                                               */
/*             X offset from the top left of the */
/*             image in pixels to look up in the */
/*             map;                              */
/*                                               */
/*             Similarly, Y offset (positive     */
/*             downwards);                       */
/*                                               */
/*             Pointer to a char *, in which a   */
/*             pointer to the URL to fetch will  */
/*             be placed;                        */
/*                                               */
/*             Pointer to a char *, in which a   */
/*             pointer to a target window name   */
/*             for the fetch will be placed;     */
/*                                               */
/*             Pointer to a char *, in which a   */
/*             pointer to alternative text       */
/*             to display in place of the        */
/*             URL will be placed.               */
/*                                               */
/* Returns:    See parameters; note that any of  */
/*             the values returned may be NULL.  */
/*             If the URL is NULL, then the      */
/*             token didn't represent an image   */
/*             map or the coordinates didn't lie */
/*             within a region the map defines.  */
/*                                               */
/* Assumes:    Any of the char * pointers may be */
/*             NULL.                             */
/*************************************************/

void csim_return_info(browser_data * b, HStream * t, int relx, int rely,
                      char ** url, char ** target, char ** alt)
{
  HStream * item;
  char    * defurl    = NULL;
  char    * deftarget = NULL;
  char    * defalt    = NULL;

  /* Start with everything pointing nowhere */

  if (url)    *url    = NULL;
  if (target) *target = NULL;
  if (alt)    *alt    = NULL;

  /* Initial sanity checks */

  if (!b || !t) return;

  if (!(t->type & TYPE_ISCLIENTMAP)) return;

  /* Now start looking at what area the coordinates are over */

  if (ISOBJECT(t) & HtmlOBJECTshapes(t)) item = HtmlOBJECTstream(t);
  else                                   item = HtmlOBJECTmapstream(t);

  if (!item) return;

  /* Go through the Object's token stream */

  while (item)
  {
    /* Is this an A tag with associated URL? */

    if (ISLINK(item))
    {
      int result = csim_within(item, relx, rely);

      if (result == 1)
      {
        /* Found it (remember, if areas overlap, we */
        /* are supposed to take the first).         */

        if (url)    *url    = item->anchor;
        if (target) *target = item->target;
        if (alt)    *alt    = item->text;

        return;
      }

      if (result == 2)
      {
        /* Found the default details, to use if all else fails */

        defurl    = item->anchor;
        deftarget = item->target;
        defalt    = item->text;
      }
    }

    /* Try the next HStream structure */

    item = item->next;
  }

  /* Finished - return whatever defaults were specified in */
  /* the map, or NULL if there were none.                  */

  if (url)    *url    = defurl;
  if (target) *target = deftarget;
  if (alt)    *alt    = defalt;

  return;
}

/*************************************************/
/* csim_highlight_region()                       */
/*                                               */
/* Draw a border around whatever region the      */
/* map_x and map_y fields of a browser_data      */
/* structure indicate.                           */
/*                                               */
/* Parameters: Pointer to the browser_data       */
/*             struct holding info on the token  */
/*             representing the map and the      */
/*             offset x and y coordinates        */
/*             indicating what part of the map   */
/*             is to be highlighted;             */
/*                                               */
/*             Colour to use for the region      */
/*             highlight (see redraw_set_colour  */
/*             in Redraw.c for the format of     */
/*             the colour number);               */
/*                                               */
/*             Left hand x coordinate (screen    */
/*             coords) that the image is plotted */
/*             at;                               */
/*                                               */
/*             Similarly the top y coordinate    */
/*             that the image is plotted at.     */
/*************************************************/

void csim_highlight_region(browser_data * b, int colour, int left_x, int top_y)
{
  HStream * t;
  HStream * item;

  /* Initial sanity checks */

  if (!b) return;

  t = b->pointer_over;

  if (!t || !(t->type & TYPE_ISCLIENTMAP)) return;

  /* Now start looking at what area the coordinates are over */

  if (ISOBJECT(t) & HtmlOBJECTshapes(t)) item = HtmlOBJECTstream(t);
  else                                   item = HtmlOBJECTmapstream(t);

  if (!item) return;

  /* Go through the Object's token stream */

  while (item)
  {
    /* Is this an A tag with associated URL? */

    if (ISLINK(item))
    {
      if (csim_within(item, b->map_x, b->map_y))
      {
        /* Found it (remember, if areas overlap, we */
        /* are supposed to take the first).         */

        areashape type;
        int       n;

        if (!item->coords) return;

        /* Find the shape type and number of coordinates */

        type = (areashape) item->coords[0];
        n    = item->coords[1];

        /* Deal with each type */

        switch (type)
        {
          case areashape_RECT:
          {
            BBox rect;

            if (n != 4) return;

            rect.xmin = left_x + item->coords[2] * 2; /* 1 'web pixel' = 2 OS units */
            rect.ymin = top_y  - item->coords[5] * 2;
            rect.xmax = left_x + item->coords[4] * 2;
            rect.ymax = top_y  - item->coords[3] * 2;

            redraw_border_around_box(&rect, colour);
          }
          break;

          case areashape_CIRCLE:
          {
            if (n != 3) return;

            redraw_set_colour(colour);

            /* Draw the main circle around the outside     */
            /* of the area, then 'blur' around a 1 OS unit */
            /* centre point to get a thicker outline.      */

            bbc_circle(left_x + item->coords[2] * 2, /* 1 'web pixel' = 2 OS units */
                       top_y  - item->coords[3] * 2,
                       item->coords[4] * 2 + 2);

            bbc_circle(left_x + item->coords[2] * 2 + 1,
                       top_y  - item->coords[3] * 2 + 1,
                       item->coords[4] * 2 + 2);

            bbc_circle(left_x + item->coords[2] * 2 + 1,
                       top_y  - item->coords[3] * 2 - 1,
                       item->coords[4] * 2 + 2);

            bbc_circle(left_x + item->coords[2] * 2 - 1,
                       top_y  - item->coords[3] * 2 + 1,
                       item->coords[4] * 2 + 2);

            bbc_circle(left_x + item->coords[2] * 2 - 1,
                       top_y  - item->coords[3] * 2 - 1,
                       item->coords[4] * 2 + 2);
          }
          break;

          case areashape_POLY:
          {
            int coord;
            int vx, vy;
            int lx, ly;

            if (n < 6 || n % 2) return;

            redraw_set_colour(colour);

            lx = left_x + item->coords[2] * 2; /* 1 'web pixel' = 2 OS units */
            ly = top_y  - item->coords[3] * 2;

            for (
                  coord = 2,
                  vx    = left_x + item->coords[coord + 2] * 2,
                  vy    = top_y  - item->coords[coord + 3] * 2;

                  coord < n;

                  coord += 2,
                  vx    = left_x + item->coords[coord + 2] * 2,
                  vy    = top_y  - item->coords[coord + 3] * 2
                )
            {
              /* Draw the outline at the exact border coordinates  */
              /* and 'blur' 1 OS unit in NE/NW/SE/SW directions to */
              /* make the border thicker.                          */

              bbc_move(lx,     ly);
              bbc_draw(vx,     vy);
              bbc_move(lx + 1, ly + 1);
              bbc_draw(vx + 1, vy + 1);
              bbc_move(lx + 1, ly - 1);
              bbc_draw(vx + 1, vy - 1);
              bbc_move(lx - 1, ly + 1);
              bbc_draw(vx - 1, vy + 1);
              bbc_move(lx - 1, ly - 1);
              bbc_draw(vx - 1, vy - 1);

              lx = vx, ly = vy;
            }
          }
          break;
        }

        /* Finished */

        return;
      }
    }

    /* Try the next HStream structure */

    item = item->next;
  }

  /* Finished */

  return;
}