FromROSLib

/* 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   : FromROSLib.c                           */
/*                                                 */
/* Purpose: The original Customer browser sources */
/*          used RISC_OSLib heavily and some of    */
/*          the functions used are handy to have   */
/*          around. This source file contains      */
/*          a variety of functions from RISC_OSLib */
/*          with modifications where necessary     */
/*          both to fit into the browser more      */
/*          naturally, and to function better      */
/*          under C release 5.                     */
/*                                                 */
/* Authors: Various for original RISC_OSLib source */
/*          This source adapted by A.D.Hodgkinson  */
/*                                                 */
/* History: 06-Dec-96: Created.                    */
/***************************************************/

#include <stdlib.h>
#include <stdarg.h>

#include "swis.h"

#include "wimp.h"

#include "FromROSLib.h"

/* Statics */

/* Array of length of sequence for vdu codes, */
/* used by the VDU call-based functions.      */

static char Qlen[32] =
{

  1,   /* VDU 0                          */
  2,   /* Next character to printer only */
  1,   /* Printer on                     */
  1,   /* Printer off                    */
  1,   /* Print at text cursor           */
  1,   /* Print at graphics cursor       */
  1,   /* Enable VDU driver              */
  1,   /* Beep                           */
  1,   /* Backspace                      */
  1,   /* Forward space (horizontal tab) */
  1,   /* Line feed                      */
  1,   /* Up a line                      */
  1,   /* Clear (text) screen            */
  1,   /* Carriage return                */
  1,   /* Page mode on                   */
  1,   /* Page mode off                  */
  1,   /* Clear graphics window          */
  2,   /* Define text colour             */
  3,   /* Define graphics colour         */
  6,   /* Define logical colour          */
  1,   /* Restore default palette        */
  1,   /* Disable VDU drivers            */
  2,   /* Select screen mode             */
  10,  /* VDU 23,..                      */
  9,   /* Set graphics window            */
  6,   /* PLOT ...                       */
  1,   /* Restore default windows        */
  1,   /* ESCAPE char - no effect        */
  5,   /* Define text window             */
  5,   /* Define graphics origin         */
  1,   /* Home cursor                    */
  3    /* Tab cursor                     */

};       /* ...and all the rest are 1. */

/* Cached eigen values */

static int wimpt_xeig = 2;
static int wimpt_yeig = 2;

/*************************************************/
/* bbc_modevar()                                 */
/*                                               */
/* Returns the value of a mode variable, or -1   */
/* if there was some error.                      */
/*                                               */
/* Parameters: A mode number or -1 for current;  */
/*                                               */
/*             A mode variable (for the SWI call */
/*             OS_ReadModeVariable).             */
/*                                               */
/* Returns:    The value of the variable, or -1  */
/*             if an error occurs.               */
/*************************************************/

int bbc_modevar(int mode, int varno)
{
  int result;

  if (_swix(OS_ReadModeVariable,
            _INR(0,1) | _OUT (2),
            mode,
            varno,
            &result)) return -1;

  return result;
}

/*************************************************/
/* bbc_vduvar()                                  */
/*                                               */
/* Returns the value of a VDU variable, or -1 to */
/* flag an error - therefore, if the variable    */
/* may hold -1 as a valid value, you need to use */
/* bbc_vduvars() instead.                        */
/*                                               */
/* Parameters: A VDU variable number for the     */
/*             SWI call OS_ReadVduVariables.     */
/*                                               */
/* Returns:    The value of the variable, or -1  */
/*             if an error occurs.               */
/*************************************************/

int bbc_vduvar(int varno)
{
   int vars[2];
   int result;

   vars[0] = varno;
   vars[1] = -1; /* terminator */

   return _swix(OS_ReadVduVariables,
                _INR(0,1),
                vars,
                &result)
                != NULL ? -1 : result; /* relies on -1 never being valid */
}

/*************************************************/
/* bbc_vduvars()                                 */
/*                                               */
/* Returns values of any number of VDU variables */
/*                                               */
/* Parameters: A pointer to a block holding a    */
/*             list of variable numbers,         */
/*             termianted by -1;                 */
/*                                               */
/*             A pointer to a block into which   */
/*             the corresponding variable values */
/*             will be placed. This may be the   */
/*             same block as the one holding the */
/*             variable numbers.                 */
/*                                               */
/* Returns:    The block holding the variable    */
/*             numbers is updated with the       */
/*             variable values, assuming the     */
/*             call doesn't return an error.     */
/*************************************************/

