NetBSD/lib/libmenu/item.c

/*	$NetBSD: item.c,v 1.11 2007/07/23 12:12:19 blymn Exp $	*/

/*-
 * Copyright (c) 1998-1999 Brett Lymn (blymn@baea.com.au, brett_lymn@yahoo.com.au)
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 */

#include <sys/cdefs.h>
__RCSID("$NetBSD: item.c,v 1.11 2007/07/23 12:12:19 blymn Exp $");

#include <menu.h>
#include <stdlib.h>
#include <string.h>
#include "internals.h"

/* the following is defined in menu.c - it is the default menu struct */
extern MENU _menui_default_menu;

/* keep default item options for setting in new_item */
ITEM _menui_default_item = {
	{NULL, 0}, /* item name struct */
	{NULL, 0}, /* item description struct */
	NULL, /* user pointer */
	0, /* is item visible? */
	0, /* is item selected? */
	0, /* row item is on */
	0, /* column item is on */
	O_SELECTABLE, /* item options */
	NULL, /* parent menu item is bound to */
	-1, /* index number if item attached to a menu */
	NULL, /* left neighbour */
	NULL, /* right neighbour */
	NULL, /* up neighbour */
	NULL /* down neighbour */
};

/*
 * Return the item visibility flag
 */
int
item_visible(ITEM *item)
{
	if (item == NULL)
		return E_BAD_ARGUMENT;
	if (item->parent == NULL)
		return E_NOT_CONNECTED;
	
        return item->visible;
}

/*
 * Return the pointer to the item name
 */
char *
item_name(ITEM *item)
{
	if (item == NULL)
		return NULL;
	
        return item->name.string;
}

/*
 * Return the pointer to the item description
 */
char *
item_description(ITEM *item)
{
	if (item == NULL)
		return NULL;
	
        return item->description.string;
}

/*
 * Set the application defined function called when the menu is posted or
 * just after the current item changes.
 */
int
set_item_init(MENU *menu, Menu_Hook func)
{
	if (menu == NULL)
		_menui_default_menu.item_init = func;
	else
		menu->item_init = func;
        return E_OK;
}


/*
 * Return a pointer to the item initialisation routine.
 */
Menu_Hook
item_init(MENU *menu)
{
	if (menu == NULL)
		return _menui_default_menu.item_init;
	else
		return menu->item_init;
}

/*
 * Set the user defined function to be called when menu is unposted or just
 * before the current item changes.
 */
int
set_item_term(MENU *menu, Menu_Hook func)
{
	if (menu == NULL)
		_menui_default_menu.item_term = func;
	else
		menu->item_term = func;
        return E_OK;
}

/*
 * Return a pointer to the termination function
 */
Menu_Hook
item_term(MENU *menu)
{
	if (menu == NULL)
		return _menui_default_menu.item_term;
	else
		return menu->item_term;
}

/*
 * Returns the number of items that are selected.
 * The index numbers of the items are placed in the dynamically allocated
 * int array *sel.
 */
int
item_selected(MENU *menu, int **sel)
{
	int i, j;

	if (menu == NULL)
		return E_BAD_ARGUMENT;

	/* count selected */
	for (i = 0, j = 0; i < menu->item_count; i++)
		if (menu->items[i]->selected)
			j++;

	if (j == 0) {
		*sel = NULL;
		return 0;
	}
	
	if ( (*sel = malloc(sizeof(int) * j)) == NULL)
		return E_SYSTEM_ERROR;

	for (i = 0, j = 0; i < menu->item_count; i++)
		if (menu->items[i]->selected)
			(*sel)[j++] = i;

	return j;
}

/*
 * Set the item options.  We keep a global copy of the current item options
 * as subsequent new_item calls will use the updated options as their
 * defaults.
 */
int
set_item_opts(item, opts)
        ITEM *item;
        OPTIONS opts;
{
          /* selectable seems to be the only allowable item opt! */
        if (opts != O_SELECTABLE)
                return E_SYSTEM_ERROR;

	if (item == NULL)
		_menui_default_item.opts = opts;
	else
		item->opts = opts;
        return E_OK;
}

/*
 * Set item options on.
 */
int
item_opts_on(ITEM *item, OPTIONS opts)
{
        if (opts != O_SELECTABLE)
                return E_SYSTEM_ERROR;

        if (item == NULL)
		_menui_default_item.opts |= opts;
	else
		item->opts |= opts;
        return E_OK;
}

