canvas.c

操作系统SunOS 4.1.3版本的源码

#ifndef lint
#ifdef sccs
static  char sccsid[] = "@(#)canvas.c 1.1 92/07/30 Copyr 1985 Sun Micro";
#endif
#endif

/*
 * Copyright (c) 1985 by Sun Microsystems, Inc.
 */

#include <suntool/canvas_impl.h>
#include <sunwindow/win_keymap.h>

static int		canvas_set();
static caddr_t		canvas_get();

static Notify_value	canvas_handle_event();
static Notify_value	canvas_destroy();

static void		canvas_layout();

static void		compute_damage();
static void		clear_rectlist();

/* ARGSUSED */
caddr_t
canvas_window_object(win, avlist)
register Window		win;
Attr_avlist		avlist;
{
    register Pixwin	*pw = (Pixwin *) (LINT_CAST(window_get(win, WIN_PIXWIN)));
    register Canvas_info	*canvas;
    struct colormapseg cms;
    char *calloc();
    struct inputmask  mask;
    int  		fd;

    canvas = (Canvas_info *) (LINT_CAST(calloc(1, sizeof(Canvas_info))));
    if (!canvas)
	return NULL;

    status_set(canvas, retained);
    status_set(canvas, fixed_image);
    status_set(canvas, auto_clear);
    status_set(canvas, auto_expand);
    status_set(canvas, auto_shrink);

    /* Conserve memory on depth > 1 plane pixrects if only need bit map. */
    (void)pw_getcmsdata(pw, &cms, (int *)0);
    canvas->depth = (cms.cms_size==2 && pw->pw_pixrect->pr_depth<32)
	? 1 : pw->pw_pixrect->pr_depth;

    canvas->win_rect    = *(Rect *)(LINT_CAST(window_get(win, WIN_RECT)));
    fd = (int)window_get(win, WIN_FD);

    canvas_set_left(canvas, 0);
    canvas_set_top(canvas, 0);
    canvas_set_width(canvas, win_width(canvas));
    canvas_set_height(canvas, win_height(canvas));

    canvas->help_data = "sunview:canvas";

    canvas->pw = 
	pw_region(pw, 0, 0, canvas_width(canvas), canvas_height(canvas));
    if (!canvas->pw)
	return NULL;

    canvas->pw->pw_prretained = 
	mem_create(canvas_width(canvas), canvas_height(canvas), canvas->depth);
    if (!canvas->pw->pw_prretained)
	return NULL;

    (void)window_set(win,
	    WIN_NOTIFY_INFO,		PW_INPUT_DEFAULT,
	    WIN_OBJECT,			canvas, 
	    WIN_SET_PROC,		canvas_set,
	    WIN_GET_PROC,		canvas_get,
	    WIN_LAYOUT_PROC,		canvas_layout,
	    WIN_NOTIFY_EVENT_PROC,	canvas_handle_event,
	    WIN_NOTIFY_DESTROY_PROC,	canvas_destroy,
	    WIN_TYPE,			CANVAS_TYPE,
	    WIN_CONSUME_KBD_EVENTS, 	KBD_USE, KBD_DONE, 0,
    /* 
     * BUG: This is a workaround.  Canvas shouldn't event have to set the
     * 	    pick mask for the following three buttons.  In the case of
     *	    click-to-type, and when canvas has the cursor, but not the
     *	    input focus, events generated from these three buttons 
     *	    should simply drop through to the frame of the canvas.
     *	    There appears to be a bug in the event delivery algorithm
     *	    that is not consistent w/ the documentation.
     */
           WIN_CONSUME_PICK_EVENTS,     
		ACTION_PROPS, ACTION_OPEN, ACTION_FRONT,
                ACTION_BACK, ACTION_CLOSE,
		ACTION_HELP,
	        WIN_MOUSE_BUTTONS, LOC_WINENTER, LOC_WINEXIT, 
	        LOC_MOVE, KBD_REQUEST, 0,
	    0);
    return (caddr_t)canvas;
}


/* update the canvas when the window is
 * resized from window_set().
 */
