textsw_input.c

操作系统SunOS 4.1.3版本的源码

	/*
	 * Cleanup
	 */
	if ((textsw->state & TXTSW_EDITED) == 0)
	    textsw_possibly_edited_now_notify(textsw);
Done:
	if (TXTSW_IS_BUSY(textsw))
	    result |= TEXTSW_PE_BUSY;
	return(result);
Read_Only:
	result |= TEXTSW_PE_READ_ONLY;
	goto Done;
}

static Key_map_handle
find_key_map(textsw, ie)
	register Textsw_folio	 textsw;
	register Event		*ie;
{
	register Key_map_handle	 current_key = textsw->key_maps;

	while (current_key) {
	    if (current_key->event_code == event_action(ie)) {
		break;
	    }
	    current_key = current_key->next;
	}
	return(current_key);
}

pkg_private Key_map_handle
textsw_do_filter(view, ie)
	register Textsw_view	 view;
	register Event		*ie;
{
	register Textsw_folio	 textsw = FOLIO_FOR_VIEW(view);
	register Key_map_handle	 result = find_key_map(textsw, ie);

	if (result == 0)
	    goto Return;
	if (win_inputposevent(ie)) {
	    switch (result->type) {
	      case TXTSW_KEY_SMART_FILTER:
	      case TXTSW_KEY_FILTER:
		textsw_flush_caches(view, TFC_STD);
		textsw->func_state |= TXTSW_FUNC_FILTER;
		result = 0;
		break;
	    }
	    goto Return;
	}
	switch (result->type) {
	  case TXTSW_KEY_SMART_FILTER:
	  case  TXTSW_KEY_FILTER: {
	    extern int	textsw_call_smart_filter();
	    extern int	textsw_call_filter();
	    int		again_state, filter_result;

	    again_state = textsw->func_state & TXTSW_FUNC_AGAIN;
	    (void) textsw_record_filter(textsw, ie);
	    textsw->func_state |= TXTSW_FUNC_AGAIN;
	    textsw_checkpoint_undo(VIEW_REP_TO_ABS(view),
			           (caddr_t)TEXTSW_INFINITY-1);
	    if (result->type == TXTSW_KEY_SMART_FILTER) {
		filter_result = textsw_call_smart_filter(view, ie,
		    (char **)LINT_CAST(result->maps_to));
	    } else {
		filter_result = textsw_call_filter(view,
		    (char **)LINT_CAST(result->maps_to));
	    }
	    textsw_checkpoint_undo(VIEW_REP_TO_ABS(view),
			           (caddr_t)TEXTSW_INFINITY-1);
	    switch (filter_result) {
	      case 0:
	      default:
		break;
	      case 1: {
		char	msg[300];
		if (errno == ENOENT) {
		    (void) sprintf(msg, "Cannot locate filter '%s'.",
			    ((char **)LINT_CAST(result->maps_to))[0]);
		} else {
		    (void) sprintf(msg, "Unexpected problem with filter '%s'.",
			    ((char **)LINT_CAST(result->maps_to))[0]);
		}
		(void) alert_prompt(
			(Frame)window_get(WINDOW_FROM_VIEW(view), WIN_OWNER),
			(Event *) 0,
			ALERT_BUTTON_YES,		"Continue",
			ALERT_TRIGGER,		ACTION_STOP,
			ALERT_MESSAGE_STRINGS,	msg, 0,
	        	0);
		break;
	      }
	    }
	    textsw->func_state &= ~TXTSW_FUNC_FILTER;
	    textsw->to_insert_next_free = textsw->to_insert;
	    if (again_state == 0)
		textsw->func_state &= ~TXTSW_FUNC_AGAIN;
	    result = 0;
	  }
	}
Return:
	return(result);
}


static int
textsw_do_newline(view)
	register Textsw_view	view;
{
	Es_index		ev_get_insert();
	register Textsw_folio	folio = FOLIO_FOR_VIEW(view);
	int			delta;
	Es_index		first = ev_get_insert(folio->views),
				last_plus_one,
				previous;

	textsw_flush_caches(view, TFC_INSERT|TFC_PD_SEL);
	if (folio->state & TXTSW_AUTO_INDENT)
	    first = ev_get_insert(folio->views);
	delta = textsw_do_input(view, "\n", 1, TXTSW_UPDATE_SCROLLBAR);
	if (folio->state & TXTSW_AUTO_INDENT) {
	    previous = first;
	    textsw_find_pattern(folio, &previous, &last_plus_one,
				"\n", 1, EV_FIND_BACKWARD);
	    if (previous != ES_CANNOT_SET) {
		char			 buf[100];
		struct es_buf_object	 esbuf;
		register char		*c;

		esbuf.esh = folio->views->esh;
		esbuf.buf = buf;
		esbuf.sizeof_buf = sizeof(buf);
		if (es_make_buf_include_index(&esbuf, previous, 0) == 0) {
		    if (AN_ERROR(buf[0] != '\n')) {
		    } else {
			for (c = buf+1; c < buf+sizeof(buf); c++) {
			   switch (*c) {
			      case '\t':
			      case ' ':
				break;
			      default:
				goto Did_Scan;
			   }
			}
Did_Scan:
			if (c != buf+1) {
			    delta += textsw_do_input(view, buf+1,
						     (int) (c-buf-1),
						     TXTSW_UPDATE_SCROLLBAR_IF_NEEDED);
			}
		    }
		}
	    }
	}
	return(delta);
}