/*
 * Turn off the named options.
 */
int
item_opts_off(ITEM *item, OPTIONS opts)
{
        if (opts != O_SELECTABLE)
                return E_SYSTEM_ERROR;

	if (item == NULL)
		_menui_default_item.opts &= ~(opts);
	else
		item->opts &= ~(opts);
        return E_OK;
}

/*
 * Return the current options set in item.
 */
OPTIONS
item_opts(ITEM *item)
{
	if (item == NULL)
		return _menui_default_item.opts;
	else
		return item->opts;
}

/*
 * Set the selected flag of the item iff the menu options allow it.
 */
int
set_item_value(ITEM *param_item, int flag)
{
	ITEM *item = (param_item != NULL) ? param_item : &_menui_default_item;
	
          /* not bound to a menu */
        if (item->parent == NULL)
                return E_NOT_CONNECTED;

          /* menu options do not allow multi-selection */
        if ((item->parent->opts & O_ONEVALUE) == O_ONEVALUE)
                return E_REQUEST_DENIED;

        item->selected = flag;
	_menui_draw_item(item->parent, item->index);
        return E_OK;
}

/*
 * Return the item value of the item.
 */
int
item_value(ITEM *item)
{
	if (item == NULL)
		return _menui_default_item.selected;
	else
		return item->selected;
}

/*
 * Allocate a new item and return the pointer to the newly allocated
 * structure.
 */
ITEM *
new_item(char *name, char *description)
{
        ITEM *new_one;

	if (name == NULL)
		return NULL;

	  /* allocate a new item structure for ourselves */
        if ((new_one = (ITEM *)malloc(sizeof(ITEM))) == NULL)
                return NULL;

	  /* copy in the defaults for the item */
	(void)memcpy(new_one, &_menui_default_item, sizeof(ITEM));
	
	  /* fill in the name structure - first the length and then
	     allocate room for the string & copy that. */
	new_one->name.length = strlen(name);
        if ((new_one->name.string = (char *)
             malloc(sizeof(char) * new_one->name.length + 1)) == NULL) {
		  /* uh oh malloc failed - clean up & exit */
		free(new_one);
                return NULL;
        }
        
        strcpy(new_one->name.string, name);

	if (description == NULL)
		new_one->description.length = 0;
	else {
	  /* fill in the description structure, stash the length then
	     allocate room for description string and copy it in */
        	new_one->description.length = strlen(description);
        	if ((new_one->description.string =
		    (char *) malloc(sizeof(char) *
		    new_one->description.length + 1)) == NULL) {
		  	/*
			 * malloc has failed
			 * - free up allocated memory and return
			 */
			free(new_one->name.string);
			free(new_one);
			return NULL;
		}
	
		strcpy(new_one->description.string, description);
	}

	return new_one;
}

/*
 * Free the allocated storage associated with item.
 */
int
free_item(ITEM *item)
{
	if (item == NULL)
		return E_BAD_ARGUMENT;
	
	  /* check for connection to menu */
	if (item->parent != NULL)
		return E_CONNECTED;

	  /* no connections, so free storage starting with the strings */
	free(item->name.string);
	if (item->description.length)
		free(item->description.string);
	free(item);
	return E_OK;
}

/*
 * Set the menu's current item to the one given.
 */
int
set_current_item(MENU *param_menu, ITEM *item)
{
	MENU *menu = (param_menu != NULL) ? param_menu : &_menui_default_menu;
	int i = 0;

	  /* check if we have been called from an init type function */
	if (menu->in_init == 1)
		return E_BAD_STATE;

	  /* check we have items in the menu */
	if (menu->items == NULL)
		return E_NOT_CONNECTED;

	if ((i = item_index(item)) < 0)
		  /* item must not be a part of this menu */
		return E_BAD_ARGUMENT;
	
	menu->cur_item = i;
	return E_OK;
}

/*
 * Return a pointer to the current item for the menu
 */
ITEM *
current_item(MENU *menu)
{
	if (menu == NULL)
		return NULL;
	
	if (menu->items == NULL)
		return NULL;
	
	return menu->items[menu->cur_item];
}

/*
 * Return the index into the item array that matches item.
 */
int
item_index(ITEM *item)
{
	if (item == NULL)
		return _menui_default_item.index;
	else
		return item->index;
}