/* ARGSUSED */
static void
canvas_layout(owner, canvas, op)
Window			owner;
register Canvas_info	*canvas;
Window_layout_op	op;
{

    switch (op) {
	case WIN_ADJUSTED: {
	    register Rect *new_win_rect = (Rect *) (LINT_CAST(
	    	window_get((Window)(LINT_CAST(canvas)), WIN_RECT)));

	    if (new_win_rect->r_width != win_width(canvas) ||
		new_win_rect->r_height != win_height(canvas)) {

		canvas->win_rect = *new_win_rect;
		(void)canvas_resize_pixwin(canvas, TRUE);
		canvas_update_scrollbars(canvas, TRUE);
	    }
	    break;
	}

	default:
	    break;
    }
}


static int
canvas_set(canvas, avlist)
register Canvas_info	*canvas;
Attr_avlist		avlist;
{
    register Canvas_attribute	attr;
    register int		width = 0, height = 0;
    int				margin;
    short			new_pw_size = FALSE, new_canvas_size = FALSE;
    short			new_v_sb = FALSE, new_h_sb = FALSE;
    int				repaint=FALSE, show_updates;
    Scrollbar			v_sb, h_sb;
    int				ok = TRUE;
    void			pw_batch();

    for (attr = (Canvas_attribute) avlist[0]; attr;
	 avlist = attr_next(avlist), attr = (Canvas_attribute) avlist[0]) {
	switch (attr) {
	    case CANVAS_LEFT:
		break;

	    case CANVAS_TOP:
		break;

	    case CANVAS_WIDTH:
		width = (int) avlist[1];
		if (width == canvas_width(canvas))
		    width = 0;
		else
		    new_canvas_size = TRUE;
		break;

	    case CANVAS_HEIGHT:
		height = (int) avlist[1];
		if (height == canvas_height(canvas))
		    height = 0;
		else
		    new_canvas_size = TRUE;
		break;

	    case CANVAS_DEPTH:
		/*
		depth = (int) avlist[1];
		if (depth <= 0)
		    return FALSE;
		*/
		break;

	    case CANVAS_MARGIN:
		margin = (int) avlist[1];
		if (margin < 0)
		   ok = FALSE;
		else if (margin != canvas->margin) {
		    /* resize the view pixwin for the new margin */
		    canvas->margin = margin;
		    new_pw_size = TRUE;
		}
		break;

	    case CANVAS_REPAINT_PROC:
		canvas->repaint_proc = (Function)(LINT_CAST(avlist[1]));
		break;

	    case CANVAS_RESIZE_PROC:
		canvas->resize_proc = (Function)(LINT_CAST(avlist[1]));
		break;

	    case CANVAS_AUTO_CLEAR:
		if ((int) avlist[1])
		    status_set(canvas, auto_clear);
		else
		    status_reset(canvas, auto_clear);
		break;

	    case CANVAS_AUTO_EXPAND:
		if ((int) avlist[1] == status(canvas, auto_expand)) 
		    break;
		if (avlist[1])
		    status_set(canvas, auto_expand);
		else
		    status_reset(canvas, auto_expand);
		new_pw_size = TRUE;
		break;

	    case CANVAS_AUTO_SHRINK:
		if ((int) avlist[1] == status(canvas, auto_shrink)) 
		    break;
		if (avlist[1])
		    status_set(canvas, auto_shrink);
		else
		    status_reset(canvas, auto_shrink);
		new_pw_size = TRUE;
		break;

	    case CANVAS_FAST_MONO:
		if (avlist[1]) {
		    Pixwin	*pw = (Pixwin *) (LINT_CAST(window_get(
		    	(Window)(LINT_CAST(canvas)), WIN_PIXWIN)));

		    if (pw) {
			struct colormapseg cms;
			int original_pr_depth = pw->pw_pixrect->pr_depth;
			void pw_use_fast_monochrome();

			pw_use_fast_monochrome(pw);
			if (original_pr_depth != pw->pw_pixrect->pr_depth) {
				pw_use_fast_monochrome(canvas->pw);
				new_v_sb = (short)(canvas_sb(canvas,
				    SCROLL_VERTICAL));
				new_h_sb = (short)(canvas_sb(canvas,
				    SCROLL_HORIZONTAL));
				(void)pw_getcmsdata(pw, &cms, (int *)0);
				canvas->depth = ((cms.cms_size == 2 &&
				    pw->pw_pixrect->pr_depth<32)
				    ? 1 : pw->pw_pixrect->pr_depth);
			}
		    }
		}
		break;

#ifndef PRE_IBIS
	    case CANVAS_COLOR24:
		if (avlist[1]) {
		    Pixwin	*pw = (Pixwin *) (LINT_CAST(window_get(
		    	(Window)(LINT_CAST(canvas)), WIN_PIXWIN)));

		    if (pw) {
			struct colormapseg cms;
			int original_pr_depth = pw->pw_pixrect->pr_depth;
			void pw_use_color24();

			pw_use_color24(pw);
			/*if (original_pr_depth != pw->pw_pixrect->pr_depth) {*/
				pw_use_color24(canvas->pw);
				new_v_sb = (short)(canvas_sb(canvas,
				    SCROLL_VERTICAL));
				new_h_sb = (short)(canvas_sb(canvas,
				    SCROLL_HORIZONTAL));
				(void)pw_getcmsdata(pw, &cms, (int *)0);
				canvas->depth = ((cms.cms_size == 2 &&
				    pw->pw_pixrect->pr_depth<32)
				    ? 1 : pw->pw_pixrect->pr_depth);
			/*}*/
		    }
		}
		break;
#endif ndef PRE_IBIS

	    case CANVAS_RETAINED:
		if ((int) avlist[1] == status(canvas, retained))
		    break;
		if (avlist[1]) {
		    Pixwin	*pw = (Pixwin *) (LINT_CAST(window_get(
		    	(Window)(LINT_CAST(canvas)), WIN_PIXWIN)));
		    struct colormapseg cms;

		    /* Conserve memory on depth > 1 plane pixrects 
		     * if only need bit map.
		     */
		    (void)pw_getcmsdata(pw, &cms, (int *)0);
		    canvas->depth = (cms.cms_size == 2 &&
			pw->pw_pixrect->pr_depth<32)
			? 1 : pw->pw_pixrect->pr_depth;

		    status_set(canvas, retained);
		    canvas_set_pr(canvas, mem_create(canvas_width(canvas),
			canvas_height(canvas), canvas->depth));
		    if (!canvas_pr(canvas))
		       ok = FALSE;
		} 
		else {
		    status_reset(canvas, retained);
		    pw_batch(canvas->pw, PW_NONE);
		    if (canvas_pr(canvas)) {
			(void)pr_destroy(canvas_pr(canvas));
			canvas_set_pr(canvas, 0);
		    }
		}
		break;

	    case CANVAS_FIXED_IMAGE:
		if (avlist[1])
		    status_set(canvas, fixed_image);
		else
		    status_reset(canvas, fixed_image);
		break;

	    case WIN_VERTICAL_SCROLLBAR:
		v_sb = (Scrollbar) avlist[1];
		/* ignore zero scrollbar if already zero */
		new_v_sb = (v_sb || canvas_sb(canvas, SCROLL_VERTICAL));
		break;

	    case WIN_HORIZONTAL_SCROLLBAR:
		h_sb = (Scrollbar) avlist[1];
		/* ignore zero scrollbar if already zero */
		new_h_sb = (h_sb || canvas_sb(canvas, SCROLL_HORIZONTAL));
		break;

  	    case HELP_DATA:
  		canvas->help_data = (caddr_t) avlist[1];
		break;

	    default:
		/*
		return attr_check(attr, ATTR_PKG_CANVAS, "window_set()");
		*/
		break;
	}
    }
    if (new_pw_size)
	ok |= canvas_resize_pixwin(canvas, FALSE);

    if (new_canvas_size) {
	/* if auto expand is on, always expand
	 * the canvas to at least the edges of
	 * the viewing pixwin.
	 */
	if (status(canvas, auto_expand)) {
	    if (width)
		width = max(width, view_width(canvas));
	    if (height)
		height = max(height, view_height(canvas));
	}
	/* if auto shrink is on, always shrink
	 * the canvas to the edges of the viewing pixwin.
	 */
	if (status(canvas, auto_shrink)) {
	    width = min(width, view_width(canvas));
	    height = min(height, view_height(canvas));
	}
	ok |= canvas_resize_canvas(canvas, width, height, FALSE);