win_keymap.c

操作系统SunOS 4.1.3版本的源码

		    }
		}
		break;
	    case 9:	/* cntl-i */
	        if (event_shiftmask(event) & CTRLMASK) {
		    if (event_shiftmask(event) & SHIFTMASK) {
	                action = ACTION_SELECT_FIELD_BACKWARD;
		    } else {
	                action = ACTION_SELECT_FIELD_FORWARD;
		    }
		}
		break;
	    case 240:	/* Meta-p */
                action = ACTION_COPY_THEN_PASTE;
		break;
	    case 243:	/* Meta-s */
                action = ACTION_STORE;
		break;
	    case 236:	/* Meta-l */
                action = ACTION_LOAD;
		break;
	    case 233:	/* Meta-i */
                action = ACTION_INSERT;
		break;
	    case 229:	/* Meta-e */
                action = ACTION_EMPTY;
	    	break;
	    case 228:	/* Meta-d */
                action = ACTION_MATCH_DELIMITER;
		break;
	    default:
	        /* Check to see if this is one of the 
                 * client-modifiable keys.
		 */

		if (keymap_from_fd[fd].keymap) {
		
		    km = keymap_from_fd[fd].keymap->km_table;
		    if (ie_code != km[WIN_KEYMAP_ERASE_CHAR].code &&
		        ie_code != km[WIN_KEYMAP_ERASE_WORD].code &&
			ie_code != km[WIN_KEYMAP_ERASE_LINE].code) {
			
			return;
		    } else if (ie_code == km[WIN_KEYMAP_ERASE_CHAR].code) {
		        if (event_shiftmask(event) & SHIFTMASK) {
			    action = ACTION_ERASE_CHAR_FORWARD;
			} else {
			    action = ACTION_ERASE_CHAR_BACKWARD;
			}
		    } else if (ie_code == km[WIN_KEYMAP_ERASE_WORD].code) {
			if (event_shiftmask(event) & SHIFTMASK) {
			    action = ACTION_ERASE_WORD_FORWARD;
			} else {
			    action = ACTION_ERASE_WORD_BACKWARD;
			}
		    } else if (ie_code == km[WIN_KEYMAP_ERASE_LINE].code) {
		        if (event_shiftmask(event) & SHIFTMASK) {
			    action = ACTION_ERASE_LINE_END;
			} else {
			    action = ACTION_ERASE_LINE_BACKWARD;
			}
		    }
		}
	}
      }

    } else {
        switch(ie_code) {
	    case WIN_STOP:
	        action =  ACTION_STOP;
		break;
	    case KEY_TOP(1):
	        action =  ACTION_CAPS_LOCK;
		break;
	    case 127:	/* DEL */
                /* kludge for compatibility with 4.0.
                 * do mapping if user has not modified default
                 * mappings 
                 */
		if (keymap_from_fd[fd].keymap) 
		    user_code = keymap_from_fd[fd].keymap->km_table[WIN_KEYMAP_ERASE_CHAR].code; 
		else 
		    user_code = 127;
		switch(user_code) {
		    case 0:
		    case 127:
			if (event_shiftmask(event) & SHIFTMASK) {
			    action =  ACTION_ERASE_CHAR_FORWARD;
			} else {
			    action =  ACTION_ERASE_CHAR_BACKWARD;
			}
			break;
		    default:
			break;
		}
		break;
	    case 23:	/* ^W */
                /* kludge for compatibility with 4.0.
                 * do mapping if user has not modified default
                 * mappings 
                 */
		if (keymap_from_fd[fd].keymap) 
		    user_code = keymap_from_fd[fd].keymap->km_table[WIN_KEYMAP_ERASE_WORD].code; 
		else 
		    user_code = 23;
		switch(user_code) {
		    case 0:
		    case 23:
			if (event_shiftmask(event) & SHIFTMASK) {
			    action =  ACTION_ERASE_WORD_FORWARD;
			} else {
			    action =  ACTION_ERASE_WORD_BACKWARD;
			}
			break;
		    default:
			break;
		}
		break;
	    case 21:	/* ^U */
                /* kludge for compatibility with 4.0.
                 * do mapping if user has not modified default
                 * mappings 
                 */
		if (keymap_from_fd[fd].keymap) 
		    user_code = keymap_from_fd[fd].keymap->km_table[WIN_KEYMAP_ERASE_LINE].code; 
		else 
		    user_code = 21;
		switch(user_code) {
		    case 0:
		    case 21:
			if (event_shiftmask(event) & SHIFTMASK) {
			    action =  ACTION_ERASE_LINE_END;
			} else {
			    action =  ACTION_ERASE_LINE_BACKWARD;
			}
			break;
		    default:
			break;
		}
		break;
	    case KEY_LEFT(2):
	        action =  ACTION_AGAIN;
		break;
	    case KEY_LEFT(6):
	        action =  ACTION_COPY;
		break;
	    case KEY_LEFT(8):
	        action =  ACTION_PASTE;
		break;
	    case KEY_LEFT(10):
	        action =  ACTION_CUT;
		break;
	    case 32569:	/* Help Key */
	        action =  ACTION_HELP;
		break;
	    case KEY_LEFT(3):
	        action =  ACTION_PROPS;
		break;
	    case KEY_RIGHT(11):
	        action =  ACTION_GO_LINE_FORWARD;
		break;
	    case KEY_RIGHT(13):
	        action =  ACTION_GO_DOCUMENT_END;
		break;
	    case KEY_RIGHT(7):
	        action =  ACTION_GO_DOCUMENT_START;
		break;
	    case KEY_LEFT(4):
	        if (event_shiftmask(event) & SHIFTMASK) {
		    action =  ACTION_REDO;
		} else {
		    action =  ACTION_UNDO;
		}
		break;
	    case KEY_LEFT(5):
	        if (event_shiftmask(event) & SHIFTMASK) {
		    action =  ACTION_BACK;
		} else {
		    action =  ACTION_FRONT;
		}
		break;
	    case KEY_LEFT(7):
	        if (event_shiftmask(event) & SHIFTMASK) {
		    action =  ACTION_CLOSE;
		} else {
		    action =  ACTION_OPEN;
		}
		break;
	    case KEY_LEFT(9):
	        if (!event_shiftmask(event)) {
		    action =  ACTION_FIND_FORWARD;
		} else if (event_shiftmask(event) & CTRLMASK) {
		    action =  ACTION_REPLACE;
		} else {
		    action =  ACTION_FIND_BACKWARD;
		}
		break;
	    case 13:	/* cntl-ret */
	        if (event_shiftmask(event) & CTRLMASK) {
		    if (event_shiftmask(event) & SHIFTMASK) {
	                action = ACTION_GO_DOCUMENT_START;
		    } else {
	                action = ACTION_GO_DOCUMENT_END;
		    }
		}
		break;
	    case 16:	/* cntl-p */
	        if (event_shiftmask(event) & CTRLMASK) {
		    if (event_shiftmask(event) & SHIFTMASK) {
	                action = ACTION_GO_COLUMN_FORWARD;
		    } else {
	                action = ACTION_GO_COLUMN_BACKWARD;
		    }
		}
	    default:
	        /* Check to see if this is one of the client-modifiable
		 * keys
		 */
		if (keymap_from_fd[fd].keymap) {
		    
		    km = keymap_from_fd[fd].keymap->km_table;
		    if (ie_code != km[WIN_KEYMAP_ERASE_CHAR].code &&
		        ie_code != km[WIN_KEYMAP_ERASE_WORD].code &&
			ie_code != km[WIN_KEYMAP_ERASE_LINE].code) {
			
			return;
		    } else if (ie_code == km[WIN_KEYMAP_ERASE_CHAR].code &&
		               mask_matches(event_shiftmask(event), 
			       km[WIN_KEYMAP_ERASE_CHAR].mask)) {
		        if (event_shiftmask(event) & SHIFTMASK) {
			    action =  ACTION_ERASE_CHAR_FORWARD;
			} else {
			    action =  ACTION_ERASE_CHAR_BACKWARD;
			}
		    } else if (ie_code == km[WIN_KEYMAP_ERASE_WORD].code &&
		    		mask_matches(event_shiftmask(event),
				km[WIN_KEYMAP_ERASE_WORD].mask)) {
			if (event_shiftmask(event) & SHIFTMASK) {
			    action =  ACTION_ERASE_WORD_FORWARD;
			} else {
			    action =  ACTION_ERASE_WORD_BACKWARD;
			}
		    } else if (ie_code == km[WIN_KEYMAP_ERASE_LINE].code &&
		    		mask_matches(event_shiftmask(event),
				km[WIN_KEYMAP_ERASE_LINE].mask)) {
		        if (event_shiftmask(event) & SHIFTMASK) {
			    action =  ACTION_ERASE_LINE_END;
			} else {
			    action =  ACTION_ERASE_LINE_BACKWARD;
			}
		    }
		}
	}
    }
    if (action && sv_bits_get_mask(kb, action - SUNVIEW_FIRST)) {
	event_set_action(event, action);
    }
}