pkg_private Es_index
textsw_get_saved_insert(textsw)
	register Textsw_folio	textsw;
{
	Ev_finger_handle	saved_insert_finger;

	saved_insert_finger = ev_find_finger(
			&textsw->views->fingers, textsw->save_insert);
	return(saved_insert_finger ? saved_insert_finger->pos : ES_INFINITY);
}

pkg_private int
textsw_clear_pending_func_state(textsw)
	register Textsw_folio	textsw;
{
	if (!EV_MARK_IS_NULL(&textsw->save_insert)) {
	    if (textsw->func_state & TXTSW_FUNC_PUT) {
		Es_index	old_insert = textsw_get_saved_insert(textsw);
		if AN_ERROR(old_insert == ES_INFINITY) {
		} else {
		    textsw_set_insert(textsw, old_insert);
		}
	    } else
		ASSUME(textsw->func_state & TXTSW_FUNC_GET);
	    ev_remove_finger(&textsw->views->fingers, textsw->save_insert);
	    (void) ev_init_mark(&textsw->save_insert);
	}
	if (textsw->func_state & TXTSW_FUNC_FILTER) {
	    textsw->to_insert_next_free = textsw->to_insert;
	}
	textsw->func_state &= ~(TXTSW_FUNC_ALL | TXTSW_FUNC_EXECUTE);
}

/*	==========================================================
 *
 *		Input mask initialization and setting.
 *
 *	==========================================================
 */

static struct inputmask	basemask_kbd, mousebuttonmask_kbd;
static struct inputmask	basemask_pick, mousebuttonmask_pick;
static int		masks_have_been_initialized;	/* Defaults to FALSE */

static setupmasks()
{
	register struct inputmask	*mask;
	register int			i;

	/*
	 * Set up the standard kbd mask.
	 */
	mask = &basemask_kbd;
	input_imnull(mask);
        mask->im_flags |= IM_EUC | IM_NEGEVENT | IM_META | IM_NEGMETA | IM_ISO;
	for (i=1; i<17; i++) {
	    win_setinputcodebit(mask, KEY_LEFT(i));
	    win_setinputcodebit(mask, KEY_TOP(i));
	    win_setinputcodebit(mask, KEY_RIGHT(i));
	}
	/* Unset TOP and OPEN because will look for them in pick mask */
	/*
	 * Use win_keymap_*inputcodebig() for events that are semantic,
	 * i.e., have no actual inputmask bit assignment.  This is done
	 * in textsw_set_base_mask() below since we need the fd to know
	 * what keymap to look in.
	 */
	win_setinputcodebit(mask, KBD_USE);
	win_setinputcodebit(mask, KBD_DONE);
#ifdef VT_100_HACK
	win_setinputcodebit(mask, SHIFT_LEFT);		/* Pick up the shift */
	win_setinputcodebit(mask, SHIFT_RIGHT);		/*   keys for VT-100 */
	win_setinputcodebit(mask, SHIFT_LOCK);		/*   compatibility */
#endif
	/*
	 * Set up the standard pick mask.
	 */
	mask = &basemask_pick;
	input_imnull(mask);
	win_setinputcodebit(mask, WIN_STOP);
	win_setinputcodebit(mask, LOC_WINENTER);
	win_setinputcodebit(mask, LOC_WINEXIT);
	win_setinputcodebit(mask, TXTSW_POINT);
	win_setinputcodebit(mask, TXTSW_ADJUST);
	win_setinputcodebit(mask, TXTSW_MENU);
	win_setinputcodebit(mask, KBD_REQUEST);
	win_setinputcodebit(mask, LOC_MOVE);	/* NOTE: New */
	win_setinputcodebit(mask, LOC_STILL);	/* NOTE: Detect shift up??? */
	mask->im_flags |= IM_NEGEVENT;
	/* Make "mouse" mask use base mask */
	mousebuttonmask_kbd = basemask_kbd;
	mousebuttonmask_pick = basemask_pick;
	masks_have_been_initialized = TRUE;
}

