walkmenu_public.c

操作系统SunOS 4.1.3版本的源码

     va_list valist; 
     
     if (!m) return FALSE;

     va_start(valist); 
     (void) attr_make((char **)LINT_CAST(avlist), ATTR_STANDARD_SIZE, valist);
     va_end(valist); 
    
     (((struct menu *)LINT_CAST(m))->ops->menu_set_op)(m, avlist);
     return TRUE;
}


/* VARARGS2 */
caddr_t
menu_get(m, attr, v1)
	caddr_t m, attr, v1;
{
    return m ? (((struct menu *)LINT_CAST(m))->ops->menu_get_op)(m, attr, 
	v1) : NULL;
}


void
menu_destroy(m)
	caddr_t m; /* menu or menu_item */
{
    menu_destroy_with_proc(m, (void (*)())0);
}


void
menu_destroy_with_proc(m, destroy_proc)
	caddr_t m; /* menu or menu_item */
	void (*destroy_proc)();
{
    if (m)
	(((struct menu *)LINT_CAST(m))->ops->menu_destroy_op)(m, destroy_proc);
}


/* 
 *  Returns requested menu item position based on selection type.
 *  Always returns a legal item position.
 */
Pkg_private int
menu_curitem(m, type, default_pos)
	struct menu *m;
	Menu_attribute type;
{
    switch (type) {

      case MENU_SELECTED_ITEM:
      case MENU_SELECTED:
	if (range(m->selected_position, 1, m->nitems))
	    return m->selected_position;
	else if (m->default_position
		 && range(m->default_position, 1, m->nitems))
	    return m->default_position;
	else
	    return default_pos;
	
      case MENU_DEFAULT_ITEM:
      case MENU_DEFAULT:
	return range(m->default_position, 1, m->nitems)
	    ? m->default_position : default_pos;
	
      case NULL:  /* handles the case when the behavior wasn''t specified */
      case MENU_NOP:
      default:
	return (int)type > 0
	    && (int)type <= m->nitems ? (int)type : default_pos;
    }
}


Private caddr_t
menu_return_result(menu, dynamic, parent)
	struct menu *menu;
	struct menu_info *dynamic;
	struct menu_item *parent;
{   
    register struct menu *m;
    register struct menu_item *mi;
    struct menu *(*m_gen_proc)();
    struct menu_item *(*mi_gen_proc)();
    caddr_t v, (*notify_proc)();
    
    menu->dynamic_info = dynamic, menu->parent = parent;
    --dynamic->depth;

    if (m_gen_proc = menu->gen_proc) {
	m = (m_gen_proc)(menu, MENU_NOTIFY);
	if (m == NULL) return 0;
	m->dynamic_info = dynamic;
	m->parent = parent;
    } else m = menu; 
    
    /* 1017887 & 1011052 vmh */
    if (menu_get(m, MENU_NITEMS) <= 0) 
          {
          m = (m_gen_proc)(m, MENU_DISPLAY);
          } 
    /* 1017887 & 1011052 vmh */
    

    if (m->dynamic_info->depth < 0
	|| !range(m->selected_position, 1, m->nitems))
	m->selected_position = menu_curitem(m, m->default_selection, 1);
    mi = m->item_list[m->selected_position - 1];

    mi->selected = m->dynamic_info->depth <= 0;

    mi->parent = m;

    if (mi->inactive) {
	v = menu_return_no_value((Menu)m, (Menu_item)mi);
	goto cleanup;
    }

    if (mi_gen_proc = mi->gen_proc) {
	mi = (mi_gen_proc)(mi, MENU_NOTIFY);
	if (mi == NULL) return menu_return_no_value((Menu)menu, (Menu_item)mi);
	mi->parent = m;
    }
	    
    notify_proc =
	(m->dynamic_info->depth <= 0  && mi->notify_proc) ? mi->notify_proc
	    : m->notify_proc ? m->notify_proc : m->dynamic_info->notify_proc;
    
    v = (notify_proc)(m, mi);
    	
    if (mi_gen_proc) (mi_gen_proc)(mi, MENU_NOTIFY_DONE);

cleanup:
    if (m_gen_proc) {
	m->dynamic_info = NULL;
	
	/* 1017887 & 1011052 vmh */
	(m_gen_proc)(m, MENU_DISPLAY_DONE);
	/* 1017887 & 1011052 vmh */

	(m_gen_proc)(m, MENU_NOTIFY_DONE);
    }

    menu->dynamic_info = NULL;
    	
    return v;
}
	    

