walkmenu_set.c

操作系统SunOS 4.1.3版本的源码

	    break;
	
	  default:
	    if (ATTR_PKG_MENU == ATTR_PKG(attrs[0]))
		(void) fprintf(stderr,
			"menu_set:  Menu attribute not allowed.\n%s\n",
			attr_sprint((caddr_t)NULL, (u_int)attrs[0]));
		break;
	    
	}
}


Pkg_private void
menu_item_sets(mi, attrs)
	register struct menu_item *mi;
 	register Menu_attribute *attrs;
{   
    for (; *attrs; attrs = menu_attr_next(attrs))
	switch (attrs[0]) {

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

	  case MENU_ACTION_ITEM:
	    (void) image_set(mi->image, IMAGE_STRING, attrs[1], 0);
	    mi->notify_proc = (caddr_t (*)())attrs[2];
	    break;

	  case MENU_STRING_ITEM:
	    (void) image_set(mi->image, IMAGE_STRING, attrs[1], 0);
	    mi->value = (caddr_t)attrs[2];
	    break;

	  case MENU_ACTION_IMAGE:
	    if (IMAGE_P(attrs[1])) { /* Fixme:  Image pkg should do this? */
		image_destroy(mi->image); /* Fixme:  If attrs[] == NULL ?? */
		mi->image = (struct image *)attrs[1];
	    } else if (mi->image) {
		(void) image_set(mi->image, IMAGE_PIXRECT, attrs[1], 0);
	    }
	    mi->notify_proc = (caddr_t (*)())attrs[2];
	    break;

	  case MENU_IMAGE_ITEM:
	    (void) image_set(mi->image, IMAGE_PIXRECT, attrs[1], 0);
	    mi->value = (caddr_t)attrs[2];
	    break;

	  case MENU_BOXED:
	    (void) image_set(mi->image, IMAGE_BOXED, attrs[1], 0);
	    break;

	  case MENU_CENTER:
	    (void) image_set(mi->image, IMAGE_CENTER, attrs[1], 0);
	    break;
	    
	  case MENU_CLIENT_DATA:
	    mi->client_data = (caddr_t)attrs[1];
	    break;
	    
	  case HELP_DATA:
	    mi->help_data = (caddr_t)attrs[1];
	    break;
	    
	  case MENU_FEEDBACK:
	    mi->no_feedback = !(int)attrs[1];
	    break;
	    
	  case MENU_FONT:
	    (void) image_set(mi->image, IMAGE_FONT, attrs[1], 0);
	    break;

	  case MENU_GEN_PROC:
	    mi->gen_proc = (struct menu_item *(*)())attrs[1];
	    break;

	  case MENU_GEN_PROC_IMAGE:
	    if (IMAGE_P(attrs[1])) { /* Fixme:  Image pkg should do this? */
		image_destroy(mi->image);
		mi->image = (struct image *)attrs[1];
	    } else {
		(void) image_set(mi->image, IMAGE_PIXRECT, attrs[1], 0);
		(void) image_set(mi->image, IMAGE_RIGHT_PIXRECT,
				 &menu_arrow_pr, 0);
	    }
	    mi->gen_proc = (struct menu_item *(*)())attrs[2];
	    break;

	  case MENU_GEN_PROC_ITEM:
	    (void) image_set(mi->image, IMAGE_STRING, attrs[1], 0);
	    (void) image_set(mi->image, IMAGE_RIGHT_PIXRECT, &menu_arrow_pr, 0);
	    mi->gen_proc = (struct menu_item *(*)())attrs[2];
	    break;
	    
	  case MENU_GEN_PULLRIGHT:
	    mi->gen_pullright = (struct menu *(*)())attrs[1];
	    mi->pullright = mi->gen_pullright != NULL;
	    (void) image_set(mi->image, IMAGE_RIGHT_PIXRECT,
		      mi->pullright ? &menu_arrow_pr : NULL, 
		      0);
	    break;

	  case MENU_GEN_PULLRIGHT_IMAGE:
	    if (IMAGE_P(attrs[1])) { /* Fixme:  Image pkg should do this? */
		image_destroy(mi->image);
		mi->image = (struct image *)attrs[1];
	    } else {
		(void) image_set(mi->image, IMAGE_PIXRECT, attrs[1], 0);
		(void) image_set(mi->image, IMAGE_RIGHT_PIXRECT,
				 &menu_arrow_pr, 0);
	    }
	    mi->gen_pullright = (struct menu *(*)())attrs[2];
	    mi->pullright = mi->gen_pullright != NULL;
	    mi->value = 0;
	    break;

	  case MENU_GEN_PULLRIGHT_ITEM:
	    (void) image_set(mi->image, IMAGE_STRING, attrs[1], 0);
	    (void) image_set(mi->image, IMAGE_RIGHT_PIXRECT, &menu_arrow_pr, 0);
	    mi->gen_pullright = (struct menu *(*)())attrs[2];
	    mi->pullright = mi->gen_pullright != NULL;
	    mi->value = 0;
	    break;
	    
	  case MENU_IMAGE:
	    if (IMAGE_P(attrs[1])) { /* Fixme:  Image pkg should do this? */
		image_destroy(mi->image);
		mi->image = (struct image *)attrs[1];
	    } else {
		(void) image_set(mi->image, IMAGE_PIXRECT, attrs[1], 0);
	    }
	    break;

	  case MENU_INACTIVE:
	    mi->inactive = (int)attrs[1];
	    break;

	  case MENU_INVERT:
	    (void) image_set(mi->image, IMAGE_INVERT, attrs[1], 0);
	    break;
	    
	  case MENU_LEFT_MARGIN:
	    (void) image_set(mi->image, IMAGE_LEFT_MARGIN, attrs[1], 0);
	    break;
	    
	  case MENU_MARGIN:
	    (void) image_set(mi->image, IMAGE_MARGIN, attrs[1], 0);
	    break;
	    
	  case MENU_PULLRIGHT:
	    mi->value = (caddr_t)attrs[1];
	    mi->pullright = mi->value != NULL;
	    (void) image_set(mi->image, IMAGE_RIGHT_PIXRECT,
		      mi->pullright ? &menu_arrow_pr : NULL,
		      0);
	    break;

	  case MENU_PULLRIGHT_IMAGE:
	    if (IMAGE_P(attrs[1])) { /* Fixme:  Image pkg should do this? */
		image_destroy(mi->image);
		mi->image = (struct image *)attrs[1];
	    } else if (mi->image) {
		(void) image_set(mi->image, IMAGE_PIXRECT, attrs[1], 0);
		(void) image_set(mi->image, IMAGE_RIGHT_PIXRECT,
				 &menu_arrow_pr, 0);
	    }
	    mi->value = (caddr_t)attrs[2];
	    mi->pullright = mi->value != NULL;
	    break;

	  case MENU_PULLRIGHT_ITEM:
	    (void) image_set(mi->image, IMAGE_STRING, attrs[1], 0);
	    (void) image_set(mi->image, IMAGE_RIGHT_PIXRECT, &menu_arrow_pr, 0);
	    mi->value = (caddr_t)attrs[2];
	    mi->pullright = mi->value != NULL;
	    break;

	  case MENU_RELEASE:
	    mi->free_item = TRUE;
	    break;
	    
	  case MENU_RELEASE_IMAGE:
	    if (mi->image) {
		/* FIXME: Someday this should separate the 2 cases. */
		mi->image->free_string = TRUE;
		mi->image->free_pr = TRUE;
	    }
	    break;
	    
	  case MENU_RIGHT_MARGIN:
	    (void) image_set(mi->image, IMAGE_RIGHT_MARGIN, attrs[1], 0);
	    break;
	    
	  case MENU_SELECTED:
	    mi->selected = (int)attrs[1];
	    break;
	    
	  case MENU_STRING:
	    (void) image_set(mi->image, IMAGE_STRING, attrs[1], 0);
	    break;
	    
	  case MENU_VALUE:
	    mi->value = (caddr_t)attrs[1];
	    mi->pullright = FALSE;
	    (void) image_set(mi->image, IMAGE_RIGHT_PIXRECT, NULL, 0);
	    break;

	  case MENU_LINE_AFTER_ITEM:
	    switch ((int)attrs[1])  {
	       case MENU_HORIZONTAL_LINE: 
	           mi->h_line = 1;
		   break;
	       case MENU_VERTICAL_LINE:
	           mi->v_line = 1;
		   break;
	       default:
	           (void) fprintf(stderr,
		   	"Invalid argument for attribute MENU_LINE_AFTER_ITEM: %d\n",(int)attrs[1]);
	    }
	    break;
		   	    
	  case MENU_NOP:
	    break;
	
	  default:
	    if (ATTR_PKG_MENU == ATTR_PKG(attrs[0]))
		(void) fprintf(stderr,
			"menu_set(item):  Menu attribute not allowed.\n%s\n",
			attr_sprint((caddr_t)NULL, (u_int)attrs[0]));
		break;

	}
}