/******************************************************************************
 *	win_keymap_code_and_mask(newevent, mask, mapping) -- take the
 *		event and mask and map the event into the corresponding mask
 *		and mapping event.
 ******************************************************************************/
void
win_keymap_map_code_and_mask(newevent, mask, mapping, fd)
    int newevent;
    int mask;
    int mapping;
    int fd;
{
     struct keymap_table	*km;
     
      if (!keymap_from_fd[fd].keymap) {
          keymap_from_fd[fd].keymap = (Keymap *)Malloc(sizeof(Keymap));
      }
      km = keymap_from_fd[fd].keymap->km_table;

    if (mapping == ACTION_ERASE_CHAR_BACKWARD) {
        km[WIN_KEYMAP_ERASE_CHAR].code = newevent;
	km[WIN_KEYMAP_ERASE_CHAR].mask = mask;
    } else if (mapping == ACTION_ERASE_WORD_BACKWARD) {
        km[WIN_KEYMAP_ERASE_WORD].code = newevent;
	km[WIN_KEYMAP_ERASE_WORD].mask = mask;
    } else if (mapping == ACTION_ERASE_LINE_BACKWARD) {
        km[WIN_KEYMAP_ERASE_LINE].code = newevent;
	km[WIN_KEYMAP_ERASE_LINE].mask = mask;
    }
    return;
}