_kernel_oserror * bbc_vduvars(int * vars, int * values)
{
   return _swix(OS_ReadVduVariables,
                _INR(0,1),

                (int) vars,
                (int) values);
}

/*************************************************/
/* bbc_vduq()                                    */
/*                                               */
/* Output multiple characters. Runs through an   */
/* assembler routine bbc_vdu for speed.          */
/*                                               */
/* Parameters: A control character - the number  */
/*             of further characters to expect   */
/*             is defined in the static 'Qlen',  */
/*             defined at the top of this file,  */
/*             and depends on the char given.    */
/*************************************************/

_kernel_oserror * bbc_vduq(int c,...)
{
   _kernel_oserror * e;
   va_list           ap;
   int               n;

   e = bbc_vdu(c); /* See FromROSLib.s */

   if ((c >= ' ') || e) return(e);

   va_start(ap, c);
   n = Qlen[c];

   while ((--n) && (!e)) e = bbc_vdu(va_arg(ap,int));

   va_end(ap);

   return(e);
}

/*************************************************/
/* bbc_clg()                                     */
/*                                               */
/* Clears the current graphics window.           */
/*************************************************/

_kernel_oserror * bbc_clg(void)
{
  return (bbc_vdu(BBC_ClearGraph));
}

/*************************************************/
/* bbc_gwindow()                                 */
/*                                               */
/* Defines a graphics window.                    */
/*                                               */
/* Parameters: X coordinate of bottom left hand  */
/*             corner of graphics window in OS   */
/*             units, inclusive;                 */
/*                                               */
/*             Y coordinate for the same;        */
/*                                               */
/*             X coordinate of top right hand    */
/*             corner of graphics window in OS   */
/*             units, exclusive;                 */
/*                                               */
/*             Y coordinate for the same.        */
/*************************************************/

_kernel_oserror * bbc_gwindow(int xmin, int ymin, int xmax, int ymax)
{
  _kernel_oserror * e = bbc_vdu(BBC_DefGraphWindow);

  if (!e) e = bbc_vduw(xmin);
  if (!e) e = bbc_vduw(ymin);
  if (!e) e = bbc_vduw(xmax);
  if (!e) e = bbc_vduw(ymax);

  return e;
}

/*************************************************/
/* bbc_origin()                                  */
/*                                               */
/* Sets the graphics plotting origin.            */
/*                                               */
/* Parameters: X coordinate of origin, in OS     */
/*             units;                            */
/*                                               */
/*             Y coordinate for the same.        */
/*************************************************/

_kernel_oserror * bbc_origin(int x, int y)
{
   _kernel_oserror * e = bbc_vdu(BBC_DefGraphOrigin);

   if (!e) e = bbc_vduw(x);
   if (!e) e = bbc_vduw(y);

   return e;
}

/*************************************************/
/* bbc_gcol()                                    */
/*                                               */
/* Sets a graphics colour and plotting action.   */
/*                                               */
/* Graphics plotting actions:                    */
/*                                               */
/* P is pixel on screen.                         */
/* N is new colour.                              */
/*                                               */
/* Action  Behaviour                             */
/*                                               */
/* 0       P = N                                 */
/* 1       P |= N (OR)                           */
/* 2       P &= N (AND)                          */
/* 3       P = P ^ N (XOR)                       */
/* 4       P = !P (NOT)                          */
/* 5       P = P (no change to screen colour)    */
/* 6       P &= (!N) (AND NOT)                   */
/* 7       P |= (!N) (OR NOT)                    */
/* 8 -15   As 0-7 but background is transparent  */
/* 16-31   Pattern 1, with action 0 - 15         */
/* 32-47   Pattern 2, with action 0 - 15         */
/* 48-63   Pattern 3, with action 0 - 15         */
/* 64-79   Pattern 4, with action 0 - 15         */
/* 80-95   Large pattern, with action 0 - 15     */
/*                                               */
/* Parameters: Plotting action (see above);      */
/*                                               */
/*             Graphics colour (0-127 for the    */
/*             foreground, else background is    */
/*             set to colour - 128). The colour  */
/*             used is ANDed with the maximum    */
/*             number of colours for the screen  */
/*             mode (1,3, 15 or 63 for 2, 4, 16  */
/*             or >=256 colour modes).           */
/*************************************************/