pkg_private int
textsw_set_base_mask(fd)
	int	fd;
{
	if (masks_have_been_initialized == FALSE) {
	    setupmasks();
	}

	win_keymap_set_smask_class(fd, KEYMAP_FUNCT_KEYS);
	win_keymap_set_smask_class(fd, KEYMAP_EDIT_KEYS);
	win_keymap_set_smask_class(fd, KEYMAP_MOTION_KEYS);
	win_keymap_set_smask_class(fd, KEYMAP_TEXT_KEYS);
        win_keymap_set_smask(fd, TXTSW_HELP);

	win_keymap_unset_imask_from_std_bind(&basemask_kbd, TXTSW_TOP);
	win_keymap_unset_imask_from_std_bind(&basemask_kbd, TXTSW_OPEN);
	win_keymap_unset_imask_from_std_bind(&basemask_kbd, TXTSW_PROPS);
	win_keymap_unset_imask_from_std_bind(&basemask_kbd, TXTSW_HELP);
	win_set_kbd_mask(fd, &basemask_kbd);

	win_keymap_set_imask_from_std_bind(&basemask_pick, TXTSW_TOP);
	win_keymap_set_imask_from_std_bind(&basemask_pick, TXTSW_OPEN);
	win_keymap_set_imask_from_std_bind(&basemask_pick, TXTSW_PROPS);
	win_keymap_set_imask_from_std_bind(&basemask_pick, TXTSW_HELP);
	win_set_pick_mask(fd, &basemask_pick);
}

pkg_private int
textsw_set_mouse_button_mask(fd)
	int	fd;
{
	if (masks_have_been_initialized == FALSE) {
	    setupmasks();
	}
	win_set_kbd_mask(fd, &mousebuttonmask_kbd);

	win_set_pick_mask(fd, &mousebuttonmask_pick);
}

/*	==========================================================
 *
 *		Functions invoked by function keys.
 *
 *	==========================================================
 */

pkg_private void
textsw_begin_function(view, function)
	Textsw_view		view;
	unsigned		function;
{
	register Textsw_folio	folio = FOLIO_FOR_VIEW(view);

	textsw_flush_caches(view, TFC_STD);
	if ((folio->state & TXTSW_CONTROL_DOWN) &&
	    !TXTSW_IS_READ_ONLY(folio))
	    folio->state |= TXTSW_PENDING_DELETE;
	folio->track_state |= TXTSW_TRACK_SECONDARY;
	folio->func_state |= function|TXTSW_FUNC_EXECUTE;
	textsw_init_timer(folio);
	if AN_ERROR(folio->func_state & TXTSW_FUNC_SVC_SAW(function))
	    /* Following covers up inconsistent state with Seln. Svc. */
	    folio->func_state &= ~TXTSW_FUNC_SVC_SAW(function);
}

pkg_private void
textsw_init_timer(folio)
	Textsw_folio	folio;
{
	/*
	 * Make last_point/_adjust/_ie_time close (but not too close) to
	 *   current time to avoid overflow in tests for multi-click.
	 */
	folio->last_point.tv_sec -= 1000;
	folio->last_adjust = folio->last_point;
	folio->last_ie_time = folio->last_point;
};


pkg_private void
textsw_end_function(view, function)
	Textsw_view		view;
	unsigned		function;
{
	pkg_private void	textsw_end_selection_function();
	register Textsw_folio	folio = FOLIO_FOR_VIEW(view);

	folio->state &= ~TXTSW_PENDING_DELETE;
	folio->track_state &= ~TXTSW_TRACK_SECONDARY;
	folio->func_state &=
	    ~(function | TXTSW_FUNC_SVC_SAW(function) | TXTSW_FUNC_EXECUTE);
	textsw_end_selection_function(folio);
}

static
textsw_begin_again(view)
	Textsw_view	 view;
{
	textsw_begin_function(view, TXTSW_FUNC_AGAIN);
}

static
textsw_end_again(view, x, y)
	Textsw_view	 view;
	int			 x, y;
{
	textsw_do_again(view, x, y);
	textsw_end_function(view, TXTSW_FUNC_AGAIN);
	/* 
	 * Make sure each sequence of again will not accumulate.
	 * Like find, delete and insert.
	 */
	textsw_checkpoint_again(VIEW_REP_TO_ABS(view));
}

