Mouse

/* 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   : Mouse.c                                */
/*                                                 */
/* Purpose: Mouse pointer related functions for    */
/*          the browser.                           */
/*                                                 */
/* Author : A.D.Hodgkinson                         */
/*                                                 */
/* History: 14-Mar-97: Created.                    */
/***************************************************/

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

#include "swis.h"
#include "kernel.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 "toolbox.h"

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

#include "Handlers.h"

#include "Mouse.h"

/* Locals */

static int mouse_watch = 0;

static int mouse_x;
static int mouse_y;
static int mouse_time;
static int mouse_on    = 1;
static int mouse_shape = 1;
static int mouse_used  = 0;

/*************************************************/
/* mouse_watch_pointer_control()                 */
/*                                               */
/* Controls watching movement of the mouse       */
/* pointer; if turned on, when the pointer moves */
/* the function will ensure that the pointer is  */
/* also visible.                                 */
/*                                               */
/* Parameters: 1 to turn watching on, 0 to turn  */
/*             it off.                           */
/*************************************************/

void mouse_watch_pointer_control(int on)
{
  if (on)
  {
    if (!mouse_watch)
    {
      mouse_x = mouse_y = mouse_time = -1;
      register_null_claimant(Wimp_ENull, mouse_watch_pointer, NULL);
      mouse_watch = 1;
    }
  }
  else
  {
    if (mouse_watch)
    {
      deregister_null_claimant(Wimp_ENull, mouse_watch_pointer, NULL);
      mouse_watch = 0;
    }
  }
}

/*************************************************/
/* mouse_watch_pointer()                         */
/*                                               */
/* Watches to see if the mouse pointer moves,    */
/* and if so, ensures the pointer is visible.    */
/*                                               */
/* Parameters are as standard for a Wimp event   */
/* handler.                                      */
/*************************************************/

int mouse_watch_pointer(int eventcode, WimpPollBlock * block, IdBlock * idb, void * handle)
{
  WimpGetPointerInfoBlock i;

  if (!wimp_get_pointer_info(&i))
  {
    if (mouse_x    < 0) mouse_x = i.x;
    if (mouse_y    < 0) mouse_y = i.y;
    if (mouse_time < 0) _swix(OS_ReadMonotonicTime, _OUT(0), &mouse_time);

    if (mouse_x != i.x || mouse_y != i.y)
    {
      if (!mouse_on) mouse_pointer_on();

      mouse_x = mouse_y = mouse_time = -1;

      mouse_used = 1;
    }
    else if (mouse_on)
    {
      int t;

      _swix(OS_ReadMonotonicTime, _OUT(0), &t);

      if (t - mouse_time > 500) mouse_pointer_off();
    }
  }

  return 0;
}

/*************************************************/
/* mouse_pointer_on()                            */
/*                                               */
/* Turns the mouse pointer on immediately.       */
/*************************************************/

void mouse_pointer_on(void)
{
  if (!mouse_on)
  {
    mouse_x = mouse_y = mouse_time = -1;
    mouse_on = 1;
    mouse_set_pointer_shape(mouse_shape);
  }
}

/*************************************************/
/* mouse_pointer_off()                           */
/*                                               */
/* Turns the mouse pointer off immediately.      */
/*************************************************/

void mouse_pointer_off(void)
{
  if (mouse_on && !mouse_used)
  {
    mouse_x = mouse_y = mouse_time = -1;
    mouse_set_pointer_shape(Mouse_Shape_Off);
    mouse_on = 0;
  }
}

/*************************************************/
/* mouse_force_unused()                          */
/*                                               */
/* Resets the internal mouse_used flag back to   */
/* zero, so that the mouse pointer may be        */
/* turned off (otherwise the user has moved the  */
/* pointer and it shouldn't be switched off).    */
/*************************************************/

void mouse_force_unused(void)
{
  mouse_used = 0;
}

/*************************************************/
/* mouse_set_pointer_shape()                     */
/*                                               */
/* Sets the shape of the pointer; shape 0 turns  */
/* it off. If mouse_on is set to zero, this will */
/* *not* override that setting.                  */
/*                                               */
/* Parameters: Pointer shape; see Mouse.h for    */
/*             definitions of shapes.            */
/*************************************************/