_kernel_oserror * bbc_gcol(int a, int b)
{
   _kernel_oserror * e = bbc_vdu(BBC_DefGraphColour);

   if (!e) e = bbc_vdu(a);
   if (!e) e = bbc_vdu(b);

   return e;
}

/*************************************************/
/* bbc_plot()                                    */
/*                                               */
/* Plot something on the screen with OS_Plot.    */
/* See PRM volume 1 page 607 for full details.   */
/*                                               */
/* Parameters: Plot number;                      */
/*                                               */
/*             X coordinate;                     */
/*                                               */
/*             Y coordinate.                     */
/*************************************************/

_kernel_oserror * bbc_plot(int n, int x, int y)
{
  return _swix(OS_Plot,
               _INR(0,2),
               n,
               x,
               y);
}

/*************************************************/
/* bbc_move()                                    */
/*                                               */
/* Move the graphics cursor to absolute coords.  */
/*                                               */
/* Parameters: X coordinate to move to, in OS    */
/*             units;                            */
/*                                               */
/*             Y coordinate for the same.        */
/*************************************************/

_kernel_oserror * bbc_move(int x, int y)
{
   return bbc_plot(BBC_MoveCursorAbs, x, y);
}

/*************************************************/
/* bbc_moveby()                                  */
/*                                               */
/* Move the graphics cursor to absolute coords.  */
/*                                               */
/* Parameters: X offset to move by, in OS units; */
/*                                               */
/*             Y coordinate for the same.        */
/*************************************************/

_kernel_oserror * bbc_moveby(int x, int y)
{
   return bbc_plot(BBC_MoveCursorRel, x, y);
}

/*************************************************/
/* bbc_draw()                                    */
/*                                               */
/* Draws a solid line including both end points  */
/* to absolute coordinates, starting the line at */
/* the current graphics cursor position.         */
/*                                               */
/* Parameters: X coordinate to draw to, in OS    */
/*             units;                            */
/*                                               */
/*             Y coordinate for the same.        */
/*************************************************/

_kernel_oserror * bbc_draw(int x, int y)
{
   return bbc_plot(BBC_SolidBoth + BBC_DrawAbsFore, x, y);
}

/*************************************************/
/* bbc_drawby()                                  */
/*                                               */
/* Draws a solid line including both end points  */
/* to relative coordinates, starting the line at */
/* the current graphics cursor position.         */
/*                                               */
/* Parameters: X offset to draw by, in OS units; */
/*                                               */
/*             Y coordinate for the same.        */
/*************************************************/

_kernel_oserror * bbc_drawby(int x, int y)
{
   return bbc_plot(BBC_SolidBoth + BBC_DrawRelFore, x, y);
}

/*************************************************/
/* bbc_rectangle()                               */
/*                                               */
/* Plots a rectangle outline.                    */
/*                                               */
/* Parameters: X coordinate of bottom left hand  */
/*             corner, in OS units;              */
/*                                               */
/*             Y coordinate for the same;        */
/*                                               */
/*             Rectangle width plus one, in OS   */
/*             units - this is added to the X    */
/*             value to produce an *exclusive*   */
/*             top right hand corner coordinate, */
/*             hence for an 8 OS unit wide       */
/*             rectangle, say, you'd pass in 7;  */
/*                                               */
/*             Similarly, the rectangle height.  */
/*************************************************/

_kernel_oserror * bbc_rectangle(int x, int y, int w, int h)
{
   _kernel_oserror * e = bbc_move(x,y);

   if (!e) e = bbc_plot(BBC_SolidExFinal + BBC_DrawRelFore,  0,  h);
   if (!e) e = bbc_plot(BBC_SolidExFinal + BBC_DrawRelFore,  w,  0);
   if (!e) e = bbc_plot(BBC_SolidExFinal + BBC_DrawRelFore,  0, -h);
   if (!e) e = bbc_plot(BBC_SolidExFinal + BBC_DrawRelFore, -w,  0);

   return e;
}

/*************************************************/
/* bbc_rectanglefill()                           */
/*                                               */
/* Plots a filled rectangle.                     */
/*                                               */
/* Parameters: As bbc_rectangle.                 */
/*************************************************/