caddr_t
menu_pullright_return_result(menu_item)
	Menu_item menu_item;
{   
    register struct menu *m;
    struct menu *(*gen_proc)();
    register struct menu *mn;
    caddr_t v;
    register struct menu_item *mi = (struct menu_item *)LINT_CAST(menu_item);
    
    if (!mi || !mi->pullright) return NULL;

    m = mi->parent;

    if (gen_proc = mi->gen_pullright) {
	mn = (gen_proc)(mi, MENU_NOTIFY);
	if (mn == NULL) return menu_return_no_value((Menu)m, menu_item);
    } else {
	mn = (struct menu *)LINT_CAST(mi->value);
    }
    
    v = menu_return_result(mn, m->dynamic_info, mi);
    m->valid_result = mn->valid_result;
    
    if (gen_proc) (gen_proc)(mi, MENU_NOTIFY_DONE);
    
    return v;
}


caddr_t
menu_return_value(menu, menu_item)
	Menu menu;
	Menu_item menu_item;
{   
    register struct menu *m = (struct menu *)LINT_CAST(menu);
    register struct menu_item *mi = (struct menu_item *)LINT_CAST(menu_item);

    if (!m || !mi) {					/* No menu or item */
	if (m) m->valid_result = FALSE;
	return (caddr_t)MENU_NO_VALUE;
    }

    if (mi->pullright) return menu_pullright_return_result(menu_item);

    m->valid_result = TRUE;
    return (caddr_t)mi->value;				/* Return value */
}

    
caddr_t
menu_return_item(menu, menu_item)
	Menu menu;
	Menu_item menu_item;
{   
    register struct menu *m = (struct menu *)LINT_CAST(menu);
    register struct menu_item *mi = (struct menu_item *)LINT_CAST(menu_item);

    if (!m || !mi) {					/* No menu or item */
	if (m) m->valid_result = FALSE;
	return (caddr_t)MENU_NO_ITEM;
    }

    if (mi->pullright) return menu_pullright_return_result(menu_item);

    m->valid_result = TRUE;
    return (caddr_t)mi;					/* Return pointer */
}


/* ARGSUSED */    
caddr_t
menu_return_no_value(menu, menu_item)
	Menu menu;
	Menu_item menu_item;
{   
    struct menu *m = (struct menu *)LINT_CAST(menu);

    if (m) m->valid_result = FALSE;
    return (caddr_t)MENU_NO_VALUE;
}


/* ARGSUSED */    
caddr_t
menu_return_no_item(menu, menu_item)
	Menu menu;
	Menu_item menu_item;
{   
    struct menu *m = (struct menu *)LINT_CAST(menu);

    if (m) m->valid_result = FALSE;
    return (caddr_t)MENU_NO_ITEM;
}


/* 
 * Find the menu_item specified by the avlist.
 */
