387 lines
8.9 KiB
C
387 lines
8.9 KiB
C
#ifndef lint
|
|
#ifdef sccs
|
|
static char sccsid[] = "@(#)cursor.c 1.1 94/10/31 Copyr 1983 Sun Micro";
|
|
#endif
|
|
#endif
|
|
|
|
/*
|
|
* Copyright (c) 1983 by Sun Microsystems, Inc.
|
|
*/
|
|
|
|
/*
|
|
* cursor.c: Routines for creating & modifying a cursor.
|
|
*
|
|
*/
|
|
|
|
#include <varargs.h>
|
|
#include <sys/types.h>
|
|
#include <pixrect/pixrect.h>
|
|
#include <pixrect/memvar.h>
|
|
#include <sunwindow/rect.h>
|
|
#include <sunwindow/win_cursor.h>
|
|
#include <sunwindow/cursor_impl.h>
|
|
|
|
static int cursor_set_attr();
|
|
|
|
/* VARARGS0 */
|
|
Cursor
|
|
cursor_create(va_alist)
|
|
va_dcl
|
|
{
|
|
caddr_t avlist[ATTR_STANDARD_SIZE];
|
|
struct cursor *cursor;
|
|
char *calloc();
|
|
va_list valist;
|
|
|
|
va_start(valist);
|
|
(void)attr_make(avlist, ATTR_STANDARD_SIZE, valist);
|
|
va_end(valist)
|
|
|
|
if (!(cursor = (struct cursor *) (LINT_CAST(calloc(1, sizeof(struct cursor))))))
|
|
return(0);
|
|
|
|
cursor->cur_function = PIX_SRC | PIX_DST;
|
|
cursor->cur_shape =
|
|
#ifdef ecd.cursor
|
|
mem_create(CURSOR_MIN_SIZE, CURSOR_MIN_SIZE, 1);
|
|
#else
|
|
mem_create(CURSOR_MAX_IMAGE_WORDS, CURSOR_MAX_IMAGE_WORDS, 1);
|
|
#endif ecd.cursor
|
|
cursor->flags = FREE_SHAPE;
|
|
|
|
cursor->horiz_hair_op = PIX_SRC;
|
|
cursor->horiz_hair_color = -1;
|
|
cursor->horiz_hair_thickness = 1;
|
|
cursor->horiz_hair_length = CURSOR_TO_EDGE;
|
|
cursor->horiz_hair_gap = 0;
|
|
|
|
cursor->vert_hair_op = PIX_SRC;
|
|
cursor->vert_hair_color = -1;
|
|
cursor->vert_hair_thickness = 1;
|
|
cursor->vert_hair_length = CURSOR_TO_EDGE;
|
|
cursor->vert_hair_gap = 0;
|
|
|
|
(void)cursor_set_attr(cursor, avlist);
|
|
|
|
return (Cursor) cursor;
|
|
}
|
|
|
|
|
|
void
|
|
cursor_destroy(cursor_client)
|
|
Cursor cursor_client;
|
|
{
|
|
struct cursor *cursor;
|
|
|
|
cursor = (struct cursor *)(LINT_CAST(cursor_client));
|
|
if (free_shape(cursor))
|
|
(void)pr_destroy(cursor->cur_shape);
|
|
|
|
free((caddr_t)cursor);
|
|
}
|
|
|
|
|
|
/* cursor_get returns the current value of which_attr. */
|
|
caddr_t
|
|
cursor_get(cursor_client, which_attr)
|
|
register Cursor cursor_client;
|
|
Cursor_attribute which_attr;
|
|
{
|
|
struct cursor *cursor;
|
|
|
|
cursor = (struct cursor *)(LINT_CAST(cursor_client));
|
|
switch (which_attr) {
|
|
case CURSOR_SHOW_CURSOR:
|
|
return (caddr_t) show_cursor(cursor);
|
|
|
|
case CURSOR_SHOW_CROSSHAIRS:
|
|
return (caddr_t) show_crosshairs(cursor);
|
|
|
|
case CURSOR_SHOW_HORIZ_HAIR:
|
|
return (caddr_t) show_horiz_hair(cursor);
|
|
|
|
case CURSOR_SHOW_VERT_HAIR:
|
|
return (caddr_t) show_vert_hair(cursor);
|
|
|
|
case CURSOR_CROSSHAIR_BORDER_GRAVITY:
|
|
case CURSOR_HORIZ_HAIR_BORDER_GRAVITY:
|
|
return (caddr_t) horiz_border_gravity(cursor);
|
|
|
|
case CURSOR_VERT_HAIR_BORDER_GRAVITY:
|
|
return (caddr_t) vert_border_gravity(cursor);
|
|
|
|
case CURSOR_FULLSCREEN:
|
|
return (caddr_t) fullscreen(cursor);
|
|
|
|
case CURSOR_XHOT:
|
|
return (caddr_t) cursor->cur_xhot;
|
|
|
|
case CURSOR_YHOT:
|
|
return (caddr_t) cursor->cur_yhot;
|
|
|
|
case CURSOR_OP:
|
|
return (caddr_t) cursor->cur_function;
|
|
|
|
case CURSOR_IMAGE:
|
|
return (caddr_t) cursor->cur_shape;
|
|
|
|
case CURSOR_CROSSHAIR_OP:
|
|
case CURSOR_HORIZ_HAIR_OP:
|
|
return (caddr_t) cursor->horiz_hair_op;
|
|
|
|
case CURSOR_VERT_HAIR_OP:
|
|
return (caddr_t) cursor->vert_hair_op;
|
|
|
|
case CURSOR_CROSSHAIR_COLOR:
|
|
case CURSOR_HORIZ_HAIR_COLOR:
|
|
return (caddr_t) cursor->horiz_hair_color;
|
|
|
|
case CURSOR_CROSSHAIR_THICKNESS:
|
|
case CURSOR_HORIZ_HAIR_THICKNESS:
|
|
return (caddr_t) cursor->horiz_hair_thickness;
|
|
|
|
case CURSOR_VERT_HAIR_COLOR:
|
|
return (caddr_t) cursor->vert_hair_color;
|
|
|
|
case CURSOR_VERT_HAIR_THICKNESS:
|
|
return (caddr_t) cursor->vert_hair_thickness;
|
|
|
|
case CURSOR_CROSSHAIR_GAP:
|
|
case CURSOR_HORIZ_HAIR_GAP:
|
|
return (caddr_t) cursor->horiz_hair_gap;
|
|
|
|
case CURSOR_VERT_HAIR_GAP:
|
|
return (caddr_t) cursor->vert_hair_gap;
|
|
|
|
case CURSOR_CROSSHAIR_LENGTH:
|
|
case CURSOR_HORIZ_HAIR_LENGTH:
|
|
return (caddr_t) cursor->horiz_hair_length;
|
|
|
|
case CURSOR_VERT_HAIR_LENGTH:
|
|
return (caddr_t) cursor->vert_hair_length;
|
|
|
|
default:
|
|
return (caddr_t) 0;
|
|
}
|
|
|
|
} /* cursor_get */
|
|
|
|
|
|
/* VARARGS1 */
|
|
int
|
|
cursor_set(cursor_client, va_alist)
|
|
Cursor cursor_client;
|
|
va_dcl
|
|
{
|
|
caddr_t avlist[ATTR_STANDARD_SIZE];
|
|
va_list valist;
|
|
struct cursor *cursor;
|
|
|
|
va_start(valist);
|
|
(void)attr_make(avlist, ATTR_STANDARD_SIZE, valist);
|
|
va_end(valist);
|
|
|
|
cursor = (struct cursor *)(LINT_CAST(cursor_client));
|
|
return cursor_set_attr(cursor, avlist);
|
|
}
|
|
|
|
|
|
/* cursor_set_attr sets the attributes mentioned in avlist. */
|
|
static int
|
|
cursor_set_attr(cursor, avlist)
|
|
register struct cursor *cursor;
|
|
register Attr_avlist avlist;
|
|
{
|
|
register Cursor_attribute which_attr;
|
|
|
|
while (which_attr = (Cursor_attribute) *avlist++) {
|
|
switch (which_attr) {
|
|
case CURSOR_SHOW_CURSOR:
|
|
if (*avlist++)
|
|
cursor->flags &= ~DONT_SHOW_CURSOR;
|
|
else
|
|
cursor->flags |= DONT_SHOW_CURSOR;
|
|
break;
|
|
|
|
case CURSOR_SHOW_CROSSHAIRS:
|
|
if (*avlist++)
|
|
cursor->flags |= SHOW_HORIZ_HAIR | SHOW_VERT_HAIR;
|
|
else
|
|
cursor->flags &= ~(SHOW_HORIZ_HAIR | SHOW_VERT_HAIR);
|
|
break;
|
|
|
|
case CURSOR_SHOW_HORIZ_HAIR:
|
|
if (*avlist++)
|
|
cursor->flags |= SHOW_HORIZ_HAIR;
|
|
else
|
|
cursor->flags &= ~SHOW_HORIZ_HAIR;
|
|
break;
|
|
|
|
case CURSOR_SHOW_VERT_HAIR:
|
|
if (*avlist++)
|
|
cursor->flags |= SHOW_VERT_HAIR;
|
|
else
|
|
cursor->flags &= ~SHOW_VERT_HAIR;
|
|
break;
|
|
|
|
case CURSOR_CROSSHAIR_BORDER_GRAVITY:
|
|
if (*avlist++)
|
|
cursor->flags |=
|
|
HORIZ_BORDER_GRAVITY | VERT_BORDER_GRAVITY;
|
|
else
|
|
cursor->flags &=
|
|
~(HORIZ_BORDER_GRAVITY | VERT_BORDER_GRAVITY);
|
|
break;
|
|
|
|
case CURSOR_HORIZ_HAIR_BORDER_GRAVITY:
|
|
if (*avlist++)
|
|
cursor->flags |= HORIZ_BORDER_GRAVITY;
|
|
else
|
|
cursor->flags &= ~HORIZ_BORDER_GRAVITY;
|
|
break;
|
|
|
|
case CURSOR_VERT_HAIR_BORDER_GRAVITY:
|
|
if (*avlist++)
|
|
cursor->flags |= VERT_BORDER_GRAVITY;
|
|
else
|
|
cursor->flags &= ~VERT_BORDER_GRAVITY;
|
|
break;
|
|
|
|
case CURSOR_FULLSCREEN:
|
|
if (*avlist++)
|
|
cursor->flags |= FULLSCREEN;
|
|
else
|
|
cursor->flags &= ~FULLSCREEN;
|
|
break;
|
|
|
|
case CURSOR_XHOT:
|
|
cursor->cur_xhot = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_YHOT:
|
|
cursor->cur_yhot = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_OP:
|
|
cursor->cur_function = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_IMAGE:
|
|
/* free the storage for the image if mem_create() was used */
|
|
if (free_shape(cursor)) {
|
|
(void)pr_destroy(cursor->cur_shape);
|
|
cursor->flags &= ~FREE_SHAPE;
|
|
}
|
|
|
|
cursor->cur_shape = (struct pixrect *) (LINT_CAST(*avlist++));
|
|
break;
|
|
|
|
case CURSOR_CROSSHAIR_COLOR:
|
|
cursor->horiz_hair_color =
|
|
cursor->vert_hair_color = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_CROSSHAIR_OP:
|
|
cursor->horiz_hair_op =
|
|
cursor->vert_hair_op = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_HORIZ_HAIR_OP:
|
|
cursor->horiz_hair_op = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_VERT_HAIR_OP:
|
|
cursor->vert_hair_op = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_HORIZ_HAIR_COLOR:
|
|
cursor->horiz_hair_color = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_CROSSHAIR_THICKNESS:
|
|
if ((int) *avlist > CURSOR_MAX_HAIR_THICKNESS)
|
|
return 1;
|
|
cursor->horiz_hair_thickness =
|
|
cursor->vert_hair_thickness = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_HORIZ_HAIR_THICKNESS:
|
|
if ((int) *avlist > CURSOR_MAX_HAIR_THICKNESS)
|
|
return 1;
|
|
cursor->horiz_hair_thickness = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_VERT_HAIR_COLOR:
|
|
cursor->vert_hair_color = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_VERT_HAIR_THICKNESS:
|
|
if ((int) *avlist > CURSOR_MAX_HAIR_THICKNESS)
|
|
return 1;
|
|
cursor->vert_hair_thickness = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_CROSSHAIR_LENGTH:
|
|
cursor->horiz_hair_length =
|
|
cursor->vert_hair_length = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_HORIZ_HAIR_LENGTH:
|
|
cursor->horiz_hair_length = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_VERT_HAIR_LENGTH:
|
|
cursor->vert_hair_length = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_CROSSHAIR_GAP:
|
|
cursor->horiz_hair_gap =
|
|
cursor->vert_hair_gap = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_HORIZ_HAIR_GAP:
|
|
cursor->horiz_hair_gap = (int) *avlist++;
|
|
break;
|
|
|
|
case CURSOR_VERT_HAIR_GAP:
|
|
cursor->vert_hair_gap = (int) *avlist++;
|
|
break;
|
|
|
|
default:
|
|
/* Here we should complain about something */
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
} /* cursor_set */
|
|
|
|
|
|
Cursor
|
|
cursor_copy(cursor_client)
|
|
register Cursor cursor_client;
|
|
{
|
|
register struct cursor *new_cursor;
|
|
struct cursor *cursor;
|
|
|
|
cursor = (struct cursor *)(LINT_CAST(cursor_client));
|
|
if (!(new_cursor = (struct cursor *)
|
|
(LINT_CAST(calloc(1, sizeof(struct cursor))))))
|
|
return 0;
|
|
|
|
*new_cursor = *cursor;
|
|
new_cursor->cur_shape =
|
|
mem_create(cursor->cur_shape->pr_width, cursor->cur_shape->pr_height,
|
|
cursor->cur_shape->pr_depth);
|
|
if (!new_cursor->cur_shape)
|
|
return 0;
|
|
|
|
/* we created this, so we free it later */
|
|
new_cursor->flags |= FREE_SHAPE;
|
|
|
|
/* copy the old image to the new image */
|
|
(void)pr_rop(new_cursor->cur_shape, 0, 0, cursor->cur_shape->pr_width,
|
|
cursor->cur_shape->pr_height, PIX_SRC, cursor->cur_shape, 0, 0);
|
|
|
|
return (Cursor) new_cursor;
|
|
}
|