void mouse_set_pointer_shape(int shape)
{
  if (shape) mouse_shape = shape;

  /* If the mouse is turned off, don't turn it back on... */

  if (shape && !mouse_on) return;

  /* Otherwise change to the required shape */

  switch (shape)
  {
    case Mouse_Shape_Off:    _swix(OS_CLI,
                                   _IN(0),

                                   "Pointer 0");
    break;

    default: /* Catchall - use normal pointer, so no 'break' */

    case Mouse_Shape_Normal:    _swix(OS_CLI,
                                      _IN(0),

                                      "Pointer 1");
    break;

    case Mouse_Shape_Link:      _swix(OS_SpriteOp,
                                      _INR(0,7),

                                      292,
                                      sprite_block,
                                      "ptr_link",
                                      2,
                                      controls.ptrlnkactvx,
                                      controls.ptrlnkactvy,
                                      0,
                                      0);
    break;

    case Mouse_Shape_Map:       _swix(OS_SpriteOp,
                                      _INR(0,7),

                                      292,
                                      sprite_block,
                                      "ptr_map",
                                      2,
                                      controls.ptrmapactvx,
                                      controls.ptrmapactvy,
                                      0,
                                      0);
    break;

    case Mouse_Shape_UD:        _swix(OS_SpriteOp,
                                      _INR(0,7),

                                      292,
                                      sprite_block,
                                      "ptr_ud",
                                      2,
                                      controls.ptrudactvx,
                                      controls.ptrudactvy,
                                      0,
                                      0);
    break;

    case Mouse_Shape_LR:        _swix(OS_SpriteOp,
                                      _INR(0,7),

                                      292,
                                      sprite_block,
                                      "ptr_lr",
                                      2,
                                      controls.ptrlractvx,
                                      controls.ptrlractvy,
                                      0,
                                      0);
    break;

    case Mouse_Shape_UDLR:      _swix(OS_SpriteOp,
                                      _INR(0,7),

                                      292,
                                      sprite_block,
                                      "ptr_udlr",
                                      2,
                                      controls.ptrudlractvx,
                                      controls.ptrudlractvy,
                                      0,
                                      0);
    break;

    case Mouse_Shape_NoResize:  _swix(OS_SpriteOp,
                                      _INR(0,7),

                                      292,
                                      sprite_block,
                                      "ptr_noresize",
                                      2,
                                      controls.ptrnoractvx,
                                      controls.ptrnoractvy,
                                      0,
                                      0);
    break;

    case Mouse_Shape_ToScroll:  _swix(OS_SpriteOp,
                                      _INR(0,7),

                                      292,
                                      sprite_block,
                                      "ptr_toscroll",
                                      2,
                                      controls.ptrtosactvx,
                                      controls.ptrtosactvy,
                                      0,
                                      0);
    break;

    case Mouse_Shape_Scrolling: _swix(OS_SpriteOp,
                                      _INR(0,7),

                                      292,
                                      sprite_block,
                                      "ptr_scroll",
                                      2,
                                      controls.ptrscractvx,
                                      controls.ptrscractvy,
                                      0,
                                      0);
    break;
  }
}

/*************************************************/
/* mouse_pointer_is_on()                         */
/*                                               */
/* States whether the pointer is on or off.      */
/*                                               */
/* Returns:    1 if the pointer is on, else 0.   */
/*************************************************/

int mouse_pointer_is_on(void)
{
  if (mouse_on) return 1;

  return 0;
}

/*************************************************/
/* mouse_to()                                    */
/*                                               */
/* Moves the mouse to a given screen coordinate. */
/*                                               */
/* Parameters: X coordinate to move to;          */
/*                                               */
/*             Y coordinate to move to;          */
/*                                               */
/*             1 to always move, else only move  */
/*             if mouse_used is zero (so it      */
/*             looks as if the user has not yet  */
/*             used or does not have a mouse).   */
/*************************************************/

void mouse_to(int x, int y, int now)
{
  char block[5];

  if (!now && mouse_used) return;

  block[0] = 3;
  block[1] = x & 0xff;
  block[2] = x >> 8;
  block[3] = y & 0xff;
  block[4] = y >> 8;

  _swix(OS_Word,
        _INR(0, 1),

        21,
        block);
}

/*************************************************/
/* mouse_rectangle()                             */
/*                                               */
/* Constrains the mouse pointer to a given       */
/* rectangle, or returns the last rectangle set  */
/* with this function.                           */
/*                                               */
/* Parameters: Pointer to a BBox, in which the   */
/*             new rectangle is held, or NULL to */
/*             set no new rectangle;             */
/*                                               */
/*             1 to rectangle the pointer now,   */
/*             else only rectangle it if it is   */
/*             not flagged as being used.        */
/*                                               */
/* Returns:    Pointer to a BBox, in which the   */
/*             previously set coordinates are    */
/*             stored if the BBox pointer given  */
/*             as a parameter is NULL (else the  */
/*             coordinates in the given BBox     */
/*             will be the same as the coords    */
/*             in the returned BBox).            */
/*************************************************/

BBox * mouse_rectangle(BBox * rect, int now)
{
  char        block[9];
  static BBox last_rect;

  if (!now && mouse_used) return &last_rect;

  if (rect)
  {
    block[0] = 1;
    block[1] = rect->xmin & 0xff;
    block[2] = rect->xmin >> 8;
    block[3] = rect->ymin & 0xff;
    block[4] = rect->ymin >> 8;
    block[5] = rect->xmax & 0xff;
    block[6] = rect->xmax >> 8;
    block[7] = rect->ymax & 0xff;
    block[8] = rect->ymax >> 8;

    _swix(OS_Word,
          _INR(0, 1),

          21,
          block);
  }

  last_rect = *rect;

  return &last_rect;
}