/* VARARGS1 */
Menu_item
menu_find(menu, va_alist)
	Menu menu;
	va_dcl
{   
    Menu_attribute avlist[ATTR_STANDARD_SIZE];
    va_list valist;
    register struct menu_item *mi, **mip;
    register Menu_attribute *attrs;
    register int nitems, valid;
    int submenus = FALSE, descend_first = FALSE;
    struct menu *m, *(*gen_proc)();
    struct menu_item *(*gen_item_proc)();
    struct menu *m_base = (struct menu *)LINT_CAST(menu);

    if (!m_base) return NULL;

    va_start(valist);    
    (void) attr_make((char **)LINT_CAST(avlist), ATTR_STANDARD_SIZE, valist);
    va_end(valist);

    nitems = m_base->nitems;
    for (attrs = avlist; *attrs; attrs = menu_attr_next(attrs))
	if (attrs[0] == MENU_DESCEND_FIRST) descend_first = (int)attrs[1];

    if (gen_proc = m_base->gen_proc) {
	m = (gen_proc)(m_base, MENU_DISPLAY);
	if (m == NULL) {
	    (void) fprintf(stderr,
		    "menu_find: menu's gen_proc failed to generate a menu.\n");
	    return NULL;
	}
    } else {
	m = m_base;
    }
    
    nitems = m->nitems;
    for (mip = m->item_list;valid = TRUE, mi = *mip, nitems--; mip++) {

	if (gen_item_proc = mi->gen_proc) {
	    mi = (gen_item_proc)(mi, MENU_DISPLAY);
	    if (mi == NULL) {
		(void) fprintf(stderr,
    "menu_find: menu item's gen_proc failed to generate a menu item.\n");
		goto exit;
	    }
	}
    
	for (attrs = avlist; *attrs; attrs = menu_attr_next(attrs)) {
	    switch (attrs[0]) {

	      case MENU_ACTION: /* & case MENU_NOTIFY_PROC: */
		valid &= mi->notify_proc == (caddr_t (*)())attrs[1];
		break;
	    
	      case MENU_CLIENT_DATA:
		valid &= mi->client_data == (caddr_t)attrs[1];
		break;

	      case MENU_FEEDBACK:
		valid &= !mi->no_feedback == (unsigned)attrs[1];
		break;
      
	      case MENU_FONT:
		valid &= image_get(mi->image, (struct image *)0, IMAGE_FONT) ==
		    (caddr_t)attrs[1];
		break;
	    
	      case MENU_GEN_PROC:
		valid &= mi->gen_proc == (struct menu_item *(*)())attrs[1];
		break;

	      case MENU_GEN_PULLRIGHT:
		valid &= mi->pullright &&
		    mi->gen_pullright == (struct menu *(*)())attrs[1];
		break;

	      case MENU_IMAGE:
		valid &= mi->image->pr == (struct pixrect *)attrs[1];
		break;

	      case MENU_INACTIVE:
		valid &= mi->inactive == (unsigned)attrs[1];
		break;
	    
	      case MENU_INVERT:
		valid &= mi->image && mi->image->invert == (unsigned)attrs[1];
		break;
	    
	      case MENU_LEFT_MARGIN:
		valid &= mi->image && mi->image->left_margin == (int)attrs[1];
		break;
	    
	      case MENU_MARGIN:
		valid &= mi->image && mi->image->margin == (int)attrs[1];
		break;
	    
	      case MENU_PARENT:
		valid &= mi->parent == (struct menu *)attrs[1];
		break;

	      case MENU_PULLRIGHT:
		valid &= mi->pullright && mi->value == (caddr_t)attrs[1];
		break;

	      case MENU_RIGHT_MARGIN:
		valid &= mi->image && mi->image->right_margin == (int)attrs[1];
		break;
	    
	      case MENU_STRING:
		valid &= strcmp(mi->image->string, (caddr_t)attrs[1]) == 0;
		break;

	      case MENU_VALUE:
		valid &= mi->value == (caddr_t)attrs[1];
		break;

	    }
	    if (!valid) break;
	}

	if (gen_item_proc) (gen_item_proc)(mi, MENU_DISPLAY_DONE);

	if (valid) goto exit;
	
	if (mi->pullright)
	    if (descend_first) {
		mi = (struct menu_item *)LINT_CAST(menu_find((Menu)mi->value,
						   ATTR_LIST, avlist, 0));
		if (mi) goto exit;
	    } else {
		submenus = TRUE;
	    }
    }
    
    if (submenus) {
	nitems = m->nitems;
	for (mip = m->item_list; mi = *mip, nitems--; mip++)
	    if (mi->pullright) {
		mi = (struct menu_item *)LINT_CAST(menu_find((Menu)mi->value,
						    ATTR_LIST, avlist, 0));
		if (mi) goto exit;
	    }
    }

    mi = NULL;

exit:
    if (gen_proc) (gen_proc)(m, MENU_DISPLAY_DONE);

    return  (Menu_item)mi;
}


#								ifdef needs_work
/*
 * FIXME: Needs more work.  Add small timeout for non-blocking read
 * 200msec?  Add attr for allow_accelerated_selection
 */
Private
accelerated_selection(m, fd, code)
    register struct menu *m;
{
    struct inputevent ie;
    register struct inputevent *iep = &ie;
    register int dopt, item;
    int		returncode;
    
    menu_selection = NULL;
    fcntl(fd, F_SETFL, FNDELAY);	/* Start 4.2BSD-style non-blocking I/O */
    while ( (returncode = read(fd, iep, sizeof(ie))) != -1) {
		if (iep->ie_code == code && win_inputnegevent(iep))
	    	while (m) {
				item = menu_curitem(m, m->initial_selection, 1);
				menu_selection = m->item_list[item - 1];
				if (menu_selection->pullright && menu_selection->value)
				    m = (struct menu *)menu_selection->value; /* generate? */
				else
				    m = NULL;
	    }
    dopt = fcntl(fd, F_GETFL, 0);/* Turn off non-blocking I/O */
    fcntl(fd, F_SETFL, dopt & ~FNDELAY);
}
#								endif needs_work


#ifdef no_longer_needed
menu_show_event(m, iep, fd)
	struct menu *m;
	struct inputevent *iep;
	int fd;
{   
    return (int)menu_show_using_fd(m, fd, iep);
}
#endif