Pkg_private void
menu_destroys(m, destroy_proc)
	register struct menu *m;
	void (*destroy_proc)();
{   
    register struct menu_item *mi;
    
    if (!m) return;
    for (; m->nitems-- > 0;) {
	mi = m->item_list[m->nitems];
	if (mi->pullright && !mi->gen_pullright && mi->value)
	    menu_destroys((struct menu *)LINT_CAST(mi->value), destroy_proc);
	menu_item_destroys(mi, destroy_proc);
    }
    free((caddr_t)m->item_list);
    if (destroy_proc) destroy_proc(m, MENU_MENU);
    free((caddr_t)m);
}


Pkg_private void
menu_item_destroys(mi, destroy_proc)
	register struct menu_item *mi;
	void (*destroy_proc)();
{
    if (!mi || !mi->free_item) return;
    image_destroy(mi->image);
    if (destroy_proc) destroy_proc(mi, MENU_ITEM);
    free((caddr_t)mi);
}


Private int
extend_item_list(m)
	register struct menu *m;
{
    extern caddr_t realloc();

    m->max_nitems =  m->max_nitems + MENU_FILLER;
    m->item_list = (struct menu_item **)LINT_CAST(realloc(
      (caddr_t)m->item_list,
      (u_int)(m->max_nitems * sizeof(struct menu_item *))));
    if (!m->item_list) {
	(void) fprintf(stderr,
		       "menu_set: Malloc failed to allocate an item list.\n");
	perror("menu_set");
	m->max_nitems =  m->max_nitems - MENU_FILLER;
	return FALSE;
    }
    return TRUE;
}


Private int
remove_item(il, len, pos)
	register struct menu_item *il[];
{
    register int i;
    if (pos < 1 || pos > len) return FALSE;
    for (i = pos; i < len; i++) il[i - 1] = il[i];
    return TRUE;
}


Private int
replace_item(il, len, pos, mi)
	struct menu_item *il[], *mi;
{
    if (pos < 1 || pos > len) return FALSE;
    il[pos - 1] = mi;
    return TRUE;
}


Private int
insert_item(il, len, pos, mi)
	register struct menu_item *il[];
	struct menu_item *mi;
{
    register int i;
    if (pos < 0 || pos >= len) return FALSE;
    for (i = len - 1; i > pos; --i) il[i] = il[i - 1];
    il[i] = mi;
    return TRUE;
}


Private int
lookup(il, len, mi)
	register struct menu_item *il[];
	struct menu_item *mi;
{
    int i;
    
    for (i = 0; i < len; i++) if (il[i] == mi) return i + 1;
    return -1;
}