_kernel_oserror * bbc_rectanglefill(int x, int y, int w, int h)
{
   _kernel_oserror * e = bbc_move(x,y);

   if (!e) e = bbc_plot(BBC_RectangleFill + BBC_DrawRelFore, w, h);

   return e;
}

/*************************************************/
/* bbc_circle()                                  */
/*                                               */
/* Plots a circle outline.                       */
/*                                               */
/* Parameters: X coordinate of midpoint, in OS   */
/*             units;                            */
/*                                               */
/*             Y coordinate for the same;        */
/*                                               */
/*             Radius, in OS units.              */
/*************************************************/

_kernel_oserror * bbc_circle(int x, int y, int r)
{
   _kernel_oserror * e = bbc_move(x,y);

   if (!e) e = bbc_plot(BBC_Circle + BBC_DrawAbsFore, x + r, y);

   return e;
}

/*************************************************/
/* bbc_circlefill()                              */
/*                                               */
/* Plots a filled circle.                        */
/*                                               */
/* Parameters: As bbc_circle.                    */
/*************************************************/

_kernel_oserror * bbc_circlefill(int x, int y, int r)
{
   _kernel_oserror * e = bbc_move(x,y);

   if (!e) e = bbc_plot(BBC_CircleFill + BBC_DrawAbsFore, x + r, y);

   return e;
}

/*************************************************/
/* bbc_trianglefill()                            */
/*                                               */
/* Plots a filled triangle.                      */
/*                                               */
/* Parameters: X coordinate of one corner, in    */
/*             OS units;                         */
/*                                               */
/*             Y coordinate of one corner, in    */
/*             OS units;                         */
/*                                               */
/*             X coordinate of another corner,   */
/*             in OS units;                      */
/*                                               */
/*             Y coordinate of another corner,   */
/*             in OS units;                      */
/*                                               */
/*             X coordinate of the last corner,  */
/*             in OS units;                      */
/*                                               */
/*             Y coordinate of the last corner,  */
/*             in OS units.                      */
/*************************************************/

_kernel_oserror * bbc_trianglefill(int x1, int y1, int x2, int y2, int x3, int y3)
{
   _kernel_oserror * e = bbc_move(x1, y1);

   if (!e) e = bbc_move(x2, y2);
   if (!e) e = bbc_plot(BBC_TriangleFill + BBC_DrawAbsFore, x3, y3);

   return e;
}

/*************************************************/
/* bbc_fill()                                    */
/*                                               */
/* Flood-fill an area from absolute              */
/*                                               */
/* Parameters: X coordinate to start fill at, in */
/*             OS units;                         */
/*                                               */
/*             Y coordinate for the same.        */
/*************************************************/

_kernel_oserror * bbc_fill(int x, int y)
{
   return bbc_plot(BBC_FloodToBack + BBC_DrawAbsFore, x, y);
}

/*************************************************/
/* wimpt_read()                                  */
/*                                               */
/* Finds out the current X and Y eigen values    */
/* (desktop scaling). Screen resolution in dots  */
/* per inch is thus 180 / eigen value.           */
/*                                               */
/* This function is typically called on receipt  */
/* of a ModeChange message.                      */
/*************************************************/

void wimpt_read(void)
{
  wimpt_xeig = 1 << bbc_vduvar(BBC_XEigFactor);
  wimpt_yeig = 1 << bbc_vduvar(BBC_YEigFactor);
}

/*************************************************/
/* wimpt_dx()                                    */
/*                                               */
/* Returns the current X eigen value (Desktop    */
/* scaling). Screen X resolution in dots per     */
/* inch is thus 180/XEig.                        */
/*************************************************/

int wimpt_dx(void)
{
  return wimpt_xeig;
}

/*************************************************/
/* wimpt_dy()                                    */
/*                                               */
/* Returns the current Y eigen value (Desktop    */
/* scaling). Screen Y resolution in dots per     */
/* inch is thus 180/YEig.                        */
/*************************************************/

int wimpt_dy(void)
{
  return wimpt_yeig;
}

/*************************************************/
/* coords_x_toscreen()                           */
/*                                               */
/* Converts a work area X coordinate (0,0 is at  */
/* the top left of the window) to a screen       */
/* coordinate (0,0 is at the bottom left of the  */
/* screen).                                      */
/*                                               */
/* Parameters: The work area X coordinate;       */
/*                                               */
/*             Pointer to WimpRedrawWindowBlock  */
/*             holding details about the window  */
/*             that the X coordinate lies in.    */
/*                                               */
/* Returns:    The given value converted to a    */
/*             screen coordinate.                */
/*************************************************/

