/*FUNC-************************************************************************/
static int parse_args(int argc, char **argv)
{
int opt;
int ret = RET_OK;
cmd_id = get_cmd_id(argc, argv);
if (cmd_id < 0)
{
fprintf(stdout, "Unknown command: [%s]\n", cmd_kw);
ret = RET_INVALID_COMMAND;
goto EXIT;
}
if (!cmd_id)
{
show_usage();
}
optind++;
while ((opt = getopt(argc, argv, "AdiS:D:")) != -1)
{
switch (opt)
{
case 'A':
opt_all = TRUE;
break;
case 'i':
opt_obj = OBJ_WHITELIST_IP;
break;
case 'd':
opt_obj = OBJ_WHITELIST_DOMAIN;
break;
case 'S':
strncpy(acl_src_ip, optarg, sizeof(acl_src_ip) - 1);
break;
case 'D':
strncpy(acl_dst_ip, optarg, sizeof(acl_dst_ip) - 1);
break;
default:
fprintf(stdout, "Invalid option: [%c]\n", opt);
ret = RET_INVALID_OPTION;
goto EXIT;
}
}
EXIT:
return(ret);
}
t_pl_func AI_PI(char **cmd, double *delay)
{
char *args;
int cmd_id;
printf_debug("Parsing command: %s", *cmd);
if ((cmd_id = get_cmd_id(*cmd)) == -1)
{
printf_error("%s: command not found", *cmd);
return (NULL);
}
args = *cmd + strlen(g_cmds[cmd_id].name);
while (*args != '\0' && (*args == ' ' || *args == '\t' || *args == '\n'))
++args;
if ((*args != '\0' && *args != '\n') != (g_cmds[cmd_id].hasArg))
{
printf_error("%s: invalid arguments", *cmd);
return (NULL);
}
*cmd = (*args != '\0' ? args : NULL);
*delay = g_cmds[cmd_id].delay;
return (g_cmds[cmd_id].fn);
}
/* Determines what kind of processing should be applied to the command pointed
* to by the cmd. Returns the kind. */
static CmdArgsType
get_cmd_args_type(const char cmd[])
{
const int cmd_id = get_cmd_id(cmd);
switch(cmd_id)
{
case COMMAND_CMD_ID:
case COM_AUTOCMD:
case COM_EXECUTE:
case COM_CMAP:
case COM_CNOREMAP:
case COM_COMMAND:
case COM_DMAP:
case COM_DNOREMAP:
case COM_FILETYPE:
case COM_FILEVIEWER:
case COM_FILEXTYPE:
case COM_MAP:
case COM_MMAP:
case COM_MNOREMAP:
case COM_NMAP:
case COM_NNOREMAP:
case COM_NORMAL:
case COM_QMAP:
case COM_QNOREMAP:
case COM_VMAP:
case COM_VNOREMAP:
case COM_NOREMAP:
case COM_WINCMD:
case COM_WINDO:
case COM_WINRUN:
return CAT_UNTIL_THE_END;
default:
return command_accepts_expr(cmd_id) ? CAT_EXPR : CAT_REGULAR;
}
}
// Run SPI command
int run_spi_cmd(char *str, int mode){
// Split command stings and arguments
char *args = strstr(str, "=");
char *data = strstr(str, " ");
int len = 0;
if (data){
*data = '\0';
data += 1;
len = strlen(data);
}
if (args){
*args = '\0';
args += 1;
}
int i = get_cmd_id(str);
if (i>=0){
cmds[i].func(i, args, data, len, mode);
}
return i;
}
int callback_mpd(struct mg_connection *c)
{
enum mpd_cmd_ids cmd_id = get_cmd_id(c->content);
size_t n = 0;
unsigned int uint_buf, uint_buf_2;
int int_buf;
char *p_charbuf = NULL, *token;
if(cmd_id == -1)
return MG_TRUE;
if(mpd.conn_state != MPD_CONNECTED && cmd_id != MPD_API_SET_MPDHOST &&
cmd_id != MPD_API_GET_MPDHOST && cmd_id != MPD_API_SET_MPDPASS &&
cmd_id != MPD_API_GET_DIRBLEAPITOKEN)
return MG_TRUE;
switch(cmd_id)
{
case MPD_API_UPDATE_DB:
mpd_run_update(mpd.conn, NULL);
break;
case MPD_API_SET_PAUSE:
mpd_run_toggle_pause(mpd.conn);
break;
case MPD_API_SET_PREV:
mpd_run_previous(mpd.conn);
break;
case MPD_API_SET_NEXT:
mpd_run_next(mpd.conn);
break;
case MPD_API_SET_PLAY:
mpd_run_play(mpd.conn);
break;
case MPD_API_SET_STOP:
mpd_run_stop(mpd.conn);
break;
case MPD_API_RM_ALL:
mpd_run_clear(mpd.conn);
break;
case MPD_API_RM_TRACK:
if(sscanf(c->content, "MPD_API_RM_TRACK,%u", &uint_buf))
mpd_run_delete_id(mpd.conn, uint_buf);
break;
case MPD_API_PLAY_TRACK:
if(sscanf(c->content, "MPD_API_PLAY_TRACK,%u", &uint_buf))
mpd_run_play_id(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_RANDOM:
if(sscanf(c->content, "MPD_API_TOGGLE_RANDOM,%u", &uint_buf))
mpd_run_random(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_REPEAT:
if(sscanf(c->content, "MPD_API_TOGGLE_REPEAT,%u", &uint_buf))
mpd_run_repeat(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_CONSUME:
if(sscanf(c->content, "MPD_API_TOGGLE_CONSUME,%u", &uint_buf))
mpd_run_consume(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_SINGLE:
if(sscanf(c->content, "MPD_API_TOGGLE_SINGLE,%u", &uint_buf))
mpd_run_single(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_CROSSFADE:
if(sscanf(c->content, "MPD_API_TOGGLE_CROSSFADE,%u", &uint_buf))
mpd_run_crossfade(mpd.conn, uint_buf);
break;
case MPD_API_GET_OUTPUTS:
mpd.buf_size = mpd_put_outputs(mpd.buf, 1);
c->callback_param = NULL;
mpd_notify_callback(c, MG_POLL);
break;
case MPD_API_TOGGLE_OUTPUT:
if (sscanf(c->content, "MPD_API_TOGGLE_OUTPUT,%u,%u", &uint_buf, &uint_buf_2)) {
if (uint_buf_2)
mpd_run_enable_output(mpd.conn, uint_buf);
else
mpd_run_disable_output(mpd.conn, uint_buf);
}
break;
case MPD_API_SET_VOLUME:
if(sscanf(c->content, "MPD_API_SET_VOLUME,%ud", &uint_buf) && uint_buf <= 100)
mpd_run_set_volume(mpd.conn, uint_buf);
break;
case MPD_API_SET_SEEK:
if(sscanf(c->content, "MPD_API_SET_SEEK,%u,%u", &uint_buf, &uint_buf_2))
mpd_run_seek_id(mpd.conn, uint_buf, uint_buf_2);
break;
case MPD_API_GET_QUEUE:
if(sscanf(c->content, "MPD_API_GET_QUEUE,%u", &uint_buf))
n = mpd_put_queue(mpd.buf, uint_buf);
break;
case MPD_API_GET_BROWSE:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_GET_BROWSE"))
goto out_browse;
uint_buf = strtoul(strtok(NULL, ","), NULL, 10);
if((token = strtok(NULL, ",")) == NULL)
goto out_browse;
free(p_charbuf);
p_charbuf = strdup(c->content);
n = mpd_put_browse(mpd.buf, get_arg2(p_charbuf), uint_buf);
out_browse:
free(p_charbuf);
break;
case MPD_API_ADD_TRACK:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_ADD_TRACK"))
goto out_add_track;
if((token = strtok(NULL, ",")) == NULL)
goto out_add_track;
free(p_charbuf);
p_charbuf = strdup(c->content);
mpd_run_add(mpd.conn, get_arg1(p_charbuf));
out_add_track:
free(p_charbuf);
break;
case MPD_API_ADD_PLAY_TRACK:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_ADD_PLAY_TRACK"))
goto out_play_track;
if((token = strtok(NULL, ",")) == NULL)
goto out_play_track;
free(p_charbuf);
p_charbuf = strdup(c->content);
int_buf = mpd_run_add_id(mpd.conn, get_arg1(p_charbuf));
if(int_buf != -1)
mpd_run_play_id(mpd.conn, int_buf);
out_play_track:
free(p_charbuf);
break;
case MPD_API_ADD_PLAYLIST:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_ADD_PLAYLIST"))
goto out_playlist;
if((token = strtok(NULL, ",")) == NULL)
goto out_playlist;
free(p_charbuf);
p_charbuf = strdup(c->content);
mpd_run_load(mpd.conn, get_arg1(p_charbuf));
out_playlist:
free(p_charbuf);
break;
case MPD_API_SAVE_QUEUE:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_SAVE_QUEUE"))
goto out_save_queue;
if((token = strtok(NULL, ",")) == NULL)
goto out_save_queue;
free(p_charbuf);
p_charbuf = strdup(c->content);
mpd_run_save(mpd.conn, get_arg1(p_charbuf));
out_save_queue:
free(p_charbuf);
break;
case MPD_API_SEARCH:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_SEARCH"))
goto out_search;
if((token = strtok(NULL, ",")) == NULL)
goto out_search;
free(p_charbuf);
p_charbuf = strdup(c->content);
n = mpd_search(mpd.buf, get_arg1(p_charbuf));
out_search:
free(p_charbuf);
break;
#ifdef WITH_MPD_HOST_CHANGE
/* Commands allowed when disconnected from MPD server */
case MPD_API_SET_MPDHOST:
int_buf = 0;
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_SET_MPDHOST"))
goto out_host_change;
if((int_buf = strtol(strtok(NULL, ","), NULL, 10)) <= 0)
goto out_host_change;
if((token = strtok(NULL, ",")) == NULL)
goto out_host_change;
strncpy(mpd.host, token, sizeof(mpd.host));
mpd.port = int_buf;
mpd.conn_state = MPD_RECONNECT;
free(p_charbuf);
return MG_TRUE;
out_host_change:
free(p_charbuf);
break;
case MPD_API_GET_MPDHOST:
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"mpdhost\", \"data\": "
"{\"host\" : \"%s\", \"port\": \"%d\", \"passwort_set\": %s}"
"}", mpd.host, mpd.port, mpd.password ? "true" : "false");
break;
case MPD_API_GET_DIRBLEAPITOKEN:
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"dirbleapitoken\", \""
"data\": \"%s\"}", dirble_api_token);
break;
case MPD_API_SET_MPDPASS:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_SET_MPDPASS"))
goto out_set_pass;
if((token = strtok(NULL, ",")) == NULL)
goto out_set_pass;
if(mpd.password)
free(mpd.password);
mpd.password = strdup(token);
mpd.conn_state = MPD_RECONNECT;
free(p_charbuf);
return MG_TRUE;
out_set_pass:
free(p_charbuf);
break;
#endif
}
if(mpd.conn_state == MPD_CONNECTED && mpd_connection_get_error(mpd.conn) != MPD_ERROR_SUCCESS)
{
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"error\", \"data\": \"%s\"}",
mpd_connection_get_error_message(mpd.conn));
/* Try to recover error */
if (!mpd_connection_clear_error(mpd.conn))
mpd.conn_state = MPD_FAILURE;
}
if(n > 0)
mg_websocket_write(c, 1, mpd.buf, n);
return MG_TRUE;
}
int callback_mpd(struct mg_connection *c)
{
enum mpd_cmd_ids cmd_id = get_cmd_id(c->content);
size_t n = 0;
unsigned int uint_buf, uint_buf_2;
int int_buf;
char *p_charbuf = NULL;
if(cmd_id == -1)
return MG_CLIENT_CONTINUE;
if(mpd.conn_state != MPD_CONNECTED && cmd_id != MPD_API_SET_MPDHOST &&
cmd_id != MPD_API_GET_MPDHOST && cmd_id != MPD_API_SET_MPDPASS)
return MG_CLIENT_CONTINUE;
mpd_connection_set_timeout(mpd.conn, 10000);
switch(cmd_id)
{
case MPD_API_UPDATE_DB:
mpd_run_update(mpd.conn, NULL);
break;
case MPD_API_SET_PAUSE:
mpd_run_toggle_pause(mpd.conn);
break;
case MPD_API_SET_PREV:
mpd_run_previous(mpd.conn);
break;
case MPD_API_SET_NEXT:
mpd_run_next(mpd.conn);
break;
case MPD_API_SET_PLAY:
mpd_run_play(mpd.conn);
break;
case MPD_API_SET_STOP:
mpd_run_stop(mpd.conn);
break;
case MPD_API_RM_ALL:
mpd_run_clear(mpd.conn);
break;
case MPD_API_RM_TRACK:
if(sscanf(c->content, "MPD_API_RM_TRACK,%u", &uint_buf))
mpd_run_delete_id(mpd.conn, uint_buf);
break;
case MPD_API_PLAY_TRACK:
if(sscanf(c->content, "MPD_API_PLAY_TRACK,%u", &uint_buf))
mpd_run_play_id(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_RANDOM:
if(sscanf(c->content, "MPD_API_TOGGLE_RANDOM,%u", &uint_buf))
mpd_run_random(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_REPEAT:
if(sscanf(c->content, "MPD_API_TOGGLE_REPEAT,%u", &uint_buf))
mpd_run_repeat(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_CONSUME:
if(sscanf(c->content, "MPD_API_TOGGLE_CONSUME,%u", &uint_buf))
mpd_run_consume(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_SINGLE:
if(sscanf(c->content, "MPD_API_TOGGLE_SINGLE,%u", &uint_buf))
mpd_run_single(mpd.conn, uint_buf);
break;
case MPD_API_SET_VOLUME:
if(sscanf(c->content, "MPD_API_SET_VOLUME,%ud", &uint_buf) && uint_buf <= 100)
mpd_run_set_volume(mpd.conn, uint_buf);
break;
case MPD_API_SET_SEEK:
if(sscanf(c->content, "MPD_API_SET_SEEK,%u,%u", &uint_buf, &uint_buf_2))
mpd_run_seek_id(mpd.conn, uint_buf, uint_buf_2);
break;
case MPD_API_GET_QUEUE:
if(sscanf(c->content, "MPD_API_GET_QUEUE,%u", &uint_buf))
n = mpd_put_queue(mpd.buf, uint_buf);
break;
case MPD_API_GET_BROWSE:
if(sscanf(c->content, "MPD_API_GET_BROWSE,%u,%m[^\t\n]", &uint_buf, &p_charbuf) && p_charbuf != NULL)
{
n = mpd_put_browse(mpd.buf, p_charbuf, uint_buf);
free(p_charbuf);
}
break;
case MPD_API_ADD_TRACK:
if(sscanf(c->content, "MPD_API_ADD_TRACK,%m[^\t\n]", &p_charbuf) && p_charbuf != NULL)
{
mpd_run_add(mpd.conn, p_charbuf);
free(p_charbuf);
}
break;
case MPD_API_ADD_PLAY_TRACK:
if(sscanf(c->content, "MPD_API_ADD_PLAY_TRACK,%m[^\t\n]", &p_charbuf) && p_charbuf != NULL)
{
int_buf = mpd_run_add_id(mpd.conn, p_charbuf);
if(int_buf != -1)
mpd_run_play_id(mpd.conn, int_buf);
free(p_charbuf);
}
break;
case MPD_API_ADD_PLAYLIST:
if(sscanf(c->content, "MPD_API_ADD_PLAYLIST,%m[^\t\n]", &p_charbuf) && p_charbuf != NULL)
{
mpd_run_load(mpd.conn, p_charbuf);
free(p_charbuf);
}
break;
case MPD_API_SEARCH:
if(sscanf(c->content, "MPD_API_SEARCH,%m[^\t\n]", &p_charbuf) && p_charbuf != NULL)
{
n = mpd_search(mpd.buf, p_charbuf);
free(p_charbuf);
}
break;
#ifdef WITH_MPD_HOST_CHANGE
/* Commands allowed when disconnected from MPD server */
case MPD_API_SET_MPDHOST:
int_buf = 0;
if(sscanf(c->content, "MPD_API_SET_MPDHOST,%d,%m[^\t\n ]", &int_buf, &p_charbuf) &&
p_charbuf != NULL && int_buf > 0)
{
strncpy(mpd.host, p_charbuf, sizeof(mpd.host));
free(p_charbuf);
mpd.port = int_buf;
mpd.conn_state = MPD_RECONNECT;
return MG_CLIENT_CONTINUE;
}
break;
case MPD_API_GET_MPDHOST:
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"mpdhost\", \"data\": "
"{\"host\" : \"%s\", \"port\": \"%d\", \"passwort_set\": %s}"
"}", mpd.host, mpd.port, mpd.password ? "true" : "false");
break;
case MPD_API_SET_MPDPASS:
if(sscanf(c->content, "MPD_API_SET_MPDPASS,%m[^\t\n ]", &p_charbuf))
{
if(mpd.password)
free(mpd.password);
mpd.password = p_charbuf;
mpd.conn_state = MPD_RECONNECT;
return MG_CLIENT_CONTINUE;
}
break;
#endif
}
if(mpd.conn_state == MPD_CONNECTED && mpd_connection_get_error(mpd.conn) != MPD_ERROR_SUCCESS)
{
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"error\", \"data\": \"%s\"}",
mpd_connection_get_error_message(mpd.conn));
/* Try to recover error */
if (!mpd_connection_clear_error(mpd.conn))
mpd.conn_state = MPD_FAILURE;
}
if(n > 0)
mg_websocket_write(c, 1, mpd.buf, n);
return MG_CLIENT_CONTINUE;
}
void parse_msg(char *buf, int len, orix_msg *msg)
{
char *token = buf, *tmp = buf, *end;
int count = 0;
/* Segun rfc 1459 los mensajes deben terminar con un par \r\n, en este caso
* al que encuentre primero (\r o \n) lo cambiare por un espacio, de esta forma (1) no tendra
* problemas con encontrar el ultimo parametro.
*/
end = buf + len - 2;
if(*end == '\r')
*end = ' ';
else
end = NULL;
memset(msg, 0, sizeof(orix_msg));
/* Detectando origen (prefijo) */
if(*buf == ':') {
while((*token++)) {
if(*token == ' ') { /* Corto, lo agrego a la lista de componentes del mensaje. */
*token = 0;
msg->component[count++] = tmp + 1;
tmp = (token = token + 1);
break;
}
}
}
/* (1) */
while(*token) {
if(*token == ' ' && *(token + 1) != ' ') {
*token = 0; /* Corta la cadena */
msg->component[count++] = tmp;
if(*(token + 1) == ':') {
msg->component[count++] = token + 2;
if(end) { /* Necesito que los bytes \r\n sean ajustado a 0 */
*end = 0;
*(end + 1) = 0;
}
break;
}
if(count == MAX_COMPONENTS)
break;
tmp = token + 1;
}
token++;
}
if(*buf != ':')
msg->cmd_id = get_cmd_id(msg->component[0]); /* Si no tiene origen, el comando va primero */
else {
msg->cmd_id = get_cmd_id(msg->component[1]);
tmp = msg->component[0];
token = tmp;
/* Separa component[0] (origen) si tiene el formato *!*@*, consiguiendo nick, user, host */
while((*token++)) {
if(*token == '!') {
*token = 0;
msg->src_nick = tmp;
tmp = (token = token + 1);
} else if(*token == '@') {
*token = 0;
msg->src_user = tmp;
msg->src_host = token + 1;
}
}
}
msg->count = count;
}
/* Returns negative value in case of error */
static int
execute_command(FileView *view, const char command[], int menu)
{
int id;
int result;
if(command == NULL)
{
flist_sel_stash_if_nonempty(view);
return 0;
}
command = skip_to_cmd_name(command);
if(command[0] == '"')
return 0;
if(command[0] == '\0' && !menu)
{
flist_sel_stash_if_nonempty(view);
return 0;
}
if(!menu)
{
init_cmds(1, &cmds_conf);
cmds_conf.begin = 0;
cmds_conf.current = view->list_pos;
cmds_conf.end = view->list_rows - 1;
}
id = get_cmd_id(command);
if(!cmd_should_be_processed(id))
{
return 0;
}
if(id == USER_CMD_ID)
{
char undo_msg[COMMAND_GROUP_INFO_LEN];
snprintf(undo_msg, sizeof(undo_msg), "in %s: %s",
replace_home_part(flist_get_dir(view)), command);
cmd_group_begin(undo_msg);
cmd_group_end();
}
keep_view_selection = 0;
result = execute_cmd(command);
if(result >= 0)
return result;
switch(result)
{
case CMDS_ERR_LOOP:
status_bar_error("Loop in commands");
break;
case CMDS_ERR_NO_MEM:
status_bar_error("Unable to allocate enough memory");
break;
case CMDS_ERR_TOO_FEW_ARGS:
status_bar_error("Too few arguments");
break;
case CMDS_ERR_TRAILING_CHARS:
status_bar_error("Trailing characters");
break;
case CMDS_ERR_INCORRECT_NAME:
status_bar_error("Incorrect command name");
break;
case CMDS_ERR_NEED_BANG:
status_bar_error("Add bang to force");
break;
case CMDS_ERR_NO_BUILTIN_REDEFINE:
status_bar_error("Can't redefine builtin command");
break;
case CMDS_ERR_INVALID_CMD:
status_bar_error("Invalid command name");
break;
case CMDS_ERR_NO_BANG_ALLOWED:
status_bar_error("No ! is allowed");
break;
case CMDS_ERR_NO_RANGE_ALLOWED:
status_bar_error("No range is allowed");
break;
case CMDS_ERR_NO_QMARK_ALLOWED:
status_bar_error("No ? is allowed");
break;
case CMDS_ERR_INVALID_RANGE:
/* message dialog is enough */
break;
case CMDS_ERR_NO_SUCH_UDF:
status_bar_error("No such user defined command");
break;
case CMDS_ERR_UDF_IS_AMBIGUOUS:
status_bar_error("Ambiguous use of user-defined command");
break;
case CMDS_ERR_ZERO_COUNT:
status_bar_error("Zero count");
break;
case CMDS_ERR_INVALID_ARG:
status_bar_error("Invalid argument");
break;
case CMDS_ERR_CUSTOM:
/* error message is posted by command handler */
break;
default:
status_bar_error("Unknown error");
break;
}
if(!menu && vle_mode_is(NORMAL_MODE))
{
flist_sel_stash_if_nonempty(view);
}
return -1;
}
int
edit_cmd (SwitchCmd * scmd, AppData * a)
{
uint32_t i, maxx;
int state = 0;
uint32_t num_strings;
int lbl_x, idx = 0;
MENU *my_menu;
SwitchCmd tmp;
ITEM *my_items[11];
char *mnu_str[2][10];
// WINDOW * menu_win,*menu_sub;
tmp = *scmd;
message (a, "Modify Command\n");
while (state >= 0)
{
num_strings = 10; //what,len,data[8]
state = 0;
debugMsg ("allocating items\n");
mnu_str[0][0] = "Cmd";
mnu_str[1][0] = (char *) spGetCmdStr (tmp.what);
my_items[0] = new_item (mnu_str[0][0], mnu_str[1][0]);
mnu_str[0][1] = "Len";
mnu_str[1][1] = utlCalloc (32, sizeof (char));
snprintf (mnu_str[1][1], 32, "%u", tmp.len);
my_items[1] = new_item (mnu_str[0][1], mnu_str[1][1]);
for (i = 2; i < num_strings; i++)
{
mnu_str[0][i] = utlCalloc (32, sizeof (char));
snprintf (mnu_str[0][i], 32, "data[%" PRIu32 "]", i - 2);
mnu_str[1][i] = utlCalloc (32, sizeof (char));
snprintf (mnu_str[1][i], 32, "%u", tmp.data[i - 2]);
my_items[i] = new_item (mnu_str[0][i], mnu_str[1][i]);
}
my_items[num_strings] = (ITEM *) NULL;
my_menu = new_menu ((ITEM **) my_items);
set_menu_opts (my_menu,
O_ONEVALUE | O_NONCYCLIC | O_ROWMAJOR | O_SHOWDESC);
maxx = getmaxx (stdscr);
appDataMakeMenuWnd (my_menu);
post_menu (my_menu);
lbl_x = 3 + (maxx - 6) / 2 - strlen ("Cmd") / 2;
mvwprintw (menu_win (my_menu), 1, lbl_x, "%s", "Cmd");
wrefresh (menu_win (my_menu));
debugMsg ("starting menu loop\n");
while (state == 0)
{
int c;
ITEM *selection;
c = getch ();
switch (c)
{
case 263: //ESC
case K_BACK: //Backspace
state = -1;
break;
case KEY_DOWN:
menu_driver (my_menu, REQ_DOWN_ITEM);
break;
case KEY_UP:
menu_driver (my_menu, REQ_UP_ITEM);
break;
case KEY_RESIZE:
//windows need to be resized.. ignore
break;
case 'c':
state = 3;
break;
case 13: //enter
selection = current_item (my_menu);
idx = item_index (selection);
state = 5;
break;
default:
break;
}
wrefresh (menu_win (my_menu));
}
unpost_menu (my_menu);
appDataDestroyMenuWnd (my_menu);
free_menu (my_menu);
for (i = 0; i < num_strings; ++i)
{
free_item (my_items[i]);
}
utlFAN (mnu_str[1][1]);
for (i = 2; i < num_strings; ++i)
{
utlFAN (mnu_str[0][i]);
utlFAN (mnu_str[1][i]);
}
if (state > 0)
{
int rv;
switch (state)
{
case 3: //cancel
return 1;
case 5: //edit
switch (idx)
{
case 0:
rv = get_cmd_id (a);
if (rv >= 0)
tmp.what = rv;
break;
case 1:
tmp.len = get_num (a); //1,29,a);
break;
default:
tmp.data[idx - 2] = get_num (a); //idx,29,a);
break;
}
break;
default:
break;
}
}
}
*scmd = tmp; //replace with temporary
return 0;
}
