void worldfactory::draw_mod_list( WINDOW *w, int &start, int &cursor, const std::vector<std::string> &mods, bool is_active_list, const std::string &text_if_empty )
{
werase( w );
calcStartPos( start, cursor, getmaxy( w ), mods.size() );
if( mods.empty() ) {
center_print( w, 0, c_red, "%s", text_if_empty.c_str() );
} else {
const size_t wwidth = getmaxx( w ) - 1 - 3; // border (1) + ">> " (3)
for( size_t i = start, c = 0; i < mods.size() && (int)c < getmaxy( w ); ++i, ++c ) {
auto mod = mman->mod_map[mods[i]];
if( (int)i != cursor ) {
mvwprintw( w, c, 1, " " );
} else {
if( is_active_list ) {
mvwprintz( w, c, 1, c_yellow, ">> " );
} else {
mvwprintz( w, c, 1, c_blue, ">> " );
}
}
const std::string name = utf8_truncate( mod->name, wwidth );
#ifndef LUA
if ( mod->need_lua ) {
mvwprintz( w, c, 4, c_dkgray, "%s", name.c_str() );
} else {
mvwprintz( w, c, 4, c_white, "%s", name.c_str() );
}
#else
mvwprintz( w, c, 4, c_white, "%s", name.c_str() );
#endif
}
}
draw_scrollbar( w, cursor, getmaxy( w ), mods.size(), 0, 0 );
wrefresh( w );
}
int
one_try_want_to(char *question, int dflt, int on_ctrl_C, HelpType help, int flags)
{
char *q2;
int rv;
size_t l;
l = strlen(question) + 5;
q2 = fs_get((l+1) * sizeof(char));
strncpy(q2, question, l);
q2[l] = '\0';
(void) utf8_truncate(q2, ps_global->ttyo->screen_cols - 6);
strncat(q2, "? ", l+1 - strlen(q2) - 1);
q2[l] = '\0';
rv = radio_buttons(q2,
(ps_global->ttyo->screen_rows > 4) ? - FOOTER_ROWS(ps_global) : -1,
yorn, dflt, on_ctrl_C, help, flags | RB_ONE_TRY);
fs_give((void **) &q2);
return(rv);
}
int
optionally_enter(char *utf8string, int y_base, int x_base, int utf8string_size,
char *utf8prompt, ESCKEY_S *escape_list, HelpType help, int *flags)
{
UCS *string = NULL, ucs;
size_t string_size;
UCS *s2;
UCS *saved_original = NULL;
char *candidate;
UCS *kill_buffer = NULL;
UCS *k, *kb;
int field_pos; /* offset into array dline.vl */
int i, j, return_v, cols, prompt_width, too_thin,
real_y_base, km_popped, passwd;
char **help_text;
long fkey_table[12];
struct key_menu *km;
bitmap_t bitmap;
COLOR_PAIR *lastc = NULL, *promptc = NULL;
struct variable *vars = ps_global->vars;
struct display_line dline;
#ifdef _WINDOWS
int cursor_shown;
#endif
dprint((5, "=== optionally_enter called ===\n"));
dprint((9, "utf8string:\"%s\" y:%d x:%d length: %d append: %d\n",
utf8string ? utf8string : "",
x_base, y_base, utf8string_size,
(flags && *flags & OE_APPEND_CURRENT)));
dprint((9, "passwd:%d utf8prompt:\"%s\" label:\"%s\"\n",
(flags && *flags & OE_PASSWD_NOAST) ? 10 :
(flags && *flags & OE_PASSWD) ? 1 : 0,
utf8prompt ? utf8prompt : "",
(escape_list && escape_list[0].ch != -1 && escape_list[0].label)
? escape_list[0].label: ""));
if(!ps_global->ttyo)
return(pre_screen_config_opt_enter(utf8string, utf8string_size, utf8prompt,
escape_list, help, flags));
#ifdef _WINDOWS
if (mswin_usedialog ())
return(win_dialog_opt_enter(utf8string, utf8string_size, utf8prompt,
escape_list, help, flags));
#endif
/*
* Utf8string comes in as UTF-8. We'll convert it to a UCS-4 array and operate on
* that array, then convert it back before returning. Utf8string_size is the size
* of the utf8string array but that doesn't help us much for the array we need to
* operate on here. We'll just allocate a big array and then cut it off when
* sending it back.
*
* This should come before the specialized calls above but those aren't
* converted to use UCS-4 yet.
*/
string = utf8_to_ucs4_cpystr(utf8string);
dline.vused = ucs4_strlen(string);
string_size = (2 * MAX(utf8string_size,dline.vused) + 100);
fs_resize((void **) &string, string_size * sizeof(UCS));
suspend_busy_cue();
cols = ps_global->ttyo->screen_cols;
prompt_width = utf8_width(utf8prompt);
too_thin = 0;
km_popped = 0;
if(y_base > 0)
real_y_base = y_base;
else{
real_y_base = y_base + ps_global->ttyo->screen_rows;
real_y_base = MAX(real_y_base, 0);
}
flush_ordered_messages();
mark_status_dirty();
if(flags && *flags & OE_APPEND_CURRENT) /* save a copy in case of cancel */
saved_original = ucs4_cpystr(string);
/*
* build the function key mapping table, skipping predefined keys...
*/
memset(fkey_table, NO_OP_COMMAND, 12 * sizeof(long));
for(i = 0, j = 0; escape_list && escape_list[i].ch != -1 && i+j < 12; i++){
if(i+j == OE_HELP_KEY)
j++;
if(i+j == OE_CANCEL_KEY)
j++;
if(i+j == OE_ENTER_KEY)
j++;
fkey_table[i+j] = escape_list[i].ch;
}
/* assumption that HelpType is char ** */
help_text = help;
if(help_text){ /*---- Show help text -----*/
int width = ps_global->ttyo->screen_cols - x_base;
if(FOOTER_ROWS(ps_global) == 1){
km_popped++;
FOOTER_ROWS(ps_global) = 3;
clearfooter(ps_global);
y_base = -3;
real_y_base = y_base + ps_global->ttyo->screen_rows;
}
for(j = 0; j < 2 && help_text[j]; j++){
MoveCursor(real_y_base + 1 + j, x_base);
CleartoEOLN();
if(width < utf8_width(help_text[j])){
char *tmp = cpystr(help_text[j]);
(void) utf8_truncate(tmp, width);
PutLine0(real_y_base + 1 + j, x_base, tmp);
fs_give((void **) &tmp);
}
else
PutLine0(real_y_base + 1 + j, x_base, help_text[j]);
}
}
else{
clrbitmap(bitmap);
clrbitmap((km = &oe_keymenu)->bitmap); /* force formatting */
if(!(flags && (*flags) & OE_DISALLOW_HELP))
setbitn(OE_HELP_KEY, bitmap);
setbitn(OE_ENTER_KEY, bitmap);
if(!(flags && (*flags) & OE_DISALLOW_CANCEL))
setbitn(OE_CANCEL_KEY, bitmap);
setbitn(OE_CTRL_T_KEY, bitmap);
/*---- Show the usual possible keys ----*/
for(i=0,j=0; escape_list && escape_list[i].ch != -1 && i+j < 12; i++){
if(i+j == OE_HELP_KEY)
j++;
if(i+j == OE_CANCEL_KEY)
j++;
if(i+j == OE_ENTER_KEY)
j++;
oe_keymenu.keys[i+j].label = escape_list[i].label;
oe_keymenu.keys[i+j].name = escape_list[i].name;
setbitn(i+j, bitmap);
}
for(i = i+j; i < 12; i++)
if(!(i == OE_HELP_KEY || i == OE_ENTER_KEY || i == OE_CANCEL_KEY))
oe_keymenu.keys[i].name = NULL;
draw_keymenu(km, bitmap, cols, 1-FOOTER_ROWS(ps_global), 0, FirstMenu);
}
if(pico_usingcolor() && VAR_PROMPT_FORE_COLOR &&
VAR_PROMPT_BACK_COLOR &&
pico_is_good_color(VAR_PROMPT_FORE_COLOR) &&
pico_is_good_color(VAR_PROMPT_BACK_COLOR)){
lastc = pico_get_cur_color();
if(lastc){
promptc = new_color_pair(VAR_PROMPT_FORE_COLOR,
VAR_PROMPT_BACK_COLOR);
(void)pico_set_colorp(promptc, PSC_NONE);
}
}
else
StartInverse();
/*
* if display length isn't wide enough to support input,
* shorten up the prompt...
*/
if((dline.dwid = cols - (x_base + prompt_width)) < MIN_OPT_ENT_WIDTH){
char *p;
unsigned got_width;
/*
* Scoot prompt pointer forward at least (MIN_OPT_ENT_WIDTH - dline.dwid) screencells.
*/
p = utf8_count_forw_width(utf8prompt, MIN_OPT_ENT_WIDTH-dline.dwid, &got_width);
if(got_width < MIN_OPT_ENT_WIDTH-dline.dwid)
p = utf8_count_forw_width(utf8prompt, MIN_OPT_ENT_WIDTH+1-dline.dwid, &got_width);
if(p){
prompt_width = utf8_width(p);
dline.dwid = cols - (x_base + prompt_width);
utf8prompt = p;
}
}
/*
* How many UCS-4 characters will we need to make up the width dwid? It could be
* unlimited because of zero-width characters, I suppose, but realistically it
* isn't going to be much more than dwid.
*/
dline.dlen = 2 * dline.dwid + 100;
dline.dl = (UCS *) fs_get(dline.dlen * sizeof(UCS));
dline.olddl = (UCS *) fs_get(dline.dlen * sizeof(UCS));
memset(dline.dl, 0, dline.dlen * sizeof(UCS));
memset(dline.olddl, 0, dline.dlen * sizeof(UCS));
dline.movecursor = MoveCursor;
dline.writechar = Writewchar;
dline.row = real_y_base;
dline.col = x_base + prompt_width;
dline.vl = string;
dline.vlen = --string_size; /* -1 for terminating zero */
dline.vbase = field_pos = 0;
#ifdef _WINDOWS
cursor_shown = mswin_showcaret(1);
#endif
PutLine0(real_y_base, x_base, utf8prompt);
/*
* If appending, position field_pos at end of input.
*/
if(flags && *flags & OE_APPEND_CURRENT)
while(string[field_pos])
field_pos++;
passwd = (flags && *flags & OE_PASSWD_NOAST) ? 10 :
(flags && *flags & OE_PASSWD) ? 1 : 0;
line_paint(field_pos, &dline, &passwd);
/*----------------------------------------------------------------------
The main loop
loops until someone sets the return_v.
----------------------------------------------------------------------*/
return_v = -10;
while(return_v == -10) {
#ifdef MOUSE
mouse_in_content(KEY_MOUSE, -1, -1, 0x5, 0);
register_mfunc(mouse_in_content,
real_y_base, x_base + prompt_width,
real_y_base, ps_global->ttyo->screen_cols);
#endif
#ifdef _WINDOWS
mswin_allowpaste(MSWIN_PASTE_LINE);
g_mc_row = real_y_base;
g_mc_col = x_base + prompt_width;
mswin_mousetrackcallback(pcpine_oe_cursor);
#endif
/* Timeout 10 min to keep imap mail stream alive */
ps_global->conceal_sensitive_debugging = passwd ? 1 : 0;
ucs = read_char(600);
ps_global->conceal_sensitive_debugging = 0;
#ifdef MOUSE
clear_mfunc(mouse_in_content);
#endif
#ifdef _WINDOWS
mswin_allowpaste(MSWIN_PASTE_DISABLE);
mswin_mousetrackcallback(NULL);
#endif
/*
* Don't want to intercept all characters if typing in passwd.
* We select an ad hoc set that we will catch and let the rest
* through. We would have caught the set below in the big switch
* but we skip the switch instead. Still catch things like ^K,
* DELETE, ^C, RETURN.
*/
if(passwd)
switch(ucs){
case ctrl('F'):
case KEY_RIGHT:
case ctrl('B'):
case KEY_LEFT:
case ctrl('U'):
case ctrl('A'):
case KEY_HOME:
case ctrl('E'):
case KEY_END:
case TAB:
goto ok_for_passwd;
}
if(too_thin && ucs != KEY_RESIZE && ucs != ctrl('Z') && ucs != ctrl('C'))
goto bleep;
switch(ucs){
/*--------------- KEY RIGHT ---------------*/
case ctrl('F'):
case KEY_RIGHT:
if(field_pos >= string_size || string[field_pos] == '\0')
goto bleep;
line_paint(++field_pos, &dline, &passwd);
break;
/*--------------- KEY LEFT ---------------*/
case ctrl('B'):
case KEY_LEFT:
if(field_pos <= 0)
goto bleep;
line_paint(--field_pos, &dline, &passwd);
break;
/*-------------------- WORD SKIP --------------------*/
case ctrl('@'):
/*
* Note: read_char *can* return NO_OP_COMMAND which is
* the def'd with the same value as ^@ (NULL), BUT since
* read_char has a big timeout (>25 secs) it won't.
*/
/* skip thru current word */
while(string[field_pos]
&& isalnum((unsigned char) string[field_pos]))
field_pos++;
/* skip thru current white space to next word */
while(string[field_pos]
&& !isalnum((unsigned char) string[field_pos]))
field_pos++;
line_paint(field_pos, &dline, &passwd);
break;
/*-------------------- RETURN --------------------*/
case PF4:
if(F_OFF(F_USE_FK,ps_global)) goto bleep;
case ctrl('J'):
case ctrl('M'):
return_v = 0;
break;
/*-------------------- Destructive backspace --------------------*/
case '\177': /* DEL */
case ctrl('H'):
/* Try and do this with by telling the terminal to delete a
a character. If that fails, then repaint the rest of the
line, acheiving the same much less efficiently
*/
if(field_pos <= 0)
goto bleep;
field_pos--;
/* drop thru to pull line back ... */
/*-------------------- Delete char --------------------*/
case ctrl('D'):
case KEY_DEL:
if(field_pos >= string_size || !string[field_pos])
goto bleep;
dline.vused--;
for(s2 = &string[field_pos]; *s2 != 0; s2++)
*s2 = s2[1];
*s2 = 0; /* Copy last NULL */
line_paint(field_pos, &dline, &passwd);
if(flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
break;
/*--------------- Kill line -----------------*/
case ctrl('K'):
if(kill_buffer != NULL)
fs_give((void **) &kill_buffer);
if(field_pos != 0 || string[0]){
if(!passwd && F_ON(F_DEL_FROM_DOT, ps_global))
dline.vused -= ucs4_strlen(&string[i = field_pos]);
else
dline.vused = i = 0;
kill_buffer = ucs4_cpystr(&string[field_pos = i]);
string[field_pos] = '\0';
line_paint(field_pos, &dline, &passwd);
if(flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
}
break;
/*------------------- Undelete line --------------------*/
case ctrl('U'):
if(kill_buffer == NULL)
goto bleep;
/* Make string so it will fit */
kb = ucs4_cpystr(kill_buffer);
if(ucs4_strlen(kb) + ucs4_strlen(string) > string_size)
kb[string_size - ucs4_strlen(string)] = '\0';
if(string[field_pos] == '\0') {
/*--- adding to the end of the string ----*/
for(k = kb; *k; k++)
string[field_pos++] = *k;
string[field_pos] = '\0';
}
else{
int shift;
shift = ucs4_strlen(kb);
/* shift field_pos ... end to right */
for(k = &string[field_pos] + ucs4_strlen(&string[field_pos]);
k >= &string[field_pos]; k--)
*(k+shift) = *k;
for(k = kb; *k; k++)
string[field_pos++] = *k;
}
if(*kb && flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
dline.vused = ucs4_strlen(string);
fs_give((void **) &kb);
line_paint(field_pos, &dline, &passwd);
break;
/*-------------------- Interrupt --------------------*/
case ctrl('C'): /* ^C */
if(F_ON(F_USE_FK,ps_global) || (flags && ((*flags) & OE_DISALLOW_CANCEL)))
goto bleep;
goto cancel;
case PF2:
if(F_OFF(F_USE_FK,ps_global) || (flags && ((*flags) & OE_DISALLOW_CANCEL)))
goto bleep;
cancel:
return_v = 1;
if(saved_original){
for(i = 0; saved_original[i]; i++)
string[i] = saved_original[i];
string[i] = 0;
}
break;
case ctrl('A'):
case KEY_HOME:
/*-------------------- Start of line -------------*/
line_paint(field_pos = 0, &dline, &passwd);
break;
case ctrl('E'):
case KEY_END:
/*-------------------- End of line ---------------*/
line_paint(field_pos = dline.vused, &dline, &passwd);
break;
/*-------------------- Help --------------------*/
case ctrl('G') :
case PF1:
if(flags && ((*flags) & OE_DISALLOW_HELP))
goto bleep;
else if(FOOTER_ROWS(ps_global) == 1 && km_popped == 0){
km_popped++;
FOOTER_ROWS(ps_global) = 3;
clearfooter(ps_global);
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
draw_keymenu(km, bitmap, cols, 1-FOOTER_ROWS(ps_global),
0, FirstMenu);
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
mark_keymenu_dirty();
y_base = -3;
dline.row = real_y_base = y_base + ps_global->ttyo->screen_rows;
PutLine0(real_y_base, x_base, utf8prompt);
memset(dline.dl, 0, dline.dlen * sizeof(UCS));
memset(dline.olddl, 0, dline.dlen * sizeof(UCS));
line_paint(field_pos, &dline, &passwd);
break;
}
if(FOOTER_ROWS(ps_global) > 1){
mark_keymenu_dirty();
return_v = 3;
}
else
goto bleep;
break;
#ifdef MOUSE
/* Mouse support untested in pine 5.00 */
case KEY_MOUSE :
{
MOUSEPRESS mp;
int w;
mouse_get_last (NULL, &mp);
switch(mp.button){
case M_BUTTON_LEFT : /* position cursor */
mp.col -= dline.col;
/*
* We have to figure out which character is under the cursor.
* This is complicated by the fact that characters may
* be other than one cell wide.
*/
/* the -1 is for the '<' when text is offscreen left */
w = (dline.vbase > 0) ? mp.col-1 : mp.col;
if(mp.col <= 0)
field_pos = dline.vbase - 1;
else{
if(dline.vused <= dline.vbase
|| ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vused-1) <= w)
field_pos = dline.vused;
else{
/*
* Find index of 1st character that causes the
* width to be > w.
*/
for(i = 0;
ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vbase+i) <= w;
i++)
;
field_pos = dline.vbase + i;
}
}
field_pos = MIN(MAX(field_pos, 0), dline.vused);
/* just allow line_paint to choose vbase */
line_paint(field_pos, &dline, &passwd);
break;
case M_BUTTON_RIGHT :
#ifdef _WINDOWS
/*
* Same as M_BUTTON_LEFT except we paste in text after
* moving the cursor.
*/
mp.col -= dline.col;
/* the -1 is for the '<' when text is offscreen left */
w = (dline.vbase > 0) ? mp.col-1 : mp.col;
if(mp.col <= 0)
field_pos = dline.vbase - 1;
else{
if(dline.vused <= dline.vbase
|| ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vused-1) <= w)
field_pos = dline.vused;
else{
/*
* Find index of 1st character that causes the
* width to be > w.
*/
for(i = 0;
ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vbase+i) <= w;
i++)
;
field_pos = dline.vbase + i;
}
}
field_pos = MIN(MAX(field_pos, 0), dline.vused);
line_paint(field_pos, &dline, &passwd);
mswin_allowpaste(MSWIN_PASTE_LINE);
mswin_paste_popup();
mswin_allowpaste(MSWIN_PASTE_DISABLE);
break;
#endif
case M_BUTTON_MIDDLE : /* NO-OP for now */
default: /* just ignore */
break;
}
}
break;
#endif
case NO_OP_IDLE:
/*
* Keep mail stream alive by checking for new mail.
* If we're asking for a password in a login prompt
* we don't want to check for new_mail because the
* new mail check might be what got us here in the first
* place (because of a filter trying to save a message).
* If we need to wait for the user to come back then
* the caller will just have to deal with the failure
* to login.
*/
i = -1;
if(!ps_global->no_newmail_check_from_optionally_enter)
i = new_mail(0, 2, NM_DEFER_SORT);
if(sp_expunge_count(ps_global->mail_stream) &&
flags && ((*flags) & OE_SEQ_SENSITIVE))
goto cancel;
if(i < 0){
line_paint(field_pos, &dline, &passwd);
break; /* no changes, get on with life */
}
/* Else fall into redraw */
/*-------------------- Redraw --------------------*/
case ctrl('L'):
/*---------------- re size ----------------*/
case KEY_RESIZE:
dline.row = real_y_base = y_base > 0 ? y_base :
y_base + ps_global->ttyo->screen_rows;
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
ClearScreen();
redraw_titlebar();
if(ps_global->redrawer != (void (*)(void))NULL)
(*ps_global->redrawer)();
redraw_keymenu();
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
PutLine0(real_y_base, x_base, utf8prompt);
cols = ps_global->ttyo->screen_cols;
too_thin = 0;
if(cols < x_base + prompt_width + 4){
Writechar(BELL, 0);
PutLine0(real_y_base, 0, "Screen's too thin. Ouch!");
too_thin = 1;
}
else{
dline.col = x_base + prompt_width;
dline.dwid = cols - (x_base + prompt_width);
dline.dlen = 2 * dline.dwid + 100;
fs_resize((void **) &dline.dl, (size_t) dline.dlen * sizeof(UCS));
fs_resize((void **) &dline.olddl, (size_t) dline.dlen * sizeof(UCS));
memset(dline.dl, 0, dline.dlen * sizeof(UCS));
memset(dline.olddl, 0, dline.dlen * sizeof(UCS));
line_paint(field_pos, &dline, &passwd);
}
fflush(stdout);
dprint((9,
"optionally_enter RESIZE new_cols:%d too_thin: %d\n",
cols, too_thin));
break;
case PF3 : /* input to potentially remap */
case PF5 :
case PF6 :
case PF7 :
case PF8 :
case PF9 :
case PF10 :
case PF11 :
case PF12 :
if(F_ON(F_USE_FK,ps_global)
&& fkey_table[ucs - PF1] != NO_OP_COMMAND)
ucs = fkey_table[ucs - PF1]; /* remap function key input */
default:
if(escape_list){ /* in the escape key list? */
for(j=0; escape_list[j].ch != -1; j++){
if(escape_list[j].ch == ucs){
return_v = escape_list[j].rval;
break;
}
}
if(return_v != -10)
break;
}
if(ucs < 0x80 && FILTER_THIS((unsigned char) ucs)){
bleep:
putc(BELL, stdout);
continue;
}
ok_for_passwd:
/*--- Insert a character -----*/
if(dline.vused >= string_size)
goto bleep;
/*---- extending the length of the string ---*/
for(s2 = &string[++dline.vused]; s2 - string > field_pos; s2--)
*s2 = *(s2-1);
string[field_pos++] = ucs;
line_paint(field_pos, &dline, &passwd);
if(flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
} /*---- End of switch on char ----*/
}
#ifdef _WINDOWS
if(!cursor_shown)
mswin_showcaret(0);
#endif
if(dline.dl)
fs_give((void **) &dline.dl);
if(dline.olddl)
fs_give((void **) &dline.olddl);
if(saved_original)
fs_give((void **) &saved_original);
if(kill_buffer)
fs_give((void **) &kill_buffer);
/*
* Change string back into UTF-8.
*/
candidate = ucs4_to_utf8_cpystr(string);
if(string)
fs_give((void **) &string);
if(candidate){
strncpy(utf8string, candidate, utf8string_size);
utf8string[utf8string_size-1] = '\0';
fs_give((void **) &candidate);
}
if (!(flags && (*flags) & OE_KEEP_TRAILING_SPACE))
removing_trailing_white_space(utf8string);
if(lastc){
(void)pico_set_colorp(lastc, PSC_NONE);
free_color_pair(&lastc);
if(promptc)
free_color_pair(&promptc);
}
else
EndInverse();
MoveCursor(real_y_base, x_base); /* Move the cursor to show we're done */
fflush(stdout);
resume_busy_cue(0);
if(km_popped){
FOOTER_ROWS(ps_global) = 1;
clearfooter(ps_global);
ps_global->mangled_body = 1;
}
return(return_v);
}
const recipe *select_crafting_recipe( int &batch_size )
{
if( normalized_names.empty() ) {
translate_all();
}
const int headHeight = 3;
const int subHeadHeight = 2;
const int freeWidth = TERMX - FULL_SCREEN_WIDTH;
bool isWide = ( TERMX > FULL_SCREEN_WIDTH && freeWidth > 15 );
const int width = isWide ? ( freeWidth > FULL_SCREEN_WIDTH ? FULL_SCREEN_WIDTH * 2 : TERMX ) :
FULL_SCREEN_WIDTH;
const int wStart = ( TERMX - width ) / 2;
const int tailHeight = isWide ? 3 : 4;
const int dataLines = TERMY - ( headHeight + subHeadHeight ) - tailHeight;
const int dataHalfLines = dataLines / 2;
const int dataHeight = TERMY - ( headHeight + subHeadHeight );
const int infoWidth = width - FULL_SCREEN_WIDTH - 1;
const recipe *last_recipe = nullptr;
catacurses::window w_head = catacurses::newwin( headHeight, width, 0, wStart );
catacurses::window w_subhead = catacurses::newwin( subHeadHeight, width, 3, wStart );
catacurses::window w_data = catacurses::newwin( dataHeight, width, headHeight + subHeadHeight,
wStart );
int item_info_x = infoWidth;
int item_info_y = dataHeight - 3;
int item_info_width = wStart + width - infoWidth;
int item_info_height = headHeight + subHeadHeight;
if( !isWide ) {
item_info_x = 1;
item_info_y = 1;
item_info_width = 1;
item_info_height = 1;
}
catacurses::window w_iteminfo = catacurses::newwin( item_info_y, item_info_x, item_info_height,
item_info_width );
list_circularizer<std::string> tab( craft_cat_list );
list_circularizer<std::string> subtab( craft_subcat_list[tab.cur()] );
std::vector<const recipe *> current;
std::vector<bool> available;
const int componentPrintHeight = dataHeight - tailHeight - 1;
//preserves component color printout between mode rotations
nc_color rotated_color = c_white;
int previous_item_line = -1;
std::string previous_tab;
std::string previous_subtab;
item tmp;
int line = 0;
int ypos = 0;
int scroll_pos = 0;
bool redraw = true;
bool keepline = false;
bool done = false;
bool batch = false;
bool show_hidden = false;
int batch_line = 0;
int display_mode = 0;
const recipe *chosen = nullptr;
std::vector<iteminfo> thisItem;
std::vector<iteminfo> dummy;
input_context ctxt( "CRAFTING" );
ctxt.register_cardinal();
ctxt.register_action( "QUIT" );
ctxt.register_action( "CONFIRM" );
ctxt.register_action( "CYCLE_MODE" );
ctxt.register_action( "SCROLL_UP" );
ctxt.register_action( "SCROLL_DOWN" );
ctxt.register_action( "PREV_TAB" );
ctxt.register_action( "NEXT_TAB" );
ctxt.register_action( "FILTER" );
ctxt.register_action( "RESET_FILTER" );
ctxt.register_action( "TOGGLE_FAVORITE" );
ctxt.register_action( "HELP_RECIPE" );
ctxt.register_action( "HELP_KEYBINDINGS" );
ctxt.register_action( "CYCLE_BATCH" );
ctxt.register_action( "RELATED_RECIPES" );
ctxt.register_action( "HIDE_SHOW_RECIPE" );
const inventory &crafting_inv = g->u.crafting_inventory();
const std::vector<npc *> helpers = g->u.get_crafting_helpers();
std::string filterstring;
const auto &available_recipes = g->u.get_available_recipes( crafting_inv, &helpers );
std::map<const recipe *, bool> availability_cache;
do {
if( redraw ) {
// When we switch tabs, redraw the header
redraw = false;
if( ! keepline ) {
line = 0;
} else {
keepline = false;
}
if( display_mode > 2 ) {
display_mode = 2;
}
TAB_MODE m = ( batch ) ? BATCH : ( filterstring.empty() ) ? NORMAL : FILTERED;
draw_recipe_tabs( w_head, tab.cur(), m );
draw_recipe_subtabs( w_subhead, tab.cur(), subtab.cur(), available_recipes, m );
show_hidden = false;
available.clear();
if( batch ) {
current.clear();
for( int i = 1; i <= 20; i++ ) {
current.push_back( chosen );
available.push_back( chosen->requirements().can_make_with_inventory( crafting_inv, i ) );
}
} else {
std::vector<const recipe *> picking;
if( !filterstring.empty() ) {
auto qry = trim( filterstring );
if( qry.size() > 2 && qry[1] == ':' ) {
switch( qry[0] ) {
case 't':
picking = available_recipes.search( qry.substr( 2 ), recipe_subset::search_type::tool );
break;
case 'c':
picking = available_recipes.search( qry.substr( 2 ), recipe_subset::search_type::component );
break;
case 's':
picking = available_recipes.search( qry.substr( 2 ), recipe_subset::search_type::skill );
break;
case 'p':
picking = available_recipes.search( qry.substr( 2 ), recipe_subset::search_type::primary_skill );
break;
case 'Q':
picking = available_recipes.search( qry.substr( 2 ), recipe_subset::search_type::quality );
break;
case 'q':
picking = available_recipes.search( qry.substr( 2 ), recipe_subset::search_type::quality_result );
break;
case 'd':
picking = available_recipes.search( qry.substr( 2 ),
recipe_subset::search_type::description_result );
break;
case 'm': {
auto &learned = g->u.get_learned_recipes();
if( query_is_yes( qry ) ) {
std::set_intersection( available_recipes.begin(), available_recipes.end(), learned.begin(),
learned.end(), std::back_inserter( picking ) );
} else {
std::set_difference( available_recipes.begin(), available_recipes.end(), learned.begin(),
learned.end(),
std::back_inserter( picking ) );
}
break;
}
case 'h': {
std::copy( available_recipes.begin(), available_recipes.end(), std::back_inserter( picking ) );
if( query_is_yes( qry ) ) {
show_hidden = true;
}
break;
}
default:
current.clear();
}
} else {
picking = available_recipes.search( qry );
}
} else if( subtab.cur() == "CSC_*_FAVORITE" ) {
picking = available_recipes.favorite();
} else if( subtab.cur() == "CSC_*_RECENT" ) {
picking = available_recipes.recent();
} else {
picking = available_recipes.in_category( tab.cur(), subtab.cur() != "CSC_ALL" ? subtab.cur() : "" );
}
current.clear();
for( auto i : picking ) {
if( ( uistate.hidden_recipes.find( i->ident() ) != uistate.hidden_recipes.end() ) == show_hidden ) {
current.push_back( i );
}
}
if( !show_hidden ) {
draw_hidden_amount( w_head, 0, picking.size() - current.size() );
}
available.reserve( current.size() );
// cache recipe availability on first display
for( const auto e : current ) {
if( !availability_cache.count( e ) ) {
availability_cache.emplace( e, e->requirements().can_make_with_inventory( crafting_inv ) );
}
}
if( subtab.cur() != "CSC_*_RECENT" ) {
std::stable_sort( current.begin(), current.end(), []( const recipe * a, const recipe * b ) {
return b->difficulty < a->difficulty;
} );
std::stable_sort( current.begin(), current.end(), [&]( const recipe * a, const recipe * b ) {
return availability_cache[a] && !availability_cache[b];
} );
}
std::transform( current.begin(), current.end(),
std::back_inserter( available ), [&]( const recipe * e ) {
return availability_cache[e];
} );
}
// current/available have been rebuilt, make sure our cursor is still in range
if( current.empty() ) {
line = 0;
} else {
line = std::min( line, static_cast<int>( current.size() ) - 1 );
}
}
// Clear the screen of recipe data, and draw it anew
werase( w_data );
if( isWide ) {
werase( w_iteminfo );
}
if( isWide ) {
mvwprintz( w_data, dataLines + 1, 5, c_white,
_( "Press <ENTER> to attempt to craft object." ) );
wprintz( w_data, c_white, " " );
if( !filterstring.empty() ) {
wprintz( w_data, c_white,
_( "[E]: Describe, [F]ind, [R]eset, [m]ode, [s]how/hide, Re[L]ated, [*]Favorite, %s [?] keybindings" ),
( batch ) ? _( "cancel [b]atch" ) : _( "[b]atch" ) );
} else {
wprintz( w_data, c_white,
_( "[E]: Describe, [F]ind, [m]ode, [s]how/hide, Re[L]ated, [*]Favorite, %s [?] keybindings" ),
( batch ) ? _( "cancel [b]atch" ) : _( "[b]atch" ) );
}
} else {
if( !filterstring.empty() ) {
mvwprintz( w_data, dataLines + 1, 5, c_white,
_( "[E]: Describe, [F]ind, [R]eset, [m]ode, [s]how/hide, Re[L]ated, [*]Favorite, [b]atch [?] keybindings" ) );
} else {
mvwprintz( w_data, dataLines + 1, 5, c_white,
_( "[E]: Describe, [F]ind, [m]ode, [s]how/hide, Re[L]ated, [*]Favorite, [b]atch [?] keybindings" ) );
}
mvwprintz( w_data, dataLines + 2, 5, c_white,
_( "Press <ENTER> to attempt to craft object." ) );
}
// Draw borders
for( int i = 1; i < width - 1; ++i ) { // _
mvwputch( w_data, dataHeight - 1, i, BORDER_COLOR, LINE_OXOX );
}
for( int i = 0; i < dataHeight - 1; ++i ) { // |
mvwputch( w_data, i, 0, BORDER_COLOR, LINE_XOXO );
mvwputch( w_data, i, width - 1, BORDER_COLOR, LINE_XOXO );
}
mvwputch( w_data, dataHeight - 1, 0, BORDER_COLOR, LINE_XXOO ); // _|
mvwputch( w_data, dataHeight - 1, width - 1, BORDER_COLOR, LINE_XOOX ); // |_
int recmin = 0, recmax = current.size();
if( recmax > dataLines ) {
if( line <= recmin + dataHalfLines ) {
for( int i = recmin; i < recmin + dataLines; ++i ) {
std::string tmp_name = current[i]->result_name();
if( batch ) {
tmp_name = string_format( _( "%2dx %s" ), i + 1, tmp_name.c_str() );
}
mvwprintz( w_data, i - recmin, 2, c_dark_gray, "" ); // Clear the line
if( i == line ) {
mvwprintz( w_data, i - recmin, 2, ( available[i] ? h_white : h_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
} else {
mvwprintz( w_data, i - recmin, 2, ( available[i] ? c_white : c_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
}
}
} else if( line >= recmax - dataHalfLines ) {
for( int i = recmax - dataLines; i < recmax; ++i ) {
std::string tmp_name = current[i]->result_name();
if( batch ) {
tmp_name = string_format( _( "%2dx %s" ), i + 1, tmp_name.c_str() );
}
mvwprintz( w_data, dataLines + i - recmax, 2, c_light_gray, "" ); // Clear the line
if( i == line ) {
mvwprintz( w_data, dataLines + i - recmax, 2,
( available[i] ? h_white : h_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
} else {
mvwprintz( w_data, dataLines + i - recmax, 2,
( available[i] ? c_white : c_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
}
}
} else {
for( int i = line - dataHalfLines; i < line - dataHalfLines + dataLines; ++i ) {
std::string tmp_name = current[i]->result_name();
if( batch ) {
tmp_name = string_format( _( "%2dx %s" ), i + 1, tmp_name.c_str() );
}
mvwprintz( w_data, dataHalfLines + i - line, 2, c_light_gray, "" ); // Clear the line
if( i == line ) {
mvwprintz( w_data, dataHalfLines + i - line, 2,
( available[i] ? h_white : h_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
} else {
mvwprintz( w_data, dataHalfLines + i - line, 2,
( available[i] ? c_white : c_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
}
}
}
} else {
for( size_t i = 0; i < current.size() && i < static_cast<size_t>( dataHeight ) + 1; ++i ) {
std::string tmp_name = current[i]->result_name();
if( batch ) {
tmp_name = string_format( _( "%2dx %s" ), static_cast<int>( i ) + 1, tmp_name.c_str() );
}
if( static_cast<int>( i ) == line ) {
mvwprintz( w_data, i, 2, ( available[i] ? h_white : h_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
} else {
mvwprintz( w_data, i, 2, ( available[i] ? c_white : c_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
}
}
}
if( !current.empty() ) {
int pane = FULL_SCREEN_WIDTH - 30 - 1;
int count = batch ? line + 1 : 1; // batch size
nc_color col = available[ line ] ? c_white : c_light_gray;
const auto &req = current[ line ]->requirements();
draw_can_craft_indicator( w_head, 0, *current[line] );
wrefresh( w_head );
ypos = 0;
auto qry = trim( filterstring );
std::string qry_comps;
if( qry.compare( 0, 2, "c:" ) == 0 ) {
qry_comps = qry.substr( 2 );
}
std::vector<std::string> component_print_buffer;
auto tools = req.get_folded_tools_list( pane, col, crafting_inv, count );
auto comps = req.get_folded_components_list( pane, col, crafting_inv, count, qry_comps );
component_print_buffer.insert( component_print_buffer.end(), tools.begin(), tools.end() );
component_print_buffer.insert( component_print_buffer.end(), comps.begin(), comps.end() );
if( !g->u.knows_recipe( current[line] ) ) {
component_print_buffer.push_back( _( "Recipe not memorized yet" ) );
auto books_with_recipe = g->u.get_books_for_recipe( crafting_inv, current[line] );
std::string enumerated_books =
enumerate_as_string( books_with_recipe.begin(), books_with_recipe.end(),
[]( itype_id type_id ) {
return item::find_type( type_id )->nname( 1 );
} );
const std::string text = string_format( _( "Written in: %s" ), enumerated_books.c_str() );
std::vector<std::string> folded_lines = foldstring( text, pane );
component_print_buffer.insert(
component_print_buffer.end(), folded_lines.begin(), folded_lines.end() );
}
//handle positioning of component list if it needed to be scrolled
int componentPrintOffset = 0;
if( display_mode > 2 ) {
componentPrintOffset = ( display_mode - 2 ) * componentPrintHeight;
}
if( component_print_buffer.size() < static_cast<size_t>( componentPrintOffset ) ) {
componentPrintOffset = 0;
if( previous_tab != tab.cur() || previous_subtab != subtab.cur() || previous_item_line != line ) {
display_mode = 2;
} else {
display_mode = 0;
}
}
//only used to preserve mode position on components when
//moving to another item and the view is already scrolled
previous_tab = tab.cur();
previous_subtab = subtab.cur();
previous_item_line = line;
const int xpos = 30;
if( display_mode == 0 ) {
const int width = getmaxx( w_data ) - xpos - item_info_x;
print_colored_text(
w_data, ypos++, xpos, col, col,
string_format( _( "Primary skill used: <color_cyan>%s</color>" ),
( !current[line]->skill_used ? _( "N/A" ) :
current[line]->skill_used.obj().name() ) ) );
auto player_skill = g->u.get_skill_level( current[line]->skill_used );
std::string difficulty_color =
current[ line ]->difficulty > player_skill ? "yellow" : "green";
print_colored_text(
w_data, ypos++, xpos, col, col,
string_format( _( "Difficulty: <color_%s>%d</color>" ),
difficulty_color, current[ line ]->difficulty ) );
std::string skill_level_string =
current[line]->skill_used ?
string_format( _( "Your skill level: <color_%s>%d</color>" ),
difficulty_color, player_skill ) :
_( "Your skill level: <color_yellow>N/A</color>" );
print_colored_text( w_data, ypos++, xpos, col, col, skill_level_string );
ypos += fold_and_print( w_data, ypos, xpos, width, col,
_( "Other skills used: %s" ),
current[line]->required_skills_string( &g->u ) );
const int expected_turns = g->u.expected_time_to_craft( *current[line],
count ) / to_moves<int>( 1_turns );
ypos += fold_and_print( w_data, ypos, xpos, pane, col,
_( "Time to complete: <color_cyan>%s</color>" ),
to_string( time_duration::from_turns( expected_turns ) ) );
print_colored_text(
w_data, ypos++, xpos, col, col,
string_format( _( "Dark craftable? <color_cyan>%s</color>" ),
current[line]->has_flag( "BLIND_EASY" ) ? _( "Easy" ) :
current[line]->has_flag( "BLIND_HARD" ) ? _( "Hard" ) :
_( "Impossible" ) ) );
ypos += print_items( *current[line], w_data, ypos, xpos, col, batch ? line + 1 : 1 );
}
//color needs to be preserved in case part of the previous page was cut off
nc_color stored_color = col;
if( display_mode > 2 ) {
stored_color = rotated_color;
} else {
rotated_color = col;
}
int components_printed = 0;
for( size_t i = static_cast<size_t>( componentPrintOffset );
i < component_print_buffer.size(); i++ ) {
if( ypos >= componentPrintHeight ) {
break;
}
components_printed++;
print_colored_text( w_data, ypos++, xpos, stored_color, col, component_print_buffer[i] );
}
if( ypos >= componentPrintHeight &&
component_print_buffer.size() > static_cast<size_t>( components_printed ) ) {
mvwprintz( w_data, ypos++, xpos, col, _( "v (more)" ) );
rotated_color = stored_color;
}
if( isWide ) {
if( last_recipe != current[line] ) {
last_recipe = current[line];
tmp = current[line]->create_result();
}
tmp.info( true, thisItem, count );
draw_item_info( w_iteminfo, tmp.tname(), tmp.type_name(), thisItem, dummy,
scroll_pos, true, true, true, false, true );
}
}
draw_scrollbar( w_data, line, dataLines, recmax, 0 );
wrefresh( w_data );
if( isWide ) {
wrefresh( w_iteminfo );
}
const std::string action = ctxt.handle_input();
if( action == "CYCLE_MODE" ) {
display_mode = display_mode + 1;
if( display_mode <= 0 ) {
display_mode = 0;
}
} else if( action == "LEFT" ) {
std::string start = subtab.cur();
do {
subtab.prev();
} while( subtab.cur() != start && available_recipes.empty_category( tab.cur(),
subtab.cur() != "CSC_ALL" ? subtab.cur() : "" ) );
redraw = true;
} else if( action == "SCROLL_UP" ) {
scroll_pos--;
} else if( action == "SCROLL_DOWN" ) {
scroll_pos++;
} else if( action == "PREV_TAB" ) {
tab.prev();
subtab = list_circularizer<std::string>( craft_subcat_list[tab.cur()] );//default ALL
redraw = true;
} else if( action == "RIGHT" ) {
std::string start = subtab.cur();
do {
subtab.next();
} while( subtab.cur() != start && available_recipes.empty_category( tab.cur(),
subtab.cur() != "CSC_ALL" ? subtab.cur() : "" ) );
redraw = true;
} else if( action == "NEXT_TAB" ) {
tab.next();
subtab = list_circularizer<std::string>( craft_subcat_list[tab.cur()] );//default ALL
redraw = true;
} else if( action == "DOWN" ) {
line++;
} else if( action == "UP" ) {
line--;
} else if( action == "CONFIRM" ) {
if( available.empty() || !available[line] ) {
popup( _( "You can't do that!" ) );
} else if( !g->u.check_eligible_containers_for_crafting( *current[line],
( batch ) ? line + 1 : 1 ) ) {
// popup is already inside check
} else {
chosen = current[line];
batch_size = ( batch ) ? line + 1 : 1;
done = true;
}
} else if( action == "HELP_RECIPE" ) {
if( current.empty() ) {
popup( _( "Nothing selected!" ) );
redraw = true;
continue;
}
tmp = current[line]->create_result();
full_screen_popup( "%s\n%s", tmp.type_name( 1 ).c_str(), tmp.info( true ).c_str() );
redraw = true;
keepline = true;
} else if( action == "FILTER" ) {
struct SearchPrefix {
char key;
std::string example;
std::string description;
};
std::vector<SearchPrefix> prefixes = {
{ 'q', _( "metal sawing" ), _( "<color_cyan>quality</color> of resulting item" ) },
//~ Example result description search term
{ 'd', _( "reach attack" ), _( "<color_cyan>full description</color> of resulting item (slow)" ) },
{ 'c', _( "two by four" ), _( "<color_cyan>component</color> required to craft" ) },
{ 'p', _( "tailoring" ), _( "<color_cyan>primary skill</color> used to craft" ) },
{ 's', _( "cooking" ), _( "<color_cyan>any skill</color> used to craft" ) },
{ 'Q', _( "fine bolt turning" ), _( "<color_cyan>quality</color> required to craft" ) },
{ 't', _( "soldering iron" ), _( "<color_cyan>tool</color> required to craft" ) },
{ 'h', _( "yes" ), _( "recipes which are <color_cyan>hidden</color> or not" ) },
{ 'm', _( "no" ), _( "recipes which are <color_cyan>memorized</color> or not" ) },
};
int max_example_length = 0;
for( const auto &prefix : prefixes ) {
max_example_length = std::max( max_example_length, utf8_width( prefix.example ) );
}
std::string spaces( max_example_length, ' ' );
std::string description =
_( "The default is to search result names. Some single-character prefixes "
"can be used with a colon (:) to search in other ways.\n"
"\n"
"<color_white>Examples:</color>\n" );
{
std::string example_name = _( "shirt" );
auto padding = max_example_length - utf8_width( example_name );
description += string_format(
_( " <color_white>%s</color>%.*s %s\n" ),
example_name, padding, spaces,
_( "<color_cyan>name</color> of resulting item" ) );
}
for( const auto &prefix : prefixes ) {
auto padding = max_example_length - utf8_width( prefix.example );
description += string_format(
_( " <color_yellow>%c</color><color_white>:%s</color>%.*s %s\n" ),
prefix.key, prefix.example, padding, spaces, prefix.description );
}
string_input_popup()
.title( _( "Search:" ) )
.width( 85 )
.description( description )
.desc_color( c_light_gray )
.edit( filterstring );
redraw = true;
} else if( action == "QUIT" ) {
chosen = nullptr;
done = true;
} else if( action == "RESET_FILTER" ) {
filterstring.clear();
redraw = true;
} else if( action == "CYCLE_BATCH" ) {
if( current.empty() ) {
popup( _( "Nothing selected!" ) );
redraw = true;
continue;
}
batch = !batch;
if( batch ) {
batch_line = line;
chosen = current[batch_line];
} else {
line = batch_line;
keepline = true;
}
redraw = true;
} else if( action == "TOGGLE_FAVORITE" ) {
keepline = true;
redraw = true;
if( current.empty() ) {
popup( _( "Nothing selected!" ) );
continue;
}
if( uistate.favorite_recipes.find( current[line]->ident() ) != uistate.favorite_recipes.end() ) {
uistate.favorite_recipes.erase( current[line]->ident() );
} else {
uistate.favorite_recipes.insert( current[line]->ident() );
}
} else if( action == "HIDE_SHOW_RECIPE" ) {
if( current.empty() ) {
popup( _( "Nothing selected!" ) );
redraw = true;
continue;
}
if( show_hidden ) {
uistate.hidden_recipes.erase( current[line]->ident() );
} else {
uistate.hidden_recipes.insert( current[line]->ident() );
}
redraw = true;
} else if( action == "RELATED_RECIPES" ) {
if( current.empty() ) {
popup( _( "Nothing selected!" ) );
redraw = true;
continue;
}
std::string recipe_name = peek_related_recipe( current[ line ], available_recipes );
if( recipe_name.empty() ) {
keepline = true;
} else {
filterstring = recipe_name;
}
redraw = true;
}
if( line < 0 ) {
line = current.size() - 1;
} else if( line >= static_cast<int>( current.size() ) ) {
line = 0;
}
} while( !done );
return chosen;
}
const recipe *select_crafting_recipe( int &batch_size )
{
if( normalized_names.empty() ) {
translate_all();
}
const int headHeight = 3;
const int subHeadHeight = 2;
const int freeWidth = TERMX - FULL_SCREEN_WIDTH;
bool isWide = ( TERMX > FULL_SCREEN_WIDTH && freeWidth > 15 );
const int width = isWide ? ( freeWidth > FULL_SCREEN_WIDTH ? FULL_SCREEN_WIDTH * 2 : TERMX ) :
FULL_SCREEN_WIDTH;
const int wStart = ( TERMX - width ) / 2;
const int tailHeight = isWide ? 3 : 4;
const int dataLines = TERMY - ( headHeight + subHeadHeight ) - tailHeight;
const int dataHalfLines = dataLines / 2;
const int dataHeight = TERMY - ( headHeight + subHeadHeight );
const int infoWidth = width - FULL_SCREEN_WIDTH - 1;
const recipe *last_recipe = nullptr;
WINDOW *w_head = newwin( headHeight, width, 0, wStart );
WINDOW_PTR w_head_ptr( w_head );
WINDOW *w_subhead = newwin( subHeadHeight, width, 3, wStart );
WINDOW_PTR w_subhead_ptr( w_subhead );
WINDOW *w_data = newwin( dataHeight, width, headHeight + subHeadHeight, wStart );
WINDOW_PTR w_data_ptr( w_data );
int item_info_x = infoWidth;
int item_info_y = dataHeight - 3;
int item_info_width = wStart + width - infoWidth;
int item_info_height = headHeight + subHeadHeight;
if( !isWide ) {
item_info_x = 1;
item_info_y = 1;
item_info_width = 1;
item_info_height = 1;
}
WINDOW *w_iteminfo = newwin( item_info_y, item_info_x, item_info_height, item_info_width );
WINDOW_PTR w_iteminfo_ptr( w_iteminfo );
list_circularizer<std::string> tab( craft_cat_list );
list_circularizer<std::string> subtab( craft_subcat_list[tab.cur()] );
std::vector<const recipe *> current;
std::vector<bool> available;
const int componentPrintHeight = dataHeight - tailHeight - 1;
//preserves component color printout between mode rotations
nc_color rotated_color = c_white;
int previous_item_line = -1;
std::string previous_tab = "";
std::string previous_subtab = "";
item tmp;
int line = 0, ypos, scroll_pos = 0;
bool redraw = true;
bool keepline = false;
bool done = false;
bool batch = false;
int batch_line = 0;
int display_mode = 0;
const recipe *chosen = NULL;
std::vector<iteminfo> thisItem, dummy;
input_context ctxt( "CRAFTING" );
ctxt.register_cardinal();
ctxt.register_action( "QUIT" );
ctxt.register_action( "CONFIRM" );
ctxt.register_action( "CYCLE_MODE" );
ctxt.register_action( "SCROLL_UP" );
ctxt.register_action( "SCROLL_DOWN" );
ctxt.register_action( "PREV_TAB" );
ctxt.register_action( "NEXT_TAB" );
ctxt.register_action( "FILTER" );
ctxt.register_action( "RESET_FILTER" );
ctxt.register_action( "HELP_RECIPE" );
ctxt.register_action( "HELP_KEYBINDINGS" );
ctxt.register_action( "CYCLE_BATCH" );
const inventory &crafting_inv = g->u.crafting_inventory();
const std::vector<npc *> helpers = g->u.get_crafting_helpers();
std::string filterstring = "";
do {
if( redraw ) {
// When we switch tabs, redraw the header
redraw = false;
if( ! keepline ) {
line = 0;
} else {
keepline = false;
}
if( display_mode > 2 ) {
display_mode = 2;
}
TAB_MODE m = ( batch ) ? BATCH : ( filterstring == "" ) ? NORMAL : FILTERED;
draw_recipe_tabs( w_head, tab.cur(), m );
draw_recipe_subtabs( w_subhead, tab.cur(), subtab.cur(), m );
current.clear();
available.clear();
if( batch ) {
batch_recipes( crafting_inv, helpers, current, available, chosen );
} else {
// Set current to all recipes in the current tab; available are possible to make
pick_recipes( crafting_inv, helpers, current, available,
tab.cur(), subtab.cur(), filterstring );
}
}
// Clear the screen of recipe data, and draw it anew
werase( w_data );
if( isWide ) {
werase( w_iteminfo );
}
if( isWide ) {
mvwprintz( w_data, dataLines + 1, 5, c_white,
_( "Press <ENTER> to attempt to craft object." ) );
wprintz( w_data, c_white, " " );
if( filterstring != "" ) {
wprintz( w_data, c_white, _( "[E]: Describe, [F]ind, [R]eset, [m]ode, %s [?] keybindings" ),
( batch ) ? _( "cancel [b]atch" ) : _( "[b]atch" ) );
} else {
wprintz( w_data, c_white, _( "[E]: Describe, [F]ind, [m]ode, %s [?] keybindings" ),
( batch ) ? _( "cancel [b]atch" ) : _( "[b]atch" ) );
}
} else {
if( filterstring != "" ) {
mvwprintz( w_data, dataLines + 1, 5, c_white,
_( "[E]: Describe, [F]ind, [R]eset, [m]ode, [b]atch [?] keybindings" ) );
} else {
mvwprintz( w_data, dataLines + 1, 5, c_white,
_( "[E]: Describe, [F]ind, [m]ode, [b]atch [?] keybindings" ) );
}
mvwprintz( w_data, dataLines + 2, 5, c_white,
_( "Press <ENTER> to attempt to craft object." ) );
}
// Draw borders
for( int i = 1; i < width - 1; ++i ) { // _
mvwputch( w_data, dataHeight - 1, i, BORDER_COLOR, LINE_OXOX );
}
for( int i = 0; i < dataHeight - 1; ++i ) { // |
mvwputch( w_data, i, 0, BORDER_COLOR, LINE_XOXO );
mvwputch( w_data, i, width - 1, BORDER_COLOR, LINE_XOXO );
}
mvwputch( w_data, dataHeight - 1, 0, BORDER_COLOR, LINE_XXOO ); // _|
mvwputch( w_data, dataHeight - 1, width - 1, BORDER_COLOR, LINE_XOOX ); // |_
int recmin = 0, recmax = current.size();
if( recmax > dataLines ) {
if( line <= recmin + dataHalfLines ) {
for( int i = recmin; i < recmin + dataLines; ++i ) {
std::string tmp_name = item::nname( current[i]->result );
if( batch ) {
tmp_name = string_format( _( "%2dx %s" ), i + 1, tmp_name.c_str() );
}
mvwprintz( w_data, i - recmin, 2, c_dkgray, "" ); // Clear the line
if( i == line ) {
mvwprintz( w_data, i - recmin, 2, ( available[i] ? h_white : h_dkgray ),
utf8_truncate( tmp_name, 28 ).c_str() );
} else {
mvwprintz( w_data, i - recmin, 2, ( available[i] ? c_white : c_dkgray ),
utf8_truncate( tmp_name, 28 ).c_str() );
}
}
} else if( line >= recmax - dataHalfLines ) {
for( int i = recmax - dataLines; i < recmax; ++i ) {
std::string tmp_name = item::nname( current[i]->result );
if( batch ) {
tmp_name = string_format( _( "%2dx %s" ), i + 1, tmp_name.c_str() );
}
mvwprintz( w_data, dataLines + i - recmax, 2, c_ltgray, "" ); // Clear the line
if( i == line ) {
mvwprintz( w_data, dataLines + i - recmax, 2,
( available[i] ? h_white : h_dkgray ),
utf8_truncate( tmp_name, 28 ).c_str() );
} else {
mvwprintz( w_data, dataLines + i - recmax, 2,
( available[i] ? c_white : c_dkgray ),
utf8_truncate( tmp_name, 28 ).c_str() );
}
}
} else {
for( int i = line - dataHalfLines; i < line - dataHalfLines + dataLines; ++i ) {
std::string tmp_name = item::nname( current[i]->result );
if( batch ) {
tmp_name = string_format( _( "%2dx %s" ), i + 1, tmp_name.c_str() );
}
mvwprintz( w_data, dataHalfLines + i - line, 2, c_ltgray, "" ); // Clear the line
if( i == line ) {
mvwprintz( w_data, dataHalfLines + i - line, 2,
( available[i] ? h_white : h_dkgray ),
utf8_truncate( tmp_name, 28 ).c_str() );
} else {
mvwprintz( w_data, dataHalfLines + i - line, 2,
( available[i] ? c_white : c_dkgray ),
utf8_truncate( tmp_name, 28 ).c_str() );
}
}
}
} else {
for( size_t i = 0; i < current.size() && i < ( size_t )dataHeight + 1; ++i ) {
std::string tmp_name = item::nname( current[i]->result );
if( batch ) {
tmp_name = string_format( _( "%2dx %s" ), ( int )i + 1, tmp_name.c_str() );
}
if( ( int )i == line ) {
mvwprintz( w_data, i, 2, ( available[i] ? h_white : h_dkgray ),
utf8_truncate( tmp_name, 28 ).c_str() );
} else {
mvwprintz( w_data, i, 2, ( available[i] ? c_white : c_dkgray ),
utf8_truncate( tmp_name, 28 ).c_str() );
}
}
}
if( !current.empty() ) {
int pane = FULL_SCREEN_WIDTH - 30 - 1;
int count = batch ? line + 1 : 1; // batch size
nc_color col = available[ line ] ? c_white : c_ltgray;
const auto &req = current[ line ]->requirements();
draw_can_craft_indicator( w_head, 0, *current[line] );
wrefresh( w_head );
ypos = 0;
std::vector<std::string> component_print_buffer;
auto tools = req.get_folded_tools_list( pane, col, crafting_inv, count );
auto comps = req.get_folded_components_list( pane, col, crafting_inv, count );
component_print_buffer.insert( component_print_buffer.end(), tools.begin(), tools.end() );
component_print_buffer.insert( component_print_buffer.end(), comps.begin(), comps.end() );
if( !g->u.knows_recipe( current[line] ) ) {
component_print_buffer.push_back( _( "Recipe not memorized yet" ) );
}
//handle positioning of component list if it needed to be scrolled
int componentPrintOffset = 0;
if( display_mode > 2 ) {
componentPrintOffset = ( display_mode - 2 ) * componentPrintHeight;
}
if( component_print_buffer.size() < static_cast<size_t>( componentPrintOffset ) ) {
componentPrintOffset = 0;
if( previous_tab != tab.cur() || previous_subtab != subtab.cur() || previous_item_line != line ) {
display_mode = 2;
} else {
display_mode = 0;
}
}
//only used to preserve mode position on components when
//moving to another item and the view is already scrolled
previous_tab = tab.cur();
previous_subtab = subtab.cur();
previous_item_line = line;
if( display_mode == 0 ) {
mvwprintz( w_data, ypos++, 30, col, _( "Skills used: %s" ),
( !current[line]->skill_used ? _( "N/A" ) :
current[line]->skill_used.obj().name().c_str() ) );
mvwprintz( w_data, ypos++, 30, col, _( "Required skills: %s" ),
( current[line]->required_skills_string().c_str() ) );
mvwprintz( w_data, ypos++, 30, col, _( "Difficulty: %d" ), current[line]->difficulty );
if( !current[line]->skill_used ) {
mvwprintz( w_data, ypos++, 30, col, _( "Your skill level: N/A" ) );
} else {
mvwprintz( w_data, ypos++, 30, col, _( "Your skill level: %d" ),
// Macs don't seem to like passing this as a class, so force it to int
( int )g->u.get_skill_level( current[line]->skill_used ) );
}
ypos += current[line]->print_time( w_data, ypos, 30, pane, col, count );
mvwprintz( w_data, ypos++, 30, col, _( "Dark craftable? %s" ),
current[line]->has_flag( "BLIND_EASY" ) ? _( "Easy" ) :
current[line]->has_flag( "BLIND_HARD" ) ? _( "Hard" ) :
_( "Impossible" ) );
ypos += current[line]->print_items( w_data, ypos, 30, col, ( batch ) ? line + 1 : 1 );
}
//color needs to be preserved in case part of the previous page was cut off
nc_color stored_color = col;
if( display_mode > 2 ) {
stored_color = rotated_color;
} else {
rotated_color = col;
}
int components_printed = 0;
for( size_t i = static_cast<size_t>( componentPrintOffset );
i < component_print_buffer.size(); i++ ) {
if( ypos >= componentPrintHeight ) {
break;
}
components_printed++;
print_colored_text( w_data, ypos++, 30, stored_color, col, component_print_buffer[i] );
}
if( ypos >= componentPrintHeight &&
component_print_buffer.size() > static_cast<size_t>( components_printed ) ) {
mvwprintz( w_data, ypos++, 30, col, _( "v (more)" ) );
rotated_color = stored_color;
}
if( isWide ) {
if( last_recipe != current[line] ) {
last_recipe = current[line];
tmp = current[line]->create_result();
tmp.info( true, thisItem );
}
draw_item_info( w_iteminfo, tmp.tname(), tmp.type_name(), thisItem, dummy,
scroll_pos, true, true, true, false, true );
}
}
draw_scrollbar( w_data, line, dataLines, recmax, 0 );
wrefresh( w_data );
if( isWide ) {
wrefresh( w_iteminfo );
}
const std::string action = ctxt.handle_input();
if( action == "CYCLE_MODE" ) {
display_mode = display_mode + 1;
if( display_mode <= 0 ) {
display_mode = 0;
}
} else if( action == "LEFT" ) {
subtab.prev();
redraw = true;
} else if( action == "SCROLL_UP" ) {
scroll_pos--;
} else if( action == "SCROLL_DOWN" ) {
scroll_pos++;
} else if( action == "PREV_TAB" ) {
tab.prev();
subtab = list_circularizer<std::string>( craft_subcat_list[tab.cur()] );//default ALL
redraw = true;
} else if( action == "RIGHT" ) {
subtab.next();
redraw = true;
} else if( action == "NEXT_TAB" ) {
tab.next();
subtab = list_circularizer<std::string>( craft_subcat_list[tab.cur()] );//default ALL
redraw = true;
} else if( action == "DOWN" ) {
line++;
} else if( action == "UP" ) {
line--;
} else if( action == "CONFIRM" ) {
if( available.empty() || !available[line] ) {
popup( _( "You can't do that!" ) );
} else if( !current[line]->check_eligible_containers_for_crafting( ( batch ) ? line + 1 : 1 ) ) {
; // popup is already inside check
} else {
chosen = current[line];
batch_size = ( batch ) ? line + 1 : 1;
done = true;
}
} else if( action == "HELP_RECIPE" ) {
if( current.empty() ) {
popup( _( "Nothing selected!" ) );
redraw = true;
continue;
}
tmp = current[line]->create_result();
full_screen_popup( "%s\n%s", tmp.type_name( 1 ).c_str(), tmp.info( true ).c_str() );
redraw = true;
keepline = true;
} else if( action == "FILTER" ) {
filterstring = string_input_popup( _( "Search:" ), 85, filterstring,
_( "Special prefixes for requirements:\n"
" [t] search tools\n"
" [c] search components\n"
" [q] search qualities\n"
" [s] search skills\n"
" [S] search skill used only\n"
"Special prefixes for results:\n"
" [Q] search qualities\n"
"Examples:\n"
" t:soldering iron\n"
" c:two by four\n"
" q:metal sawing\n"
" s:cooking\n"
" Q:fine bolt turning"
) );
redraw = true;
} else if( action == "QUIT" ) {
chosen = nullptr;
done = true;
} else if( action == "RESET_FILTER" ) {
filterstring = "";
redraw = true;
} else if( action == "CYCLE_BATCH" ) {
if( current.empty() ) {
popup( _( "Nothing selected!" ) );
redraw = true;
continue;
}
batch = !batch;
if( batch ) {
batch_line = line;
chosen = current[batch_line];
} else {
line = batch_line;
keepline = true;
}
redraw = true;
}
if( line < 0 ) {
line = current.size() - 1;
} else if( line >= ( int )current.size() ) {
line = 0;
}
} while( !done );
return chosen;
}
string strip_empty_characters(string str, size_t max_length) {
static const char *space_characters[] = {u8"\u1680", u8"\u180E", u8"\u2000", u8"\u2001", u8"\u2002",
u8"\u2003", u8"\u2004", u8"\u2005", u8"\u2006", u8"\u2007",
u8"\u2008", u8"\u2009", u8"\u200A", u8"\u200B", u8"\u202F",
u8"\u205F", u8"\u3000", u8"\uFEFF", u8"\uFFFC"};
static bool can_be_first[std::numeric_limits<unsigned char>::max() + 1];
static bool can_be_first_inited = [&] {
for (auto space_ch : space_characters) {
CHECK(std::strlen(space_ch) == 3);
can_be_first[static_cast<unsigned char>(space_ch[0])] = true;
}
return true;
}();
CHECK(can_be_first_inited);
// replace all occurences of space characters with a space
size_t i = 0;
while (i < str.size() && !can_be_first[static_cast<unsigned char>(str[i])]) {
i++;
}
size_t new_len = i;
while (i < str.size()) {
if (can_be_first[static_cast<unsigned char>(str[i])] && i + 3 <= str.size()) {
bool found = false;
for (auto space_ch : space_characters) {
if (space_ch[0] == str[i] && space_ch[1] == str[i + 1] && space_ch[2] == str[i + 2]) {
found = true;
break;
}
}
if (found) {
str[new_len++] = ' ';
i += 3;
continue;
}
}
str[new_len++] = str[i++];
}
Slice trimmed = trim(utf8_truncate(trim(Slice(str.c_str(), new_len)), max_length));
// check if there is some non-empty character, empty characters:
// "\xE2\x80\x8C", ZERO WIDTH NON-JOINER
// "\xE2\x80\x8D", ZERO WIDTH JOINER
// "\xE2\x80\xAE", RIGHT-TO-LEFT OVERRIDE
// "\xC2\xA0", NO-BREAK SPACE
for (i = 0;;) {
if (i == trimmed.size()) {
// if all characters are empty, return an empty string
return string();
}
if (static_cast<unsigned char>(trimmed[i]) == 0xE2 && static_cast<unsigned char>(trimmed[i + 1]) == 0x80 &&
(static_cast<unsigned char>(trimmed[i + 2]) == 0x8C || static_cast<unsigned char>(trimmed[i + 2]) == 0x8D ||
static_cast<unsigned char>(trimmed[i + 2]) == 0xAE)) {
i += 3;
continue;
}
if (static_cast<unsigned char>(trimmed[i]) == 0xC2 && static_cast<unsigned char>(trimmed[i + 1]) == 0xA0) {
i += 2;
continue;
}
break;
}
return trimmed.str();
}
/**
* Determine unique filename for `file' in `path', with optional trailing
* extension `ext'. If no `ext' is wanted, one must supply an empty string.
*
* @param path A directory path.
* @param file The basename for the resulting pathname.
* @param ext An optional filename extension to be appended to the basename.
* @param name_is_uniq An optional callback to decide whether a created
* pathname is uniq. If omitted, the default is file_does_not_exist().
*
* @returns the chosen unique complete filename as a pointer which must be
* freed via hfree().
*/
char *
filename_unique(const char *path, const char *name, const char *ext,
bool (*name_is_uniq)(const char *pathname))
{
char filename_buf[FILENAME_MAXBYTES];
char name_buf[FILENAME_MAXBYTES];
char mid_buf[32];
char ext_buf[32];
const char *mid;
char *pathname;
size_t name_len, mid_len, ext_len;
int i;
g_assert(path);
g_assert(name);
g_assert(ext);
g_assert(is_absolute_path(path));
STATIC_ASSERT(sizeof filename_buf >
sizeof mid_buf + sizeof ext_buf + GUID_HEX_SIZE);
/**
* NOTE: The generated filename must not exceed FILENAME_MAXBYTES
* because such a file cannot be created. In reality, it depends
* on the filesystem as well and the limit might be even smaller.
* In any case, we don't want to cut-off arbitrary bytes but
* at least preserve the filename extension and the (potential)
* UTF-8 encoding.
*/
/* Because "ext" can be an additional extension like .BAD rather than
* one that indicates the filetype, try to preserve the next "extension"
* as well, if there's any. */
mid = strrchr(name, '.');
if (NULL == mid || mid == name || strlen(mid) >= sizeof mid_buf) {
mid = strchr(name, '\0');
}
ext_len = strlen(ext);
mid_len = strlen(mid);
name_len = strlen(name) - mid_len;
ext_len = MIN(ext_len, sizeof ext_buf - 1);
mid_len = MIN(mid_len, sizeof mid_buf - 1);
name_len = MIN(name_len, sizeof name_buf - 1);
if (name_len + mid_len + ext_len >= sizeof filename_buf) {
g_assert(name_len >= ext_len);
name_len -= ext_len;
}
/* Truncate strings so that an UTF-8 encoding is preserved */
ext_len = utf8_truncate(ext, ext_buf, ext_len + 1);
mid_len = utf8_truncate(mid, mid_buf, mid_len + 1);
name_len = utf8_truncate(name, name_buf, name_len + 1);
str_bprintf(filename_buf, sizeof filename_buf, "%s%s%s",
name_buf, mid_buf, ext_buf);
pathname = unique_pathname(path, filename_buf, name_is_uniq);
if (pathname)
goto finish;
if (!is_directory(path))
return NULL;
/*
* Looks like we need to make the filename more unique. Append .00, then
* .01, etc... until .99.
*/
while (name_len + mid_len + ext_len + 3 >= sizeof filename_buf) {
g_assert(name_len > 0);
name_len--;
}
name_len = utf8_truncate(name, name_buf, name_len + 1);
for (i = 0; i < 100; i++) {
str_bprintf(filename_buf, sizeof filename_buf, "%s.%02u%s%s",
name_buf, i, mid_buf, ext_buf);
pathname = unique_pathname(path, filename_buf, name_is_uniq);
if (pathname)
goto finish;
}
/*
* OK, no luck. Try with a few random numbers then.
*/
while (name_len + mid_len + ext_len + 9 >= sizeof filename_buf) {
g_assert(name_len > 0);
name_len--;
}
name_len = utf8_truncate(name, name_buf, name_len + 1);
for (i = 0; i < 100; i++) {
str_bprintf(filename_buf, sizeof filename_buf, "%s.%x%s%s",
name_buf, (unsigned) random_u32(), mid_buf, ext_buf);
pathname = unique_pathname(path, filename_buf, name_is_uniq);
if (pathname)
goto finish;
}
/*
* Bad luck. Allocate a random GUID then.
*/
while (
name_len + mid_len + ext_len + GUID_HEX_SIZE + 1 >= sizeof filename_buf
) {
g_assert(name_len > 0);
name_len--;
}
name_len = utf8_truncate(name, name_buf, name_len + 1);
{
struct guid guid;
guid_random_fill(&guid);
str_bprintf(filename_buf, sizeof filename_buf, "%s.%s%s%s",
name_buf, guid_hex_str(&guid), mid_buf, ext_buf);
}
pathname = unique_pathname(path, filename_buf, name_is_uniq);
if (pathname)
goto finish;
/*
* This may also be the result of permission problems or inode
* exhaustion.
*/
g_warning("%s(): no luck with random number generator", G_STRFUNC);
finish:
return pathname;
}
const recipe *select_crafting_recipe( int &batch_size )
{
if( normalized_names.empty() ) {
translate_all();
}
const int headHeight = 3;
const int subHeadHeight = 2;
const int freeWidth = TERMX - FULL_SCREEN_WIDTH;
bool isWide = ( TERMX > FULL_SCREEN_WIDTH && freeWidth > 15 );
const int width = isWide ? ( freeWidth > FULL_SCREEN_WIDTH ? FULL_SCREEN_WIDTH * 2 : TERMX ) :
FULL_SCREEN_WIDTH;
const int wStart = ( TERMX - width ) / 2;
const int tailHeight = isWide ? 3 : 4;
const int dataLines = TERMY - ( headHeight + subHeadHeight ) - tailHeight;
const int dataHalfLines = dataLines / 2;
const int dataHeight = TERMY - ( headHeight + subHeadHeight );
const int infoWidth = width - FULL_SCREEN_WIDTH - 1;
const recipe *last_recipe = nullptr;
catacurses::window w_head = catacurses::newwin( headHeight, width, 0, wStart );
catacurses::window w_subhead = catacurses::newwin( subHeadHeight, width, 3, wStart );
catacurses::window w_data = catacurses::newwin( dataHeight, width, headHeight + subHeadHeight,
wStart );
int item_info_x = infoWidth;
int item_info_y = dataHeight - 3;
int item_info_width = wStart + width - infoWidth;
int item_info_height = headHeight + subHeadHeight;
if( !isWide ) {
item_info_x = 1;
item_info_y = 1;
item_info_width = 1;
item_info_height = 1;
}
catacurses::window w_iteminfo = catacurses::newwin( item_info_y, item_info_x, item_info_height,
item_info_width );
list_circularizer<std::string> tab( craft_cat_list );
list_circularizer<std::string> subtab( craft_subcat_list[tab.cur()] );
std::vector<const recipe *> current;
std::vector<bool> available;
const int componentPrintHeight = dataHeight - tailHeight - 1;
//preserves component color printout between mode rotations
nc_color rotated_color = c_white;
int previous_item_line = -1;
std::string previous_tab = "";
std::string previous_subtab = "";
item tmp;
int line = 0, ypos, scroll_pos = 0;
bool redraw = true;
bool keepline = false;
bool done = false;
bool batch = false;
int batch_line = 0;
int display_mode = 0;
const recipe *chosen = NULL;
std::vector<iteminfo> thisItem, dummy;
input_context ctxt( "CRAFTING" );
ctxt.register_cardinal();
ctxt.register_action( "QUIT" );
ctxt.register_action( "CONFIRM" );
ctxt.register_action( "CYCLE_MODE" );
ctxt.register_action( "SCROLL_UP" );
ctxt.register_action( "SCROLL_DOWN" );
ctxt.register_action( "PREV_TAB" );
ctxt.register_action( "NEXT_TAB" );
ctxt.register_action( "FILTER" );
ctxt.register_action( "RESET_FILTER" );
ctxt.register_action( "HELP_RECIPE" );
ctxt.register_action( "HELP_KEYBINDINGS" );
ctxt.register_action( "CYCLE_BATCH" );
const inventory &crafting_inv = g->u.crafting_inventory();
const std::vector<npc *> helpers = g->u.get_crafting_helpers();
std::string filterstring = "";
const auto &available_recipes = g->u.get_available_recipes( crafting_inv, &helpers );
std::map<const recipe *, bool> availability_cache;
do {
if( redraw ) {
// When we switch tabs, redraw the header
redraw = false;
if( ! keepline ) {
line = 0;
} else {
keepline = false;
}
if( display_mode > 2 ) {
display_mode = 2;
}
TAB_MODE m = ( batch ) ? BATCH : ( filterstring.empty() ) ? NORMAL : FILTERED;
draw_recipe_tabs( w_head, tab.cur(), m );
draw_recipe_subtabs( w_subhead, tab.cur(), subtab.cur(), available_recipes, m );
available.clear();
if( batch ) {
current.clear();
for( int i = 1; i <= 20; i++ ) {
current.push_back( chosen );
available.push_back( chosen->requirements().can_make_with_inventory( crafting_inv, i ) );
}
} else {
if( filterstring.empty() ) {
current = available_recipes.in_category( tab.cur(), subtab.cur() != "CSC_ALL" ? subtab.cur() : "" );
} else {
auto qry = trim( filterstring );
if( qry.size() > 2 && qry[1] == ':' ) {
switch( qry[0] ) {
case 't':
current = available_recipes.search( qry.substr( 2 ), recipe_subset::search_type::tool );
break;
case 'c':
current = available_recipes.search( qry.substr( 2 ), recipe_subset::search_type::component );
break;
case 's':
current = available_recipes.search( qry.substr( 2 ), recipe_subset::search_type::skill );
break;
case 'q':
current = available_recipes.search( qry.substr( 2 ), recipe_subset::search_type::quality );
break;
case 'Q':
current = available_recipes.search( qry.substr( 2 ), recipe_subset::search_type::quality_result );
break;
case 'm': {
auto &learned = g->u.get_learned_recipes();
current.clear();
if( ( qry.substr( 2 ) == "yes" ) || ( qry.substr( 2 ) == "y" ) || ( qry.substr( 2 ) == "1" ) ||
( qry.substr( 2 ) == "true" ) || ( qry.substr( 2 ) == "t" ) || ( qry.substr( 2 ) == "on" ) ) {
std::set_intersection( available_recipes.begin(), available_recipes.end(), learned.begin(),
learned.end(), std::back_inserter( current ) );
} else {
std::set_difference( available_recipes.begin(), available_recipes.end(), learned.begin(),
learned.end(),
std::back_inserter( current ) );
}
}
break;
default:
current.clear();
}
} else {
current = available_recipes.search( qry );
}
}
available.reserve( current.size() );
// cache recipe availability on first display
for( const auto e : current ) {
if( !availability_cache.count( e ) ) {
availability_cache.emplace( e, e->requirements().can_make_with_inventory( crafting_inv ) );
}
}
std::stable_sort( current.begin(), current.end(), []( const recipe * a, const recipe * b ) {
return b->difficulty < a->difficulty;
} );
std::stable_sort( current.begin(), current.end(), [&]( const recipe * a, const recipe * b ) {
return availability_cache[a] && !availability_cache[b];
} );
std::transform( current.begin(), current.end(),
std::back_inserter( available ), [&]( const recipe * e ) {
return availability_cache[e];
} );
}
// current/available have been rebuilt, make sure our cursor is still in range
if( current.empty() ) {
line = 0;
} else {
line = std::min( line, ( int )current.size() - 1 );
}
}
// Clear the screen of recipe data, and draw it anew
werase( w_data );
if( isWide ) {
werase( w_iteminfo );
}
if( isWide ) {
mvwprintz( w_data, dataLines + 1, 5, c_white,
_( "Press <ENTER> to attempt to craft object." ) );
wprintz( w_data, c_white, " " );
if( !filterstring.empty() ) {
wprintz( w_data, c_white, _( "[E]: Describe, [F]ind, [R]eset, [m]ode, %s [?] keybindings" ),
( batch ) ? _( "cancel [b]atch" ) : _( "[b]atch" ) );
} else {
wprintz( w_data, c_white, _( "[E]: Describe, [F]ind, [m]ode, %s [?] keybindings" ),
( batch ) ? _( "cancel [b]atch" ) : _( "[b]atch" ) );
}
} else {
if( !filterstring.empty() ) {
mvwprintz( w_data, dataLines + 1, 5, c_white,
_( "[E]: Describe, [F]ind, [R]eset, [m]ode, [b]atch [?] keybindings" ) );
} else {
mvwprintz( w_data, dataLines + 1, 5, c_white,
_( "[E]: Describe, [F]ind, [m]ode, [b]atch [?] keybindings" ) );
}
mvwprintz( w_data, dataLines + 2, 5, c_white,
_( "Press <ENTER> to attempt to craft object." ) );
}
// Draw borders
for( int i = 1; i < width - 1; ++i ) { // _
mvwputch( w_data, dataHeight - 1, i, BORDER_COLOR, LINE_OXOX );
}
for( int i = 0; i < dataHeight - 1; ++i ) { // |
mvwputch( w_data, i, 0, BORDER_COLOR, LINE_XOXO );
mvwputch( w_data, i, width - 1, BORDER_COLOR, LINE_XOXO );
}
mvwputch( w_data, dataHeight - 1, 0, BORDER_COLOR, LINE_XXOO ); // _|
mvwputch( w_data, dataHeight - 1, width - 1, BORDER_COLOR, LINE_XOOX ); // |_
int recmin = 0, recmax = current.size();
if( recmax > dataLines ) {
if( line <= recmin + dataHalfLines ) {
for( int i = recmin; i < recmin + dataLines; ++i ) {
std::string tmp_name = current[i]->result_name();
if( batch ) {
tmp_name = string_format( _( "%2dx %s" ), i + 1, tmp_name.c_str() );
}
mvwprintz( w_data, i - recmin, 2, c_dark_gray, "" ); // Clear the line
if( i == line ) {
mvwprintz( w_data, i - recmin, 2, ( available[i] ? h_white : h_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
} else {
mvwprintz( w_data, i - recmin, 2, ( available[i] ? c_white : c_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
}
}
} else if( line >= recmax - dataHalfLines ) {
for( int i = recmax - dataLines; i < recmax; ++i ) {
std::string tmp_name = current[i]->result_name();
if( batch ) {
tmp_name = string_format( _( "%2dx %s" ), i + 1, tmp_name.c_str() );
}
mvwprintz( w_data, dataLines + i - recmax, 2, c_light_gray, "" ); // Clear the line
if( i == line ) {
mvwprintz( w_data, dataLines + i - recmax, 2,
( available[i] ? h_white : h_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
} else {
mvwprintz( w_data, dataLines + i - recmax, 2,
( available[i] ? c_white : c_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
}
}
} else {
for( int i = line - dataHalfLines; i < line - dataHalfLines + dataLines; ++i ) {
std::string tmp_name = current[i]->result_name();
if( batch ) {
tmp_name = string_format( _( "%2dx %s" ), i + 1, tmp_name.c_str() );
}
mvwprintz( w_data, dataHalfLines + i - line, 2, c_light_gray, "" ); // Clear the line
if( i == line ) {
mvwprintz( w_data, dataHalfLines + i - line, 2,
( available[i] ? h_white : h_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
} else {
mvwprintz( w_data, dataHalfLines + i - line, 2,
( available[i] ? c_white : c_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
}
}
}
} else {
for( size_t i = 0; i < current.size() && i < ( size_t )dataHeight + 1; ++i ) {
std::string tmp_name = current[i]->result_name();
if( batch ) {
tmp_name = string_format( _( "%2dx %s" ), ( int )i + 1, tmp_name.c_str() );
}
if( ( int )i == line ) {
mvwprintz( w_data, i, 2, ( available[i] ? h_white : h_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
} else {
mvwprintz( w_data, i, 2, ( available[i] ? c_white : c_dark_gray ),
utf8_truncate( tmp_name, 28 ).c_str() );
}
}
}
if( !current.empty() ) {
int pane = FULL_SCREEN_WIDTH - 30 - 1;
int count = batch ? line + 1 : 1; // batch size
nc_color col = available[ line ] ? c_white : c_light_gray;
const auto &req = current[ line ]->requirements();
draw_can_craft_indicator( w_head, 0, *current[line] );
wrefresh( w_head );
ypos = 0;
auto qry = trim( filterstring );
std::string qry_comps;
if( qry.compare( 0, 2, "c:" ) == 0 ) {
qry_comps = qry.substr( 2 );
}
std::vector<std::string> component_print_buffer;
auto tools = req.get_folded_tools_list( pane, col, crafting_inv, count );
auto comps = req.get_folded_components_list( pane, col, crafting_inv, count, qry_comps );
component_print_buffer.insert( component_print_buffer.end(), tools.begin(), tools.end() );
component_print_buffer.insert( component_print_buffer.end(), comps.begin(), comps.end() );
if( !g->u.knows_recipe( current[line] ) ) {
component_print_buffer.push_back( _( "Recipe not memorized yet" ) );
auto books_with_recipe = g->u.get_books_for_recipe( crafting_inv, current[line] );
std::string enumerated_books =
enumerate_as_string( books_with_recipe.begin(), books_with_recipe.end(),
[]( itype_id type_id ) {
return item::find_type( type_id )->nname( 1 );
} );
const std::string text = string_format( _( "Written in: %s" ), enumerated_books.c_str() );
std::vector<std::string> folded_lines = foldstring( text, pane );
component_print_buffer.insert(
component_print_buffer.end(), folded_lines.begin(), folded_lines.end() );
}
//handle positioning of component list if it needed to be scrolled
int componentPrintOffset = 0;
if( display_mode > 2 ) {
componentPrintOffset = ( display_mode - 2 ) * componentPrintHeight;
}
if( component_print_buffer.size() < static_cast<size_t>( componentPrintOffset ) ) {
componentPrintOffset = 0;
if( previous_tab != tab.cur() || previous_subtab != subtab.cur() || previous_item_line != line ) {
display_mode = 2;
} else {
display_mode = 0;
}
}
//only used to preserve mode position on components when
//moving to another item and the view is already scrolled
previous_tab = tab.cur();
previous_subtab = subtab.cur();
previous_item_line = line;
const int xpos = 30;
if( display_mode == 0 ) {
const int width = getmaxx( w_data ) - xpos - item_info_x;
mvwprintz( w_data, ypos++, xpos, col, _( "Skills used: %s" ),
( !current[line]->skill_used ? _( "N/A" ) :
current[line]->skill_used.obj().name().c_str() ) );
ypos += fold_and_print( w_data, ypos, xpos, width, col, _( "Required skills: %s" ),
current[line]->required_skills_string().c_str() );
mvwprintz( w_data, ypos++, xpos, col, _( "Difficulty: %d" ),
current[ line ]->difficulty );
if( !current[line]->skill_used ) {
mvwprintz( w_data, ypos++, xpos, col, _( "Your skill level: N/A" ) );
} else {
mvwprintz( w_data, ypos++, xpos, col, _( "Your skill level: %d" ),
g->u.get_skill_level( current[line]->skill_used ) );
}
const int expected_turns = g->u.expected_time_to_craft( *current[line], count ) / MOVES( 1 );
ypos += fold_and_print( w_data, ypos, xpos, pane, col, _( "Time to complete: %s" ),
to_string( time_duration::from_turns( expected_turns ) ) );
mvwprintz( w_data, ypos++, xpos, col, _( "Dark craftable? %s" ),
current[line]->has_flag( "BLIND_EASY" ) ? _( "Easy" ) :
current[line]->has_flag( "BLIND_HARD" ) ? _( "Hard" ) :
_( "Impossible" ) );
ypos += print_items( *current[line], w_data, ypos, xpos, col, batch ? line + 1 : 1 );
}
//color needs to be preserved in case part of the previous page was cut off
nc_color stored_color = col;
if( display_mode > 2 ) {
stored_color = rotated_color;
} else {
rotated_color = col;
}
int components_printed = 0;
for( size_t i = static_cast<size_t>( componentPrintOffset );
i < component_print_buffer.size(); i++ ) {
if( ypos >= componentPrintHeight ) {
break;
}
components_printed++;
print_colored_text( w_data, ypos++, xpos, stored_color, col, component_print_buffer[i] );
}
if( ypos >= componentPrintHeight &&
component_print_buffer.size() > static_cast<size_t>( components_printed ) ) {
mvwprintz( w_data, ypos++, xpos, col, _( "v (more)" ) );
rotated_color = stored_color;
}
if( isWide ) {
if( last_recipe != current[line] ) {
last_recipe = current[line];
tmp = current[line]->create_result();
}
tmp.info( true, thisItem, count );
draw_item_info( w_iteminfo, tmp.tname(), tmp.type_name(), thisItem, dummy,
scroll_pos, true, true, true, false, true );
}
}
draw_scrollbar( w_data, line, dataLines, recmax, 0 );
wrefresh( w_data );
if( isWide ) {
wrefresh( w_iteminfo );
}
const std::string action = ctxt.handle_input();
if( action == "CYCLE_MODE" ) {
display_mode = display_mode + 1;
if( display_mode <= 0 ) {
display_mode = 0;
}
} else if( action == "LEFT" ) {
std::string start = subtab.cur();
do {
subtab.prev();
} while( subtab.cur() != start && available_recipes.empty_category( tab.cur(),
subtab.cur() != "CSC_ALL" ? subtab.cur() : "" ) );
redraw = true;
} else if( action == "SCROLL_UP" ) {
scroll_pos--;
} else if( action == "SCROLL_DOWN" ) {
scroll_pos++;
} else if( action == "PREV_TAB" ) {
tab.prev();
subtab = list_circularizer<std::string>( craft_subcat_list[tab.cur()] );//default ALL
redraw = true;
} else if( action == "RIGHT" ) {
std::string start = subtab.cur();
do {
subtab.next();
} while( subtab.cur() != start && available_recipes.empty_category( tab.cur(),
subtab.cur() != "CSC_ALL" ? subtab.cur() : "" ) );
redraw = true;
} else if( action == "NEXT_TAB" ) {
tab.next();
subtab = list_circularizer<std::string>( craft_subcat_list[tab.cur()] );//default ALL
redraw = true;
} else if( action == "DOWN" ) {
line++;
} else if( action == "UP" ) {
line--;
} else if( action == "CONFIRM" ) {
if( available.empty() || !available[line] ) {
popup( _( "You can't do that!" ) );
} else if( !g->u.check_eligible_containers_for_crafting( *current[line],
( batch ) ? line + 1 : 1 ) ) {
; // popup is already inside check
} else {
chosen = current[line];
batch_size = ( batch ) ? line + 1 : 1;
done = true;
}
} else if( action == "HELP_RECIPE" ) {
if( current.empty() ) {
popup( _( "Nothing selected!" ) );
redraw = true;
continue;
}
tmp = current[line]->create_result();
full_screen_popup( "%s\n%s", tmp.type_name( 1 ).c_str(), tmp.info( true ).c_str() );
redraw = true;
keepline = true;
} else if( action == "FILTER" ) {
string_input_popup()
.title( _( "Search:" ) )
.width( 85 )
.description( _( "Special prefixes for requirements:\n"
" [t] search tools\n"
" [c] search components\n"
" [q] search qualities\n"
" [s] search skills\n"
"Special prefixes for results:\n"
" [Q] search qualities\n"
"Other:\n"
" [m] search for memorized or not\n"
"Examples:\n"
" t:soldering iron\n"
" c:two by four\n"
" q:metal sawing\n"
" s:cooking\n"
" Q:fine bolt turning\n"
" m:no"
) )
.edit( filterstring );
redraw = true;
} else if( action == "QUIT" ) {
chosen = nullptr;
done = true;
} else if( action == "RESET_FILTER" ) {
filterstring.clear();
redraw = true;
} else if( action == "CYCLE_BATCH" ) {
if( current.empty() ) {
popup( _( "Nothing selected!" ) );
redraw = true;
continue;
}
batch = !batch;
if( batch ) {
batch_line = line;
chosen = current[batch_line];
} else {
line = batch_line;
keepline = true;
}
redraw = true;
}
if( line < 0 ) {
line = current.size() - 1;
} else if( line >= ( int )current.size() ) {
line = 0;
}
} while( !done );
return chosen;
}