int coords_x_toscreen(int x, WimpRedrawWindowBlock * r)
{
  return (x - r->xscroll + r->visible_area.xmin);
}

/*************************************************/
/* coords_y_toscreen()                           */
/*                                               */
/* Converts a work area Y coordinate to a screen */
/* coordinate.                                   */
/*                                               */
/* Parameters: The work area Y coordinate;       */
/*                                               */
/*             Pointer to WimpRedrawWindowBlock  */
/*             holding details about the window  */
/*             that the Y coordinate lies in.    */
/*                                               */
/* Returns:    The given value converted to a    */
/*             screen coordinate.                */
/*************************************************/

int coords_y_toscreen(int y, WimpRedrawWindowBlock * r)
{
  return (y - r->yscroll + r->visible_area.ymax);
}

/*************************************************/
/* coords_box_toscreen()                         */
/*                                               */
/* Converts the contents of a BBox representing  */
/* a rectangle in the work area of a window to   */
/* screen coordinates.                           */
/*                                               */
/* Parameters: Pointer to the BBox;              */
/*                                               */
/*             Pointer to WimpRedrawWindowBlock  */
/*             holding details about the window  */
/*             that the BBox retangle lies in.   */
/*                                               */
/* Returns:    The contents of the BBox are      */
/*             updated to hold screen            */
/*             coordinates.                      */
/*************************************************/

void coords_box_toscreen(BBox * b, WimpRedrawWindowBlock * r)
{
  b->xmax = coords_x_toscreen(b->xmax, r);
  b->xmin = coords_x_toscreen(b->xmin, r);
  b->ymin = coords_y_toscreen(b->ymin, r);
  b->ymax = coords_y_toscreen(b->ymax, r);
}

/*************************************************/
/* coords_x_toworkarea()                         */
/*                                               */
/* Converts a screen X coordinate (0,0 is at the */
/* bottom left of the screen) to a work area     */
/* coordinate (0,0 is at the top left of the     */
/* window).                                      */
/*                                               */
/* Parameters: The screen X coordiante;          */
/*                                               */
/*             Pointer to WimpRedrawWindowBlock  */
/*             holding details about the window  */
/*             that the coordinate is to be      */
/*             transformed to lie in.            */
/*                                               */
/* Returns:    The given value converted to      */
/*             a work area coordinate.           */
/*************************************************/

int coords_x_toworkarea(int x, WimpRedrawWindowBlock * r)
{
  return (x + r->xscroll - r->visible_area.xmin);
}

/*************************************************/
/* coords_y_toworkarea()                         */
/*                                               */
/* Converts a screen Y coordinate to a work area */
/* coordinate.                                   */
/*                                               */
/* Parameters: The screen Y coordiante;          */
/*                                               */
/*             Pointer to WimpRedrawWindowBlock  */
/*             holding details about the window  */
/*             that the coordinate is to be      */
/*             transformed to lie in.            */
/*                                               */
/* Returns:    The given value converted to      */
/*             a work area coordinate.           */
/*************************************************/

int coords_y_toworkarea(int y, WimpRedrawWindowBlock * r)
{
  return (y + r->yscroll - r->visible_area.ymax);
}

/*************************************************/
/* coords_box_toworkarea()                       */
/*                                               */
/* Converts the contents of a BBox representing  */
/* a rectangle in screen coords to hold work     */
/* area coordinates.                             */
/*                                               */
/* Parameters: Pointer to the BBox;              */
/*                                               */
/*             Pointer to WimpRedrawWindowBlock  */
/*             holding details about the window  */
/*             that the BBox coordinates are to  */
/*             be transformed to lie in.         */
/*                                               */
/* Returns:    The contents of the BBox are      */
/*             updated to hold work area         */
/*             coordinates.                      */
/*************************************************/

void coords_box_toworkarea(BBox * b, WimpRedrawWindowBlock * r)
{
  b->xmax = coords_x_toworkarea(b->xmax, r);
  b->xmin = coords_x_toworkarea(b->xmin, r);
  b->ymin = coords_y_toworkarea(b->ymin, r);
  b->ymax = coords_y_toworkarea(b->ymax, r);
}