pkg_private int
textsw_again(view, x, y)
	Textsw_view	 view;
	int		 x, y;
{
	textsw_begin_again(view);
	textsw_end_again(view, x, y);
}

static
textsw_begin_delete(view)
	Textsw_view	view;
{
	register Textsw_folio	textsw = FOLIO_FOR_VIEW(view);

	textsw_begin_function(view, TXTSW_FUNC_DELETE);
	if (!TXTSW_IS_READ_ONLY(textsw))
	    textsw->state |= TXTSW_PENDING_DELETE;
	    /* Force pending-delete feedback as it is implicit in DELETE */
	(void) textsw_inform_seln_svc(textsw, TXTSW_FUNC_DELETE, TRUE);
}

pkg_private int
textsw_end_delete(view)
	Textsw_view	view;
{
	extern void		textsw_init_selection_object();
	extern void		textsw_clear_secondary_selection();
	Textsw_selection_object	selection;
	int			result = 0;
	register Textsw_folio	folio = FOLIO_FOR_VIEW(view);

	(void) textsw_inform_seln_svc(folio, TXTSW_FUNC_DELETE, FALSE);
	if ((folio->func_state & TXTSW_FUNC_DELETE) == 0)
	    return(0);
	if ((folio->func_state & TXTSW_FUNC_EXECUTE) == 0)
	    goto Done;
	textsw_init_selection_object(folio, &selection, "", 0, FALSE);
	if (TFS_IS_ERROR(textsw_func_selection(folio, &selection, 0)))
	    goto Done;
	if (selection.type & TFS_IS_SELF) {
	    switch(textsw_adjust_delete_span(folio, &selection.first,
					     &selection.last_plus_one)) {
	      case TEXTSW_PE_READ_ONLY:
		textsw_clear_secondary_selection(folio, EV_SEL_SECONDARY);
		result = TEXTSW_PE_READ_ONLY;
		break;
	      case TXTSW_PE_EMPTY_INTERVAL:
		break;
	      case TXTSW_PE_ADJUSTED:
		textsw_set_selection(VIEW_REP_TO_ABS(folio->first_view),
				     ES_INFINITY, ES_INFINITY, selection.type);
		/* Fall through to delete remaining span */
	      default:
		textsw_checkpoint_undo(VIEW_REP_TO_ABS(view),
					(caddr_t)TEXTSW_INFINITY-1);
		(void) textsw_delete_span(
			view, selection.first, selection.last_plus_one,
			(unsigned)((selection.type & EV_SEL_PRIMARY)
			    ? TXTSW_DS_RECORD|TXTSW_DS_SHELVE
			    : TXTSW_DS_SHELVE));
		textsw_checkpoint_undo(VIEW_REP_TO_ABS(view),
					(caddr_t)TEXTSW_INFINITY-1);
		break;
	    }
	}
Done:
	textsw_end_function(view, TXTSW_FUNC_DELETE);
	textsw_update_scrollbars(folio, TEXTSW_VIEW_NULL);
	return(result);
}

pkg_private int
textsw_function_delete(view)
	Textsw_view	view;
{
	int		result;

	textsw_begin_delete(view);
	result = textsw_end_delete(view);
	return(result);
}

static
textsw_begin_undo(view)
	Textsw_view	view;
{
	textsw_begin_function(view, TXTSW_FUNC_UNDO);
	textsw_flush_caches(view, TFC_SEL);
}

static
textsw_end_undo(view)
	Textsw_view	view;
{
	textsw_do_undo(view);
	textsw_end_function(view, TXTSW_FUNC_UNDO);
	textsw_update_scrollbars(FOLIO_FOR_VIEW(view), TEXTSW_VIEW_NULL);
}

static
textsw_undo_notify(folio, start, delta)
	register Textsw_folio	folio;
	register Es_index	start, delta;
{
	extern void		textsw_notify_replaced();
	extern Es_index		ev_get_insert(),
				ev_set_insert();
	register Ev_chain	chain = folio->views;
	register Es_index	old_length =
				    es_get_length(chain->esh) - delta;
	Es_index		old_insert;

	if (folio->notify_level & TEXTSW_NOTIFY_EDIT)
	    old_insert = ev_get_insert(chain);
	(void) ev_set_insert(chain, (delta > 0) ? start+delta : start);
	ev_update_after_edit(chain,
			     (delta > 0) ? start : start-delta,
			     delta, old_length, start);
	if (folio->notify_level & TEXTSW_NOTIFY_EDIT) {
	    textsw_notify_replaced((Textsw_opaque)folio->first_view, 
			  old_insert, old_length,
			  (delta > 0) ? start : start+delta,
			  (delta > 0) ? start+delta : start,