void
win_keymap_unmap_code_and_mask(mapping, fd)
int	mapping;
int	fd;
{
    struct keymap_table	*km;

    if (!keymap_from_fd[fd].keymap) {
	return;
    } else {
	km = keymap_from_fd[fd].keymap->km_table;
    }
    
    if (mapping == ACTION_ERASE_CHAR_BACKWARD) {
        km[WIN_KEYMAP_ERASE_CHAR].code = 0;
	km[WIN_KEYMAP_ERASE_CHAR].mask = 0;
    } else if (mapping == ACTION_ERASE_WORD_BACKWARD) {
        km[WIN_KEYMAP_ERASE_WORD].code = 0;
	km[WIN_KEYMAP_ERASE_WORD].mask = 0;
    } else if (mapping == ACTION_ERASE_LINE_BACKWARD) {
        km[WIN_KEYMAP_ERASE_LINE].code = 0;
	km[WIN_KEYMAP_ERASE_LINE].mask = 0;
    }
    return;
}

void
win_keymap_init()
{
	register int i;
	
	/* Initialize the fd-to-keymap map */
	
	for (i = 0; i < NOFILE; i++) {
		keymap_from_fd[i].keymap = (Keymap *) 0;
		keymap_from_fd[i].smask = (Bitmask *) 0;
	}
	keymap_initialized = 1;
}

void
win_keymap_enable()
{
    keymap_enable++;
}

void
win_keymap_disable()
{
    keymap_enable = 0;
}

/**************************************************************
 * win_keymap_map_code_and_masks(), 
 * win_keymap_unmap_code_and_masks(), and
 * win_keymap_map_pending(), 
 * are included for compatibilty. These three functions
 * were a part of the 4.0 release but are no longer used in the 
 * latest libsuntool and libsunwindow libraries. However, they 
 * may still be needed by older binaries that use a libsuntool
 * library from 4.0. These functions are not the same as their 
 * 4.0 versions. Only the names are preserved.
 **************************************************************/
 
int
win_keymap_map_pending(fd, event)
int fd;
Event *event;
{ 
	/* There are no events that map 1-to-n in this system */
	return (0);
}

/***************************************************************
 * win_keymap_code_and_masks(newevent, masklist, mapping, fd) --
 * take the event and masklist and map those events into the
 * corresponding mask and mapping events.  Masklists are -1 terminated.
 ****************************************************************/


void
win_keymap_map_code_and_masks(newevent, masklist, mapping, fd)
int newevent;  
int masklist[];
int mapping;  
int fd;
{
	int *mask;

	for (mask = masklist; *mask != -1; mask++) {
	    win_keymap_map_code_and_mask(newevent, mask, mapping, fd);
	}	     

}

/* 
 * Empty function for compatibility 
 */

void
win_keymap_unmap_code_and_masks(newevent, masklist, fd)
int newevent;  
int masklist[];
int fd;
{

	/*
	 * This function is a leftover from 4.0. It 
	 * was called to unmap edit_back_char, edit_back_word, 
	 * edit_back_line (only) from ttysw/ttysw_init.c. This 
	 * was required to allow the user to override the default 
	 * settings rather than append to the default list. The 
	 * new keymapping mechanism does not allow an 1-to-n (action
	 * to event) mapping, thereby making this function 
	 * unnecessary. In the new mechanism when a new character 
	 * is mapped the old mapping is lost. 
	 */

	/* Do nothing. */
	return;
}