示例#1
0
void menu_redraw_full (MUTTMENU * menu)
{
  SETCOLOR (MT_COLOR_NORMAL);
  /* clear() doesn't optimize screen redraws */
  move (0, 0);
  clrtobot ();

  if (option (OPTHELP)) {
    SETCOLOR (MT_COLOR_STATUS);
    move (option (OPTSTATUSONTOP) ? LINES - 2 : 0, SW);
    mutt_paddstr (COLS-SW, menu->help);
    SETCOLOR (MT_COLOR_NORMAL);
    menu->offset = 1;
    menu->pagelen = LINES - 3;
  }
  else {
    menu->offset = option (OPTSTATUSONTOP) ? 1 : 0;
    menu->pagelen = LINES - 2;
  }

  sidebar_draw_frames();

  mutt_show_error ();

  menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
}
static void draw_envelope (HEADER *msg, char *fcc)
{
  draw_envelope_addr (HDR_FROM, msg->env->from);
  draw_envelope_addr (HDR_TO, msg->env->to);
  draw_envelope_addr (HDR_CC, msg->env->cc);
  draw_envelope_addr (HDR_BCC, msg->env->bcc);
  mvprintw (HDR_SUBJECT, 0, TITLE_FMT "%-*.*s", Prompts[HDR_SUBJECT - 1], W, W,
	    NONULL(msg->env->subject));
  draw_envelope_addr (HDR_REPLYTO, msg->env->reply_to);
  mvprintw (HDR_FCC, 0, TITLE_FMT "%-*.*s", Prompts[HDR_FCC - 1], W, W, fcc);



#ifdef HAVE_PGP
  redraw_pgp_lines (msg->pgp);
#endif /* HAVE_PGP */

#ifdef MIXMASTER
  redraw_mix_line (msg->chain);
#endif

  SETCOLOR (MT_COLOR_STATUS);
  mvaddstr (HDR_ATTACH - 1, 0, _("-- Attachments"));
  BKGDSET (MT_COLOR_STATUS);
  clrtoeol ();

  BKGDSET (MT_COLOR_NORMAL);
  SETCOLOR (MT_COLOR_NORMAL);
}
示例#3
0
void menu_redraw_current (MUTTMENU * menu)
{
  char buf[STRING];

  move (menu->current + menu->offset - menu->top, SW);
  menu_make_entry (buf, sizeof (buf), menu, menu->current);
  menu_pad_string (buf, sizeof (buf));

  if (option (OPTARROWCURSOR)) {
    int attr = menu->color (menu->current);

    attrset (attr);
    clrtoeol ();
    attrset (menu->color (menu->current));
    ADDCOLOR (MT_COLOR_INDICATOR);
    addstr ("->");
    attrset (attr);
    addch (' ');
    menu_pad_string (buf, sizeof (buf));
    print_enriched_string (menu->color (menu->current), (unsigned char *) buf,
                           1);
    SETCOLOR (MT_COLOR_NORMAL);
  }
  else {
    attrset (menu->color (menu->current));
    ADDCOLOR (MT_COLOR_INDICATOR);
    BKGDSET (MT_COLOR_INDICATOR);
    clrtoeol ();
    print_enriched_string (menu->color (menu->current), (unsigned char *) buf,
                           0);
    SETCOLOR (MT_COLOR_NORMAL);
    BKGDSET (MT_COLOR_NORMAL);
  }
  menu->redraw &= REDRAW_STATUS;
}
示例#4
0
void menu_redraw_motion (MUTTMENU * menu)
{
  char buf[STRING];

  if (menu->dialog) {
    menu->redraw &= ~REDRAW_MOTION;
    return;
  }

  move (menu->oldcurrent + menu->offset - menu->top, SW);
  SETCOLOR (MT_COLOR_NORMAL);
  BKGDSET (MT_COLOR_NORMAL);

  if (option (OPTARROWCURSOR)) {
    /* clear the pointer */
    attrset (menu->color (menu->oldcurrent));
    addstr ("  ");

    if (menu->redraw & REDRAW_MOTION_RESYNCH) {
      clrtoeol ();
      menu_make_entry (buf, sizeof (buf), menu, menu->oldcurrent);
      menu_pad_string (buf, sizeof (buf));
      move (menu->oldcurrent + menu->offset - menu->top, SW + 3);
      print_enriched_string (menu->color (menu->oldcurrent),
                             (unsigned char *) buf, 1);
      SETCOLOR (MT_COLOR_NORMAL);
    }

    /* now draw it in the new location */
    move (menu->current + menu->offset - menu->top, SW);
    attrset (menu->color (menu->current));
    ADDCOLOR (MT_COLOR_INDICATOR);
    addstr ("->");
    SETCOLOR (MT_COLOR_NORMAL);
  }
  else {
    /* erase the current indicator */
    attrset (menu->color (menu->oldcurrent));
    clrtoeol ();
    menu_make_entry (buf, sizeof (buf), menu, menu->oldcurrent);
    menu_pad_string (buf, sizeof (buf));
    print_enriched_string (menu->color (menu->oldcurrent),
                           (unsigned char *) buf, 1);

    /* now draw the new one to reflect the change */
    menu_make_entry (buf, sizeof (buf), menu, menu->current);
    menu_pad_string (buf, sizeof (buf));
    attrset (menu->color (menu->current));
    ADDCOLOR (MT_COLOR_INDICATOR);
    BKGDSET (MT_COLOR_INDICATOR);
    CLEARLINE_WIN (menu->current - menu->top + menu->offset);
    move (menu->current + menu->offset - menu->top, SW);
    print_enriched_string (menu->color (menu->current), (unsigned char *) buf,
                           0);
    SETCOLOR (MT_COLOR_NORMAL);
    BKGDSET (MT_COLOR_NORMAL);
  }
  menu->redraw &= REDRAW_STATUS;
}
示例#5
0
void menu_redraw_index (MUTTMENU * menu)
{
  char buf[STRING];
  int i;

  for (i = menu->top; i < menu->top + menu->pagelen; i++) {
    if (i < menu->max) {
      menu_make_entry (buf, sizeof (buf), menu, i);
      menu_pad_string (buf, sizeof (buf));

      if (option (OPTARROWCURSOR)) {
        attrset (menu->color (i));
        CLEARLINE_WIN (i - menu->top + menu->offset);

        if (i == menu->current) {
          attrset (menu->color (i));
          ADDCOLOR (MT_COLOR_INDICATOR);
          BKGDSET (MT_COLOR_INDICATOR);
          addstr ("->");
          attrset (menu->color (i));
          addch (' ');
        }
        else {
          attrset (menu->color (i));
          move (i - menu->top + menu->offset, SW);
          addstr ("   ");
        }

        print_enriched_string (menu->color (i), (unsigned char *) buf, 1);
        SETCOLOR (MT_COLOR_NORMAL);
        BKGDSET (MT_COLOR_NORMAL);
      }
      else {
        attrset (menu->color (i));

        if (i == menu->current) {
          ADDCOLOR (MT_COLOR_INDICATOR);
          BKGDSET (MT_COLOR_INDICATOR);
        }

        CLEARLINE_WIN (i - menu->top + menu->offset);

        move (i - menu->top + menu->offset, SW);
        print_enriched_string (menu->color (i), (unsigned char *) buf,
                               i != menu->current);
        SETCOLOR (MT_COLOR_NORMAL);
        BKGDSET (MT_COLOR_NORMAL);
      }
    }
    else
      CLEARLINE_WIN (i - menu->top + menu->offset);
  }
  sidebar_draw (1);
/*  sidebar_draw_frames(); */

  menu->redraw = 0;
}
void mutt_show_error (void)
{
  if (option (OPTKEEPQUIET))
    return;
  
  SETCOLOR (option (OPTMSGERR) ? MT_COLOR_ERROR : MT_COLOR_MESSAGE);
  CLEARLINE (LINES-1);
  addstr (Errorbuf);
  SETCOLOR (MT_COLOR_NORMAL);
}
BOOL CBasicCPU5Regs::OnInitDialog()
   {
    CLeaves::OnInitDialog();

    ColorSet colors(TRUE);

    POSITION p = colors.GetFirstColorPosition();

    SETCOLOR(LargestMonitorLineSize);
    SETCOLOR(SmallestMonitorLineSize);
    SETRESERVEDCOLOR(Reserved1);
    SETRESERVEDCOLOR(Reserved2);
    SETRESERVEDCOLOR(Reserved3);
    SETCOLOR(InterruptsAsBreakEvents);
    SETCOLOR(MWAITEnumerationSupported);

    SETCOLOR(C0);
    SETCOLOR(C1);
    SETCOLOR(C2);
    SETCOLOR(C3);
    SETCOLOR(C4);
    SETRESERVEDCOLOR(Reserved4);

    return TRUE;  // return TRUE unless you set the focus to a control
                  // EXCEPTION: OCX Property Pages should return FALSE
   }
示例#8
0
void menu_redraw_status (MUTTMENU * menu)
{
  char buf[STRING];

  snprintf (buf, sizeof (buf), M_MODEFMT, menu->title);
  SETCOLOR (MT_COLOR_STATUS);
  move (option (OPTSTATUSONTOP) ? 0 : LINES - 2, SW);
  mutt_paddstr (COLS-SW, buf);
  SETCOLOR (MT_COLOR_NORMAL);
  menu->redraw &= ~REDRAW_STATUS;
  sidebar_draw_frames();
}
示例#9
0
文件: progress.c 项目: darnir/neomutt
/**
 * message_bar - Draw a colourful progress bar
 * @param percent %age complete
 * @param fmt     printf(1)-like formatting string
 * @param ...     Arguments to formatting string
 */
static void message_bar(int percent, const char *fmt, ...)
{
  va_list ap;
  char buf[256], buf2[256];
  int w = percent * COLS / 100;
  size_t l;

  va_start(ap, fmt);
  vsnprintf(buf, sizeof(buf), fmt, ap);
  l = mutt_strwidth(buf);
  va_end(ap);

  mutt_simple_format(buf2, sizeof(buf2), 0, COLS - 2, FMT_LEFT, 0, buf, sizeof(buf), 0);

  move(LINES - 1, 0);

  if (ColorDefs[MT_COLOR_PROGRESS] == 0)
  {
    addstr(buf2);
  }
  else
  {
    if (l < w)
    {
      /* The string fits within the colour bar */
      SETCOLOR(MT_COLOR_PROGRESS);
      addstr(buf2);
      w -= l;
      while (w-- > 0)
      {
        addch(' ');
      }
      NORMAL_COLOR;
    }
    else
    {
      /* The string is too long for the colour bar */
      char ch;
      int off = mutt_wstr_trunc(buf2, sizeof(buf2), w, NULL);

      ch = buf2[off];
      buf2[off] = '\0';
      SETCOLOR(MT_COLOR_PROGRESS);
      addstr(buf2);
      buf2[off] = ch;
      NORMAL_COLOR;
      addstr(&buf2[off]);
    }
  }

  clrtoeol();
  mutt_refresh();
}
示例#10
0
static void draw_envelope (HEADER *msg, char *fcc)
{
  draw_envelope_addr (HDR_FROM, msg->env->from);
  draw_envelope_addr (HDR_TO, msg->env->to);
  draw_envelope_addr (HDR_CC, msg->env->cc);
  draw_envelope_addr (HDR_BCC, msg->env->bcc);
  mvprintw (HDR_SUBJECT, 0, TITLE_FMT, Prompts[HDR_SUBJECT - 1]);
  mutt_paddstr (W, NONULL (msg->env->subject));
  draw_envelope_addr (HDR_REPLYTO, msg->env->reply_to);
  mvprintw (HDR_FCC, 0, TITLE_FMT, Prompts[HDR_FCC - 1]);
  mutt_paddstr (W, fcc);

  if (WithCrypto)
    redraw_crypt_lines (msg);

#ifdef MIXMASTER
  redraw_mix_line (msg->chain);
#endif

  SETCOLOR (MT_COLOR_STATUS);
  mvaddstr (HDR_ATTACH - 1, 0, _("-- Attachments"));
  clrtoeol ();

  NORMAL_COLOR;
}
示例#11
0
文件: curs_lib.c 项目: darnir/neomutt
/**
 * mutt_get_field_full - Ask the user for a string
 * @param[in]  field    Prompt
 * @param[in]  buf      Buffer for the result
 * @param[in]  buflen   Length of buffer
 * @param[in]  complete Flags, see #CompletionFlags
 * @param[in]  multiple Allow multiple selections
 * @param[out] files    List of files selected
 * @param[out] numfiles Number of files selected
 * @retval 1  Redraw the screen and call the function again
 * @retval 0  Selection made
 * @retval -1 Aborted
 */
int mutt_get_field_full(const char *field, char *buf, size_t buflen, CompletionFlags complete,
                        bool multiple, char ***files, int *numfiles)
{
  int ret;
  int x;

  struct EnterState *es = mutt_enter_state_new();

  do
  {
    if (SigWinch)
    {
      SigWinch = 0;
      mutt_resize_screen();
      clearok(stdscr, TRUE);
      mutt_menu_current_redraw();
    }
    mutt_window_clearline(MuttMessageWindow, 0);
    SETCOLOR(MT_COLOR_PROMPT);
    addstr(field);
    NORMAL_COLOR;
    mutt_refresh();
    mutt_window_getxy(MuttMessageWindow, &x, NULL);
    ret = mutt_enter_string_full(buf, buflen, x, complete, multiple, files, numfiles, es);
  } while (ret == 1);
  mutt_window_clearline(MuttMessageWindow, 0);
  mutt_enter_state_free(&es);

  return ret;
}
示例#12
0
文件: remailer.c 项目: aschrab/mutt
static void mix_redraw_ce (REMAILER **type2_list,
			   struct coord *coords,
			   MIXCHAIN *chain,
			   int i,
			   short selected)
{
  if (!coords || !chain)
    return;
  
  if (coords[i].r < MIX_MAXROW)
  {
    
    if (selected)
      SETCOLOR (MT_COLOR_INDICATOR);
    else
      NORMAL_COLOR;
    
    mutt_window_mvaddstr (MuttIndexWindow, coords[i].r, coords[i].c,
                          type2_list[chain->ch[i]]->shortname);
    NORMAL_COLOR;

    if (i + 1 < chain->cl)
      addstr (", ");
  }
}
示例#13
0
文件: remailer.c 项目: aschrab/mutt
static void mix_redraw_head (MIXCHAIN *chain)
{
  SETCOLOR (MT_COLOR_STATUS);
  mutt_window_mvprintw (MuttIndexWindow, MIX_VOFFSET - 1, 0,
                        "-- Remailer chain [Length: %d]", chain ? chain->cl : 0);
  mutt_window_clrtoeol (MuttIndexWindow);
  NORMAL_COLOR;
}
BOOL CExtendedCPU1AMD::OnInitDialog()
   {
    CLeaves::OnInitDialog();

    ColorSet colors(TRUE);

    POSITION p;
    p = colors.GetFirstColorPosition();

    // ECX
    SETCOLOR(LAHF_SAHF);                // 0
    SETCOLOR(CmpLegacy);                // 1
    SETCOLOR(SVM);                      // 2
    SETRESERVEDCOLOR(Reserved6);        // 3
    SETCOLOR(AltMovCr8);                // 4
    SETRESERVEDCOLOR(Reserved5);        // 31..1

    // EDX
    SETRESERVEDCOLOR(Reserved1);        // 10..0
    SETCOLOR(SYSCALL_SYSRET);           // 11
    SETRESERVEDCOLOR(Reserved2);        // 19..12
    SETCOLOR(ExecuteDisable);           // 20
    SETRESERVEDCOLOR(Reserved3);        // 28..21
    SETCOLOR(LM);                       // 29
    SETRESERVEDCOLOR(Reserved4);        // 31..30

    SetFixedFont(c_EAX);
    SetFixedFont(c_EBX);

    return TRUE;  // return TRUE unless you set the focus to a control
                  // EXCEPTION: OCX Property Pages should return FALSE
   }
/******************************** TRIAL LOOP ************************************

	This code sequences trials within a block  It calls run_trial() to 
	execute a trial, then interperts result code. It places a result message 
	in the EDF file. This example allows trials to be repeated from 
	the tracker ABORT menu. 
 ********************************************************************************/
int run_trials(void)
{
  int i;
  int trial;
  
  SETCOLOR(target_foreground_color,0,0,0);       /* set background for calibration */
  SETCOLOR(target_background_color,255,255,255); /* This should match the display */
  set_calibration_colors(&target_foreground_color, &target_background_color); 
        
  /* PERFORM CAMERA SETUP, CALIBRATION */
  do_tracker_setup();
				
  /* loop through trials */
  for(trial=1;trial<=NTRIALS;trial++)
    {
      if(eyelink_is_connected()==0 || break_pressed())    /* drop out if link closed */
		{
			return ABORT_EXPT;
		}
		/* RUN THE TRIAL */
		i = do_simple_trial(trial);
		end_realtime_mode();          /* safety: make sure realtime mode stopped */

		switch(i)         	/* REPORT ANY ERRORS */
		{
		case ABORT_EXPT:        /* handle experiment abort or disconnect */
			eyemsg_printf("EXPERIMENT ABORTED");
			return ABORT_EXPT;
		case REPEAT_TRIAL:	  /* trial restart requested */
			eyemsg_printf("TRIAL REPEATED");
			trial--;
			break;
		case SKIP_TRIAL:	  /* skip trial */
			eyemsg_printf("TRIAL ABORTED");
			break;
		case TRIAL_OK:          /* successful trial */
		    eyemsg_printf("TRIAL OK");
		    break;
		default:                /* other error code */
		    eyemsg_printf("TRIAL ERROR");
			break;
		}
    }  /* END OF TRIAL LOOP */
  return 0;
}
BOOL CExtendedCPU5EAXAMD::OnInitDialog()
   {
    CExtendedCPU5AMD::OnInitDialog();

    c_Caption.SetWindowText(_T(""));

    ColorSet colors(TRUE);

    POSITION p;
    p = colors.GetFirstColorPosition();
    SETCOLOR(7_0);
    SETCOLOR(15_8);
    SETCOLOR(23_16);
    SETCOLOR(31_24);

    return TRUE;  // return TRUE unless you set the focus to a control
                  // EXCEPTION: OCX Property Pages should return FALSE
   }
示例#17
0
文件: curs_lib.c 项目: darnir/neomutt
/**
 * mutt_show_error - Show the user an error message
 */
void mutt_show_error(void)
{
  if (OptKeepQuiet || !ErrorBufMessage)
    return;

  SETCOLOR(OptMsgErr ? MT_COLOR_ERROR : MT_COLOR_MESSAGE);
  mutt_window_mvaddstr(MuttMessageWindow, 0, 0, ErrorBuf);
  NORMAL_COLOR;
  mutt_window_clrtoeol(MuttMessageWindow);
}
BOOL CExtendedCPU6Intel::OnInitDialog()
   {
    CLeaves::OnInitDialog();

    ColorSet colors(TRUE);

    POSITION p;
    p = colors.GetFirstColorPosition();
    SETCOLOR(LineSize);                 // 7..0
    SETRESERVEDCOLOR(Reserved1);        // 11..8
    SETCOLOR(Associativity);            // 15..12
    SETCOLOR(CacheSize);                // 31..16

    SetFixedFont(c_EAX);
    SetFixedFont(c_EBX);
    SetFixedFont(c_EDX);

    return TRUE;  // return TRUE unless you set the focus to a control
                  // EXCEPTION: OCX Property Pages should return FALSE
   }
示例#19
0
文件: curs_lib.c 项目: darnir/neomutt
/**
 * mutt_enter_fname_full - Ask the user to select a file
 * @param[in]  prompt   Prompt
 * @param[in]  buf      Buffer for the result
 * @param[in]  buflen   Length of the buffer
 * @param[in]  mailbox  If true, select mailboxes
 * @param[in]  multiple Allow multiple selections
 * @param[out] files    List of files selected
 * @param[out] numfiles Number of files selected
 * @param[in]  flags    Flags, see #SelectFileFlags
 * @retval  0 Success
 * @retval -1 Error
 */
int mutt_enter_fname_full(const char *prompt, char *buf, size_t buflen, bool mailbox,
                          bool multiple, char ***files, int *numfiles, SelectFileFlags flags)
{
  struct Event ch;

  SETCOLOR(MT_COLOR_PROMPT);
  mutt_window_mvaddstr(MuttMessageWindow, 0, 0, (char *) prompt);
  addstr(_(" ('?' for list): "));
  NORMAL_COLOR;
  if (buf[0] != '\0')
    addstr(buf);
  mutt_window_clrtoeol(MuttMessageWindow);
  mutt_refresh();

  do
  {
    ch = mutt_getch();
  } while (ch.ch == -2);
  if (ch.ch < 0)
  {
    mutt_window_clearline(MuttMessageWindow, 0);
    return -1;
  }
  else if (ch.ch == '?')
  {
    mutt_refresh();
    buf[0] = '\0';

    if (!flags)
      flags = MUTT_SEL_FOLDER;
    if (multiple)
      flags |= MUTT_SEL_MULTI;
    if (mailbox)
      flags |= MUTT_SEL_MAILBOX;
    mutt_select_file(buf, buflen, flags, files, numfiles);
  }
  else
  {
    char *pc = mutt_mem_malloc(mutt_str_strlen(prompt) + 3);

    sprintf(pc, "%s: ", prompt);
    mutt_unget_event(ch.op ? 0 : ch.ch, ch.op ? ch.op : 0);
    if (mutt_get_field_full(pc, buf, buflen, (mailbox ? MUTT_EFILE : MUTT_FILE) | MUTT_CLEAR,
                            multiple, files, numfiles) != 0)
    {
      buf[0] = '\0';
    }
    FREE(&pc);
  }

  return 0;
}
void mutt_message (const char *fmt, ...)
{
  va_list ap;

  va_start (ap, fmt);
  vsnprintf (Errorbuf, sizeof (Errorbuf), fmt, ap);
  va_end (ap);

  Errorbuf[ (COLS < sizeof (Errorbuf) ? COLS : sizeof (Errorbuf)) - 2 ] = 0;
  clean_error_buf();

  if (!option (OPTKEEPQUIET))
  {
    SETCOLOR (MT_COLOR_MESSAGE);
    mvaddstr (LINES - 1, 0, Errorbuf);
    clrtoeol ();
    SETCOLOR (MT_COLOR_NORMAL);
    mutt_refresh ();
  }

  unset_option (OPTMSGERR);
}
void mutt_curses_error (const char *fmt, ...)
{
  va_list ap;

  va_start (ap, fmt);
  vsnprintf (Errorbuf, sizeof (Errorbuf), fmt, ap);
  va_end (ap);
  
  dprint (1, (debugfile, "%s\n", Errorbuf));
  Errorbuf[ (COLS < sizeof (Errorbuf) ? COLS : sizeof (Errorbuf)) - 2 ] = 0;
  clean_error_buf();

  if (!option (OPTKEEPQUIET))
  {
    BEEP ();
    SETCOLOR (MT_COLOR_ERROR);
    mvaddstr (LINES-1, 0, Errorbuf);
    clrtoeol ();
    SETCOLOR (MT_COLOR_NORMAL);
    mutt_refresh ();
  }

  set_option (OPTMSGERR);
}
示例#22
0
void menu_redraw_prompt (MUTTMENU * menu)
{
  if (menu->dialog) {
    if (option (OPTMSGERR)) {
      mutt_sleep (1);
      unset_option (OPTMSGERR);
    }

    if (*Errorbuf)
      mutt_clear_error ();

    SETCOLOR (MT_COLOR_NORMAL);
    mvaddstr (LINES - 1, 0, menu->prompt);
    clrtoeol ();
  }
}
示例#23
0
void loadColors()
{
	memset(colors, 0, sizeof colors);
	SETCOLOR(AIR, 255,255,255,0);
	SETCOLORNOISE(STONE, 128,128,128,255, 16);
	SETCOLORNOISE(GRASS, 102,142,62,255, 14);
	SETCOLORNOISE(DIRT, 134,96,67,255, 22);
	SETCOLORNOISE(COBBLESTONE, 115,115,115,255, 24);
	SETCOLORNOISE(WOOD, 157,128,79,255, 11);
	SETCOLOR(6, 120,120,120,0);
	SETCOLOR(7, 84,84,84,255);
	SETCOLOR(WATER, 38,92,225,36);
	SETCOLOR(STAT_WATER, 38,92,225,36);
	SETCOLOR(10, 255,90,0,255);
	SETCOLOR(11, 255,90,0,255);
	SETCOLORNOISE(SAND, 220,212,160,255, 14);
	SETCOLORNOISE(GRAVEL, 136,126,126,255, 24);
	SETCOLOR(14, 143,140,125,255);
	SETCOLOR(15, 136,130,127,255);
	SETCOLOR(16, 115,115,115,255);
	SETCOLOR(LOG, 102,81,51,255);
	SETCOLORNOISE(LEAVES, 54,135,40,180, 12);
	SETCOLOR(20, 255,255,255,40); //glass
	SETCOLORNOISE(21, 102, 112, 134, 255, 10);
	SETCOLORNOISE(22, 29, 71, 165, 255, 5);
	SETCOLOR(23, 107, 107, 107, 255);
	SETCOLORNOISE(SANDSTONE, 218, 210, 158, 255, 7);
	SETCOLORNOISE(25, 100, 67, 50, 255, 10);
	SETCOLOR(BED, 175,116,116, 254); // Not fully opaque to prevent culling on this one
	SETCOLOR(POW_RAILROAD, 160,134,72,250);
	SETCOLOR(DET_RAILROAD, 120,114,92,250);
	SETCOLOR(29, 106,102,95,255);
	SETCOLOR(COBWEB, 220,220,220,190);
	SETCOLORNOISE(TALL_GRASS, 110,166,68,254, 12);
	SETCOLORNOISE(SHRUB, 123,79,25,254, 25);
	SETCOLOR(33, 106,102,95,255);
	SETCOLOR(34, 153,129,89,255);
	SETCOLOR(WOOL, 222,222,222,255); //Color(143,143,143,255);
	//SETCOLOR(36, 222,222,222,255);
	SETCOLOR(FLOWERR, 255,0,0,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(FLOWERY, 255,255,0,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(MUSHROOMB, 128,100,0,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(MUSHROOMR, 140,12,12,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(41, 231,165,45,255);
	SETCOLOR(42, 191,191,191,255);
	SETCOLOR(DOUBLESTEP, 200,200,200,255);
	SETCOLOR(STEP, 200,200,200,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(UP_STEP, 200,200,200,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(45, 170,86,62,255);
	SETCOLOR(BRICKSTEP, 170,86,62,254);
	SETCOLOR(UP_BRICKSTEP, 170,86,62,254);
	SETCOLOR(46, 160,83,65,255);
	SETCOLORNOISE(48, 90,108,90,255, 27);
	SETCOLOR(49, 26,11,43,255);
	SETCOLOR(TORCH, 245,220,50,200);
	SETCOLOR(FIRE, 255,170,30,200);
	SETCOLOR(52, 20,170,200,255);
	SETCOLOR(53, 157,128,79,255);
	SETCOLOR(54, 125,91,38,255);
	SETCOLOR(REDWIRE, 200,10,10,200);
	SETCOLOR(56, 129,140,143,255);
	SETCOLOR(57, 45,166,152,255);
	SETCOLOR(58, 114,88,56,255);
	SETCOLOR(59, 146,192,0,255);
	SETCOLOR(60, 95,58,30,255);
	SETCOLOR(61, 96,96,96,255);
	SETCOLOR(62, 96,96,96,255);
	SETCOLOR(63, 111,91,54,255);
	SETCOLOR(64, 136,109,67,255);
	SETCOLOR(65, 181,140,64,32);
	SETCOLOR(RAILROAD, 140,134,72,250);
	SETCOLOR(67, 115,115,115,255);
	SETCOLOR(71, 191,191,191,255);
	SETCOLOR(73, 131,107,107,255);
	SETCOLOR(74, 131,107,107,255);
	SETCOLOR(REDTORCH_OFF, 181,100,44,254);
	SETCOLOR(REDTORCH_ON, 255,0,0,254);
	SETCOLORNOISE(SNOW, 245,246,245,254, 13); // Not fully opaque to prevent culling on this one
	SETCOLORNOISE(79, 125,173,255,159, 7);
	SETCOLOR(80, 250,250,250,255);
	SETCOLOR(81, 25,120,25,255);
	SETCOLOR(82, 151,157,169,255);
	SETCOLOR(83, 183,234,150,255);
	SETCOLOR(84, 100,67,50,255);
	SETCOLOR(FENCE, 137,112,65,225); // Not fully opaque to prevent culling on this one
	SETCOLOR(86, 197,120,23,255);
	SETCOLORNOISE(87, 110,53,51,255, 16);
	SETCOLORNOISE(88, 84,64,51,255, 7);
	SETCOLORNOISE(89, 137,112,64,255, 11);
	SETCOLOR(90, 0,42,255,127);
	SETCOLOR(91, 185,133,28,255);
	SETCOLORNOISE(CAKE, 228, 205, 206, 255, 7);
	SETCOLORNOISE(93, 151,147,147, 255, 2);
	SETCOLORNOISE(94, 161,147,147, 255, 2);
	SETCOLOR(95, 125,91,38,255);
	SETCOLORNOISE(TRAPDOOR, 126,93,45,240, 5);
	SETCOLORNOISE(97, 128,128,128,255, 16);
	SETCOLORNOISE(98, 122,122,122,255, 7);
	SETCOLORNOISE(STONEBRICKSTEP, 122,122,122,254, 7);
	SETCOLORNOISE(UP_STONEBRICKSTEP, 122,122,122,254, 7);
	SETCOLORNOISE(99, 141,106,83,255, 0);
	SETCOLORNOISE(100, 182,37,36,255, 6);
	SETCOLORNOISE(IRON_BARS, 109,108,106,254, 6);
	SETCOLOR(102, 255,255,255,40);
	SETCOLORNOISE(103, 151,153,36,255, 10);
	SETCOLOR(PUMPKIN_STEM, 115,170,73,254);
	SETCOLOR(MELON_STEM, 115,170,73,254);
	SETCOLORNOISE(VINES, 51,130,36,180, 12);
	SETCOLOR(FENCE_GATE, 137,112,65,225);
	SETCOLOR(108, 170,86,62,255);
	SETCOLORNOISE(109, 122,122,122,255, 7);
	SETCOLORNOISE(MYCELIUM, 140,115,119,255, 14);
	SETCOLOR(LILYPAD, 85,124,60,254); 
	SETCOLORNOISE(NETHER_BRICK, 54,24,30,255, 7);
	SETCOLOR(NETHER_BRICK_FENCE, 54,24,30,225);
	SETCOLOR(NETHER_BRICK_STAIRS, 54,24,30,255);
	SETCOLOR(NETHER_WART, 112,8,28,254);
	SETCOLORNOISE(116, 103,64,59,255, 6);
	SETCOLORNOISE(117, 124,103,81,255, 25);
	SETCOLOR(118, 55,55,55,255);
	SETCOLOR(119, 18,16,27,127);
	SETCOLORNOISE(120, 89,117,96,255, 6);
	SETCOLORNOISE(121, 221,223,165,255, 3);
	SETCOLOR(122, 20,18,29,255);
	SETCOLORNOISE(123, 70,43,26,255, 2);
	SETCOLORNOISE(124, 119,89,55,255, 7);
	SETCOLORNOISE(WOODEN_DOUBLE_STEP, 156,127,78,255, 11);
	SETCOLORNOISE(WOODEN_STEP, 156,127,78,254, 11);
	SETCOLOR(COCOA_PLANT, 145,80,30,200);
	SETCOLORNOISE(128, 218,210,158,255, 15);
	SETCOLORNOISE(129, 109,128,116,255, 18);
	SETCOLORNOISE(130, 18,16,27,255, 5);
	SETCOLORNOISE(131, 138,129,113,255, 28);
	SETCOLORNOISE(132, 129,129,129,107, 25);
	SETCOLOR(133, 81,217,117,255);
	SETCOLORNOISE(134, 103,77,46,255, 1);
	SETCOLORNOISE(135, 195,179,123,255, 3);
	SETCOLORNOISE(136, 154,110,77,255, 2);
	
	SETCOLORNOISE(PINELEAVES, 44,84,44,160, 20); // Pine leaves
	SETCOLORNOISE(BIRCHLEAVES, 85,124,60,170, 11); // Birch leaves
	SETCOLORNOISE(JUNGLELEAVES, 44,135,50,175, 11); // Birch leaves
	SETCOLORNOISE(SANDSTEP, 218, 210, 158, 254, 7); // Not fully opaque to prevent culling on this one
	SETCOLORNOISE(UP_SANDSTEP, 218, 210, 158, 254, 7); // Not fully opaque to prevent culling on this one
	SETCOLORNOISE(WOODSTEP, 157,128,79,254, 11); // Not fully opaque to prevent culling on this one
	SETCOLORNOISE(UP_WOODSTEP, 157,128,79,254, 11); // Not fully opaque to prevent culling on this one
	SETCOLORNOISE(COBBLESTEP, 115,115,115,254, 26); // Not fully opaque to prevent culling on this one
	SETCOLORNOISE(UP_COBBLESTEP, 115,115,115,254, 26); // Not fully opaque to prevent culling on this one

	SETCOLORNOISE(PINESTEP, 103,77,46,254, 1);
	SETCOLORNOISE(BIRCHSTEP, 195,179,123,254, 3);
	SETCOLORNOISE(JUNGLESTEP, 154,110,77,254, 2);
	
	SETCOLORNOISE(UP_WOODSTEP2, 157,128,79,254, 11);
	SETCOLORNOISE(UP_PINESTEP, 103,77,46,255, 1);
	SETCOLORNOISE(UP_BIRCHSTEP, 195,179,123,255, 3);
	SETCOLORNOISE(UP_JUNGLESTEP, 154,110,77,255, 2);
	
	SETCOLORNOISE(226, 103,77,46,255, 1);
	SETCOLORNOISE(227, 195,179,123,255, 3);
	SETCOLORNOISE(228, 154,110,77,255, 2);
	
	SETCOLOR(237, 70,50,32, 255); // Pine trunk
	SETCOLORNOISE(238, 206,206,201, 255, 5); // Birch trunk
	SETCOLOR(239, 122,91,51, 255); // Jungle trunk
	SETCOLOR(240, 244,137,54, 255); // Dyed wool
	SETCOLOR(241, 200,75,210,255);
	SETCOLOR(242, 120,158,241, 255);
	SETCOLOR(243, 204,200,28, 255);
	SETCOLOR(244, 59,210,47, 255);
	SETCOLOR(245, 237,141,164, 255);
	SETCOLOR(246, 76,76,76, 255);
	SETCOLOR(247, 168,172,172, 255);
	SETCOLOR(248, 39,116,149, 255);
	SETCOLOR(249, 133,53,195, 255);
	SETCOLOR(250, 38,51,160, 255);
	SETCOLOR(251, 85,51,27, 255);
	SETCOLOR(252, 55,77,24, 255);
	SETCOLOR(253, 173,44,40, 255);
	SETCOLOR(254, 32,27,27, 255);
	
	//1.3.1+ various
	SETCOLOR(133, 61, 255, 61, 255  ); //emerald
	SETCOLOR(137, 203, 163, 136, 255 ); //command block
	SETCOLOR(138, 21, 255, 255, 255 ); //beacon
	SETCOLORNOISE(139,    128,   128,   128,   255,   16); // cobblestone wall
	SETCOLOR(145, 110, 110, 110, 255 ); //anvil
	SETCOLOR(146, 125,    91,    38,   255   ); //trapped chest
	SETCOLOR(151, 187, 158, 109, 255 ); //daylight sensor
	SETCOLOR(152, 227,  38,  12, 255 ); //redstone block
	SETCOLOR(154, 110, 110, 110, 255 ); //hopper
	SETCOLOR(155, 240, 238, 232, 255 ); //quartz
	SETCOLOR(156, 240, 238, 232, 255 ); //quartz stairs
	SETCOLOR(207, 240, 238, 232, 255 ); //quartz slab
	//SETCOLOR(159, 209, 177, 160, 255 ); //white stained clay !
	SETCOLOR(161, 54, 135, 40, 180 ); //leaves Acacia/Dark Oak
	SETCOLOR(162, 72,  72, 72, 255 ); //log Acacia/Dark Oak
	SETCOLORNOISE(163, 154, 110, 77, 255, 2); // Acacia Wood Stairs
	SETCOLORNOISE(164, 106, 127, 98, 255, 11); // Dark Oak Wood Stairs
	SETCOLOR(170, 172, 145, 18,  255 ); //haystack
	SETCOLOR(171, 224, 224, 224, 255 ); //white carpet
	SETCOLOR(172, 184, 126, 99, 255 ); //hardened clay
	SETCOLOR(173, 21,  21,  21,  255 ); //coal block
	SETCOLOR(174, 159, 189, 239, 255 ); //packed ice
	SETCOLOR(175, 0, 255, 0, 254 ); //Large flower
	SETCOLOR(206, 54, 24, 30, 255 ); //nether bricks slab

	// carpets
	SETCOLOR(36 ,  255, 255, 255,  254   ); //White carpet
	SETCOLOR(68 ,  244, 137,  54,  254   ); //Orange carpet
	SETCOLOR(69 ,  200,  75, 210,  254   ); //Magenta carpet
	SETCOLOR(70 ,  120, 158, 241,  254   ); //Light Blue carpet
	SETCOLOR(72 ,  204, 200,  28,  254   ); //Yellow carpet
	SETCOLOR(77 ,   59, 210,  47,  254   ); //Lime carpet
	SETCOLOR(131,  237, 141, 164,  254   ); //Pink carpet
	SETCOLOR(132,   76,  76,  76,  254   ); //Gray carpet
	SETCOLOR(141,  168, 172, 172,  254   ); //Light Gray
	SETCOLOR(142,   39, 116, 149,  254   ); //Cyan carpet
	SETCOLOR(143,  133,  53, 195,  254   ); //Purple carpet
	SETCOLOR(147,   38,  51, 160,  254   ); //Blue carpet
	SETCOLOR(148,   85,  51,  27,  254   ); //Brown carpet
	SETCOLOR(149,   55,  77,  24,  254   ); //Green carpet
	SETCOLOR(150,  173,  44,  40,  254   ); //Red carpet
	SETCOLOR(158,   32,  27,  27,  254   ); //Black carpet

	// clays
	SETCOLOR(159,  241, 210, 192, 255   ); //White Stained Clay

	SETCOLOR(186,  194, 116,  69, 255   ); //Orange Stained Clay
	SETCOLOR(187,  182, 120, 140, 255   ); //Magenta Stained Clay
	SETCOLOR(188,  141, 137, 167, 255   ); //Light Blue Stained Clay
	SETCOLOR(189,  219, 165,  66, 255   ); //Yellow Stained Clay
	SETCOLOR(190,  137, 149,  84, 255   ); //Lime Stained Clay
	SETCOLOR(191,  194, 110, 110, 255   ); //Pink Stained Clay
	SETCOLOR(192,   97,  82,  75, 255   ); //Gray Stained Clay
	SETCOLOR(193,  168, 138, 128, 255   ); //Light Gray Stained Clay
	SETCOLOR(194,  119, 122, 122, 255   ); //Cyan Stained Clay
	SETCOLOR(195,  152, 102, 117, 255   ); //Purple Stained Clay
	SETCOLOR(196,  103,  88, 120, 255   ); //Blue Stained Clay
	SETCOLOR(197,  109,  82,  66, 255   ); //Brown Stained Clay
	SETCOLOR(198,  105, 112,  70, 255   ); //Green Stained Clay
	SETCOLOR(199,  176,  93,  78, 255   ); //Red Stained Clay
	SETCOLOR(200,   67,  52,  46, 255   ); //Black Stained Clay

	SETCOLOR(153,  225, 140,  73, 255   ); //Red Sand

	// glass
	SETCOLOR(95 , 255, 255,  255,  100  ); //White Stained Glass
	SETCOLOR(160, 255, 255,  255,  100  ); //White Stained Glass pane
	SETCOLOR(234,  244, 137,  54,  40   ); //Orange Stained Glass [pane]
	SETCOLOR(225,  200,  75, 210,  40   ); //Magenta Stained Glass [pane]
	SETCOLOR(255,  120, 158, 241,  40   ); //Light Blue Stained Glass [pane]
	SETCOLOR(166,  204, 200,  28,  40   ); //Yellow Stained Glass [pane]
	SETCOLOR(167,   59, 210,  47,  40   ); //Lime Stained Glass [pane]
	SETCOLOR(168,  237, 141, 164,  40   ); //Pink Stained Glass [pane]
	SETCOLOR(169,   76,  76,  76,  40   ); //Gray Stained Glass [pane]
	SETCOLOR(178,  168, 172, 172,  40   ); //Light Gray Stained Glass [pane]
	SETCOLOR(179,   39, 116, 149,  40   ); //Cyan Stained Glass [pane]
	SETCOLOR(180,  133,  53, 195,  40   ); //Purple Stained Glass [pane]
	SETCOLOR(181,   38,  51, 160,  40   ); //Blue Stained Glass [pane]
	SETCOLOR(182,   85,  51,  27,  40   ); //Brown Stained Glass [pane]
	SETCOLOR(183,   55,  77,  24,  40   ); //Green Stained Glass [pane]
	SETCOLOR(184,  173,  44,  40,  40   ); //Red Stained Glass [pane]
	SETCOLOR(185,   32,  27,  27,  40   ); //Black Stained Glass [pane]

	// flowers
	SETCOLOR(165, 120, 158, 241, 254   ); //BLUE_ORCHID 165
	SETCOLOR(176, 200,  75, 210, 254 ); //ALLIUM 176
	SETCOLOR(235, 168, 172, 172, 254 ); //AZURE_BLUET 235
	// 38, 173  44  40 254, ); //RED_TULIP 38
	SETCOLOR(217, 244, 137,  54, 254 ); //ORANGE_TULIP 217
	SETCOLOR(218, 255, 255, 255, 254 ); //WHITE_TULIP 218
	SETCOLOR(219, 237, 141, 164, 254 ); //PINK_TULIP 219
	SETCOLOR(220, 168, 172, 172, 254 ); //OXEYE_DAISY 220
	// 37, 255 255  0 254, ); //SUNFLOWER 37
	SETCOLOR(233, 200,  75, 210, 254 ); //LILAC 233
	SETCOLOR(177, 237, 141, 164, 254 ); //PEONY 177

	// nether
	//SETCOLORNOISE(238,  206, 206, 201,  255,   5); // Birch Wood / quartz slab (sic!)

}
示例#24
0
文件: curs_lib.c 项目: darnir/neomutt
/**
 * mutt_yesorno - Ask the user a Yes/No question
 * @param msg Prompt
 * @param def Default answer, see #QuadOption
 * @retval num Selection made, see #QuadOption
 */
enum QuadOption mutt_yesorno(const char *msg, enum QuadOption def)
{
  struct Event ch;
  char *yes = _("yes");
  char *no = _("no");
  char *answer_string = NULL;
  int answer_string_wid, msg_wid;
  size_t trunc_msg_len;
  bool redraw = true;
  int prompt_lines = 1;

  char *expr = NULL;
  regex_t reyes;
  regex_t reno;
  char answer[2];

  answer[1] = '\0';

  bool reyes_ok = (expr = nl_langinfo(YESEXPR)) && (expr[0] == '^') &&
                  (REGCOMP(&reyes, expr, REG_NOSUB) == 0);
  bool reno_ok = (expr = nl_langinfo(NOEXPR)) && (expr[0] == '^') &&
                 (REGCOMP(&reno, expr, REG_NOSUB) == 0);

  /* In order to prevent the default answer to the question to wrapped
   * around the screen in the even the question is wider than the screen,
   * ensure there is enough room for the answer and truncate the question
   * to fit.  */
  safe_asprintf(&answer_string, " ([%s]/%s): ", (def == MUTT_YES) ? yes : no,
                (def == MUTT_YES) ? no : yes);
  answer_string_wid = mutt_strwidth(answer_string);
  msg_wid = mutt_strwidth(msg);

  while (true)
  {
    if (redraw || SigWinch)
    {
      redraw = false;
      if (SigWinch)
      {
        SigWinch = 0;
        mutt_resize_screen();
        clearok(stdscr, TRUE);
        mutt_menu_current_redraw();
      }
      if (MuttMessageWindow->cols)
      {
        prompt_lines = (msg_wid + answer_string_wid + MuttMessageWindow->cols - 1) /
                       MuttMessageWindow->cols;
        prompt_lines = MAX(1, MIN(3, prompt_lines));
      }
      if (prompt_lines != MuttMessageWindow->rows)
      {
        mutt_window_reflow_message_rows(prompt_lines);
        mutt_menu_current_redraw();
      }

      /* maxlen here is sort of arbitrary, so pick a reasonable upper bound */
      trunc_msg_len = mutt_wstr_trunc(
          msg, 4 * prompt_lines * MuttMessageWindow->cols,
          prompt_lines * MuttMessageWindow->cols - answer_string_wid, NULL);

      mutt_window_move(MuttMessageWindow, 0, 0);
      SETCOLOR(MT_COLOR_PROMPT);
      addnstr(msg, trunc_msg_len);
      addstr(answer_string);
      NORMAL_COLOR;
      mutt_window_clrtoeol(MuttMessageWindow);
    }

    mutt_refresh();
    /* SigWinch is not processed unless timeout is set */
    mutt_getch_timeout(30 * 1000);
    ch = mutt_getch();
    mutt_getch_timeout(-1);
    if (ch.ch == -2)
      continue;
    if (CI_is_return(ch.ch))
      break;
    if (ch.ch < 0)
    {
      def = MUTT_ABORT;
      break;
    }

    answer[0] = ch.ch;
    if (reyes_ok ? (regexec(&reyes, answer, 0, 0, 0) == 0) : (tolower(ch.ch) == 'y'))
    {
      def = MUTT_YES;
      break;
    }
    else if (reno_ok ? (regexec(&reno, answer, 0, 0, 0) == 0) : (tolower(ch.ch) == 'n'))
    {
      def = MUTT_NO;
      break;
    }
    else
    {
      BEEP();
    }
  }

  FREE(&answer_string);

  if (reyes_ok)
    regfree(&reyes);
  if (reno_ok)
    regfree(&reno);

  if (MuttMessageWindow->rows != 1)
  {
    mutt_window_reflow_message_rows(1);
    mutt_menu_current_redraw();
  }
  else
    mutt_window_clearline(MuttMessageWindow, 0);

  if (def != MUTT_ABORT)
  {
    addstr((char *) ((def == MUTT_YES) ? yes : no));
    mutt_refresh();
  }
  else
  {
    /* when the users cancels with ^G, clear the message stored with
     * mutt_message() so it isn't displayed when the screen is refreshed. */
    mutt_clear_error();
  }
  return def;
}
示例#25
0
void loadColors()
{	// Colors are mostly the same as in Cartograph
	memset(colors, 0, sizeof colors);
	SETCOLOR(AIR, 255,255,255,0);
	SETCOLORNOISE(STONE, 128,128,128,255, 16);
	SETCOLORNOISE(GRASS, 117,176,73,255, 14);
	SETCOLORNOISE(DIRT, 134,96,67,255, 22);
	SETCOLORNOISE(COBBLESTONE, 115,115,115,255, 26);
	SETCOLORNOISE(WOOD, 157,128,79,255, 11);
	SETCOLOR(6, 120,120,120,0);
	SETCOLOR(7, 84,84,84,255);
	SETCOLOR(8, 38,92,225,41);
	SETCOLOR(9, 38,92,225,41);
	SETCOLOR(10, 255,90,0,255);
	SETCOLOR(11, 255,90,0,255);
	SETCOLORNOISE(SAND, 220,212,160,255, 14);
	SETCOLORNOISE(GRAVEL, 136,126,126,255, 24);
	SETCOLOR(14, 143,140,125,255);
	SETCOLOR(15, 136,130,127,255);
	SETCOLOR(16, 115,115,115,255);
	SETCOLOR(LOG, 102,81,51,255);
	SETCOLORNOISE(LEAVES, 64,168,40,180, 12);
	SETCOLOR(20, 255,255,255,64); //glass
	//SETCOLOR(21, 222,50,50,255);
	//SETCOLOR(22, 222,136,50,255);
	//SETCOLOR(23, 222,222,50,255);
	//SETCOLOR(24, 136,222,50,255);
	//SETCOLOR(25, 50,222,50,255);
	//SETCOLOR(26, 50,222,136,255);
	//SETCOLOR(27, 50,222,222,255);
	//SETCOLOR(28, 104,163,222,255);
	//SETCOLOR(29, 120,120,222,255);
	//SETCOLOR(30, 136,50,222,255);
	//SETCOLOR(31, 174,74,222,255);
	//SETCOLOR(32, 222,50,222,255);
	//SETCOLOR(33, 222,50,136,255);
	//SETCOLOR(34, 77,77,77,255);
	SETCOLOR(35, 222,222,222,255); //Color(143,143,143,255);
	//SETCOLOR(36, 222,222,222,255);
	SETCOLOR(FLOWERR, 255,0,0,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(FLOWERY, 255,255,0,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(MUSHROOMB, 128,100,0,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(MUSHROOMR, 140,12,12,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(41, 231,165,45,255);
	SETCOLOR(42, 191,191,191,255);
	SETCOLOR(DOUBLESTEP, 200,200,200,255);
	SETCOLOR(STEP, 200,200,200,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(45, 170,86,62,255);
	SETCOLOR(46, 160,83,65,255);
	SETCOLOR(48, 115,115,115,255);
	SETCOLOR(49, 26,11,43,255);
	SETCOLOR(TORCH, 245,220,50,200);
	SETCOLOR(FIRE, 255,170,30,200);
	SETCOLOR(52, 245,220,50,255); // unnecessary afaik
	SETCOLOR(53, 157,128,79,255);
	SETCOLOR(54, 125,91,38,255);
	SETCOLOR(55, 245,220,50,255); // unnecessary afaik
	SETCOLOR(56, 129,140,143,255);
	SETCOLOR(57, 45,166,152,255);
	SETCOLOR(58, 114,88,56,255);
	SETCOLOR(59, 146,192,0,255);
	SETCOLOR(60, 95,58,30,255);
	SETCOLOR(61, 96,96,96,255);
	SETCOLOR(62, 96,96,96,255);
	SETCOLOR(63, 111,91,54,255);
	SETCOLOR(64, 136,109,67,255);
	SETCOLOR(65, 181,140,64,32);
	SETCOLOR(66, 150,134,102,180);
	SETCOLOR(67, 115,115,115,255);
	SETCOLOR(71, 191,191,191,255);
	SETCOLOR(73, 131,107,107,255);
	SETCOLOR(74, 131,107,107,255);
	SETCOLOR(REDTORCH_OFF, 181,100,44,254);
	SETCOLOR(REDTORCH_ON, 255,0,0,254);
	SETCOLOR(SNOW, 245,246,245,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(79, 83,113,163,55);
	SETCOLOR(80, 250,250,250,255);
	SETCOLOR(81, 25,120,25,255);
	SETCOLOR(82, 151,157,169,255);
	SETCOLOR(83, 183,234,150,255);
	SETCOLOR(84, 100,67,50,255);
	SETCOLOR(FENCE, 137,112,65,225); // Not fully opaque to prevent culling on this one
}
示例#26
0
/* return values:
 *
 * 1	message should be postponed
 * 0	normal exit
 * -1	abort message
 */
int mutt_compose_menu (HEADER *msg,   /* structure for new message */
                       char *fcc,     /* where to save a copy of the message */
                       size_t fcclen,
                       HEADER *cur,   /* current message */
                       int flags)
{
  char helpstr[LONG_STRING];
  char buf[LONG_STRING];
  char fname[_POSIX_PATH_MAX];
  MUTTMENU *menu;
  ATTACHPTR **idx = NULL;
  short idxlen = 0;
  short idxmax = 0;
  int i, close = 0;
  int r = -1;		/* return value */
  int op = 0;
  int loop = 1;
  int fccSet = 0;	/* has the user edited the Fcc: field ? */
  CONTEXT *ctx = NULL, *this = NULL;
  /* Sort, SortAux could be changed in mutt_index_menu() */
  int oldSort, oldSortAux;
  struct stat st;

  mutt_attach_init (msg->content);
  idx = mutt_gen_attach_list (msg->content, -1, idx, &idxlen, &idxmax, 0, 1);

  menu = mutt_new_menu (MENU_COMPOSE);
  menu->offset = HDR_ATTACH;
  menu->max = idxlen;
  menu->make_entry = snd_entry;
  menu->tag = mutt_tag_attach;
  menu->data = idx;
  menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_COMPOSE, ComposeHelp);
  
  while (loop)
  {
    switch (op = mutt_menuLoop (menu))
    {
      case OP_REDRAW:
	draw_envelope (msg, fcc);
	menu->offset = HDR_ATTACH;
	menu->pagelen = LINES - HDR_ATTACH - 2;
	break;
      case OP_COMPOSE_EDIT_FROM:
	menu->redraw = edit_address_list (HDR_FROM, &msg->env->from);
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
	break;
      case OP_COMPOSE_EDIT_TO:
	menu->redraw = edit_address_list (HDR_TO, &msg->env->to);
	if (option (OPTCRYPTOPPORTUNISTICENCRYPT))
	{
	  crypt_opportunistic_encrypt (msg);
	  redraw_crypt_lines (msg);
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;
      case OP_COMPOSE_EDIT_BCC:
	menu->redraw = edit_address_list (HDR_BCC, &msg->env->bcc);
	if (option (OPTCRYPTOPPORTUNISTICENCRYPT))
	{
	  crypt_opportunistic_encrypt (msg);
	  redraw_crypt_lines (msg);
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
	break;
      case OP_COMPOSE_EDIT_CC:
	menu->redraw = edit_address_list (HDR_CC, &msg->env->cc);
	if (option (OPTCRYPTOPPORTUNISTICENCRYPT))
	{
	  crypt_opportunistic_encrypt (msg);
	  redraw_crypt_lines (msg);
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);	
        break;
      case OP_COMPOSE_EDIT_SUBJECT:
	if (msg->env->subject)
	  strfcpy (buf, msg->env->subject, sizeof (buf));
	else
	  buf[0] = 0;
	if (mutt_get_field ("Subject: ", buf, sizeof (buf), 0) == 0)
	{
	  mutt_str_replace (&msg->env->subject, buf);
	  move (HDR_SUBJECT, HDR_XOFFSET);
	  if (msg->env->subject)
	    mutt_paddstr (W, msg->env->subject);
	  else
	    clrtoeol();
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;
      case OP_COMPOSE_EDIT_REPLY_TO:
	menu->redraw = edit_address_list (HDR_REPLYTO, &msg->env->reply_to);
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
	break;
      case OP_COMPOSE_EDIT_FCC:
	strfcpy (buf, fcc, sizeof (buf));
	if (mutt_get_field ("Fcc: ", buf, sizeof (buf), M_FILE | M_CLEAR) == 0)
	{
	  strfcpy (fcc, buf, fcclen);
	  mutt_pretty_mailbox (fcc, fcclen);
	  move (HDR_FCC, HDR_XOFFSET);
	  mutt_paddstr (W, fcc);
	  fccSet = 1;
	}
	MAYBE_REDRAW (menu->redraw);
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;
      case OP_COMPOSE_EDIT_MESSAGE:
	if (Editor && (mutt_strcmp ("builtin", Editor) != 0) && !option (OPTEDITHDRS))
	{
	  mutt_edit_file (Editor, msg->content->filename);
	  mutt_update_encoding (msg->content);
	  menu->redraw = REDRAW_FULL;
	  mutt_message_hook (NULL, msg, M_SEND2HOOK);
	  break;
	}
	/* fall through */
      case OP_COMPOSE_EDIT_HEADERS:
	if (mutt_strcmp ("builtin", Editor) != 0 &&
	    (op == OP_COMPOSE_EDIT_HEADERS ||
	    (op == OP_COMPOSE_EDIT_MESSAGE && option (OPTEDITHDRS))))
	{
	  char *tag = NULL, *err = NULL;
	  mutt_env_to_local (msg->env);
	  mutt_edit_headers (NONULL (Editor), msg->content->filename, msg,
			     fcc, fcclen);
	  if (mutt_env_to_intl (msg->env, &tag, &err))
	  {
	    mutt_error (_("Bad IDN in \"%s\": '%s'"), tag, err);
	    FREE (&err);
	  }
	  if (option (OPTCRYPTOPPORTUNISTICENCRYPT))
	    crypt_opportunistic_encrypt (msg);
	}
	else
	{
	  /* this is grouped with OP_COMPOSE_EDIT_HEADERS because the
	     attachment list could change if the user invokes ~v to edit
	     the message with headers, in which we need to execute the
	     code below to regenerate the index array */
	  mutt_builtin_editor (msg->content->filename, msg, cur);
	}
	mutt_update_encoding (msg->content);

	/* attachments may have been added */
	if (idxlen && idx[idxlen - 1]->content->next)
	{
	  for (i = 0; i < idxlen; i++)
          {
            FREE (&idx[i]->tree);
	    FREE (&idx[i]);
          }
	  idxlen = 0;
	  idx = mutt_gen_attach_list (msg->content, -1, idx, &idxlen, &idxmax, 0, 1);
	  menu->data = idx;
	  menu->max = idxlen;
	}

        menu->redraw = REDRAW_FULL;
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
	break;



      case OP_COMPOSE_ATTACH_KEY:
        if (!(WithCrypto & APPLICATION_PGP))
          break;       
	if (idxlen == idxmax)
        {
	  safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5));
	  menu->data = idx;
	}
	
	idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
	if ((idx[idxlen]->content = crypt_pgp_make_key_attachment(NULL)) != NULL)
	{
	  update_idx (menu, idx, idxlen++);
	  menu->redraw |= REDRAW_INDEX;
	}
	else
	  FREE (&idx[idxlen]);

	menu->redraw |= REDRAW_STATUS;

	if (option(OPTNEEDREDRAW))
	{
	  menu->redraw = REDRAW_FULL;
	  unset_option(OPTNEEDREDRAW);
	}
	
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;


      case OP_COMPOSE_ATTACH_FILE:
	{
	  char *prompt, **files;
	  int error, numfiles;

	  fname[0] = 0;
	  prompt = _("Attach file");
	  numfiles = 0;
	  files = NULL;

	  if (_mutt_enter_fname (prompt, fname, sizeof (fname), &menu->redraw, 0, 1, &files, &numfiles) == -1 ||
	      *fname == '\0')
	    break;

	  if (idxlen + numfiles >= idxmax)
	  {
	    safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5 + numfiles));
	    menu->data = idx;
	  }

	  error = 0;
	  if (numfiles > 1)
	    mutt_message _("Attaching selected files...");
	  for (i = 0; i < numfiles; i++)
	  {
	    char *att = files[i];
	    idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
            idx[idxlen]->unowned = 1;
	    idx[idxlen]->content = mutt_make_file_attach (att);
	    if (idx[idxlen]->content != NULL)
	      update_idx (menu, idx, idxlen++);
	    else
	    {
	      error = 1;
	      mutt_error (_("Unable to attach %s!"), att);
	      FREE (&idx[idxlen]);
	    }
	  }
	  
	  FREE (&files);
	  if (!error) mutt_clear_error ();

	  menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;

      case OP_COMPOSE_ATTACH_MESSAGE:
	{
	  char *prompt;
	  HEADER *h;

	  fname[0] = 0;
	  prompt = _("Open mailbox to attach message from");

	  if (Context)
	  {
	    strfcpy (fname, NONULL (Context->path), sizeof (fname));
	    mutt_pretty_mailbox (fname, sizeof (fname));
	  }

	  if (mutt_enter_fname (prompt, fname, sizeof (fname), &menu->redraw, 1) == -1 || !fname[0])
	    break;

	  mutt_expand_path (fname, sizeof (fname));
#ifdef USE_IMAP
          if (!mx_is_imap (fname))
#endif
#ifdef USE_POP
          if (!mx_is_pop (fname))
#endif
	  /* check to make sure the file exists and is readable */
	  if (access (fname, R_OK) == -1)
	  {
	    mutt_perror (fname);
	    break;
	  }

	  menu->redraw = REDRAW_FULL;

	  ctx = mx_open_mailbox (fname, M_READONLY, NULL);
	  if (ctx == NULL)
	  {
	    mutt_error (_("Unable to open mailbox %s"), fname);
	    break;
	  }

	  if (!ctx->msgcount)
	  {
	    mx_close_mailbox (ctx, NULL);
	    FREE (&ctx);
	    mutt_error _("No messages in that folder.");
	    break;
	  }

	  this = Context; /* remember current folder and sort methods*/
	  oldSort = Sort; oldSortAux = SortAux;
	  
	  Context = ctx;
	  set_option(OPTATTACHMSG);
	  mutt_message _("Tag the messages you want to attach!");
	  close = mutt_index_menu ();
	  unset_option(OPTATTACHMSG);

	  if (!Context)
	  {
	    /* go back to the folder we started from */
	    Context = this;
	    /* Restore old $sort and $sort_aux */
	    Sort = oldSort;
	    SortAux = oldSortAux;
	    menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
	    break;
	  }

	  if (idxlen + Context->tagged >= idxmax)
	  {
	    safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5 + Context->tagged));
	    menu->data = idx;
	  }

	  for (i = 0; i < Context->msgcount; i++)
	  {
	    h = Context->hdrs[i];
	    if (h->tagged)
	    {
	      idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
	      idx[idxlen]->content = mutt_make_message_attach (Context, h, 1);
	      if (idx[idxlen]->content != NULL)
		update_idx (menu, idx, idxlen++);
	      else
	      {
		mutt_error _("Unable to attach!");
		FREE (&idx[idxlen]);
	      }
	    }
	  }
	  menu->redraw |= REDRAW_FULL;

	  if (close == OP_QUIT) 
	    mx_close_mailbox (Context, NULL);
	  else
	    mx_fastclose_mailbox (Context);
	  FREE (&Context);

	  /* go back to the folder we started from */
	  Context = this;
	  /* Restore old $sort and $sort_aux */
	  Sort = oldSort;
	  SortAux = oldSortAux;
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;

      case OP_DELETE:
	CHECK_COUNT;
        if (idx[menu->current]->unowned)
          idx[menu->current]->content->unlink = 0;
	if (delete_attachment (menu, &idxlen, menu->current) == -1)
	  break;
	mutt_update_tree (idx, idxlen);
	if (idxlen)
	{
	  if (menu->current > idxlen - 1)
	    menu->current = idxlen - 1;
	}
	else
	  menu->current = 0;

	if (menu->current == 0)
	  msg->content = idx[0]->content;

        menu->redraw |= REDRAW_STATUS;
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;

#define CURRENT idx[menu->current]->content
      
      case OP_COMPOSE_TOGGLE_RECODE:
      {      
        CHECK_COUNT;
        if (!mutt_is_text_part (CURRENT))
        {
	  mutt_error (_("Recoding only affects text attachments."));
	  break;
	}
        CURRENT->noconv = !CURRENT->noconv;
        if (CURRENT->noconv)
	  mutt_message (_("The current attachment won't be converted."));
        else
	  mutt_message (_("The current attachment will be converted."));
	menu->redraw = REDRAW_CURRENT;
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;
      }
#undef CURRENT

      case OP_COMPOSE_EDIT_DESCRIPTION:
	CHECK_COUNT;
	strfcpy (buf,
		 idx[menu->current]->content->description ?
		 idx[menu->current]->content->description : "",
		 sizeof (buf));
	/* header names should not be translated */
	if (mutt_get_field ("Description: ", buf, sizeof (buf), 0) == 0)
	{
	  mutt_str_replace (&idx[menu->current]->content->description, buf);
	  menu->redraw = REDRAW_CURRENT;
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;

      case OP_COMPOSE_UPDATE_ENCODING:
        CHECK_COUNT;
        if (menu->tagprefix)
        {
	  BODY *top;
	  for (top = msg->content; top; top = top->next)
	  {
	    if (top->tagged)
	      mutt_update_encoding (top);
	  }
	  menu->redraw = REDRAW_FULL;
	}
        else
        {
          mutt_update_encoding(idx[menu->current]->content);
	  menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;
      
      case OP_COMPOSE_TOGGLE_DISPOSITION:
	/* toggle the content-disposition between inline/attachment */
	idx[menu->current]->content->disposition = (idx[menu->current]->content->disposition == DISPINLINE) ? DISPATTACH : DISPINLINE;
	menu->redraw = REDRAW_CURRENT;
	break;

      case OP_EDIT_TYPE:
	CHECK_COUNT;
        {
	  mutt_edit_content_type (NULL, idx[menu->current]->content, NULL);

	  /* this may have been a change to text/something */
	  mutt_update_encoding (idx[menu->current]->content);

	  menu->redraw = REDRAW_CURRENT;
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;

      case OP_COMPOSE_EDIT_ENCODING:
	CHECK_COUNT;
	strfcpy (buf, ENCODING (idx[menu->current]->content->encoding),
							      sizeof (buf));
	if (mutt_get_field ("Content-Transfer-Encoding: ", buf,
					    sizeof (buf), 0) == 0 && buf[0])
	{
	  if ((i = mutt_check_encoding (buf)) != ENCOTHER && i != ENCUUENCODED)
	  {
	    idx[menu->current]->content->encoding = i;
	    menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
	    mutt_clear_error();
	  }
	  else
	    mutt_error _("Invalid encoding.");
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;

      case OP_COMPOSE_SEND_MESSAGE:

        /* Note: We don't invoke send2-hook here, since we want to leave
	 * users an opportunity to change settings from the ":" prompt.
	 */
      
        if(check_attachments(idx, idxlen) != 0)
        {
	  menu->redraw = REDRAW_FULL;
	  break;
	}

      
#ifdef MIXMASTER
        if (msg->chain && mix_check_message (msg) != 0)
	  break;
#endif
      
	if (!fccSet && *fcc)
	{
	  if ((i = query_quadoption (OPT_COPY,
				_("Save a copy of this message?"))) == -1)
	    break;
	  else if (i == M_NO)
	    *fcc = 0;
	}

	loop = 0;
	r = 0;
	break;

      case OP_COMPOSE_EDIT_FILE:
	CHECK_COUNT;
	mutt_edit_file (NONULL(Editor), idx[menu->current]->content->filename);
	mutt_update_encoding (idx[menu->current]->content);
	menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
	break;

      case OP_COMPOSE_TOGGLE_UNLINK:
	CHECK_COUNT;
	idx[menu->current]->content->unlink = !idx[menu->current]->content->unlink;

#if 0
        /* OPTRESOLVE is otherwise ignored on this menu.
	 * Where's the bug?
	 */

        if (option (OPTRESOLVE) && menu->current + 1 < menu->max)
	  menu->current++;
# endif
	menu->redraw = REDRAW_INDEX;
        /* No send2hook since this doesn't change the message. */
	break;

      case OP_COMPOSE_GET_ATTACHMENT:
        CHECK_COUNT;
        if(menu->tagprefix)
        {
	  BODY *top;
	  for(top = msg->content; top; top = top->next)
	  {
	    if(top->tagged)
	      mutt_get_tmp_attachment(top);
	  }
	  menu->redraw = REDRAW_FULL;
	}
        else if (mutt_get_tmp_attachment(idx[menu->current]->content) == 0)
	  menu->redraw = REDRAW_CURRENT;

        /* No send2hook since this doesn't change the message. */
        break;
      
      case OP_COMPOSE_RENAME_FILE:
	CHECK_COUNT;
	strfcpy (fname, idx[menu->current]->content->filename, sizeof (fname));
	mutt_pretty_mailbox (fname, sizeof (fname));
	if (mutt_get_field (_("Rename to: "), fname, sizeof (fname), M_FILE)
							== 0 && fname[0])
	{
	  if (stat(idx[menu->current]->content->filename, &st) == -1)
	  {
            /* L10N:
               "stat" is a system call. Do "man 2 stat" for more information. */
	    mutt_error (_("Can't stat %s: %s"), fname, strerror (errno));
	    break;
	  }

	  mutt_expand_path (fname, sizeof (fname));
	  if(mutt_rename_file (idx[menu->current]->content->filename, fname))
	    break;
	  
	  mutt_str_replace (&idx[menu->current]->content->filename, fname);
	  menu->redraw = REDRAW_CURRENT;

	  if(idx[menu->current]->content->stamp >= st.st_mtime)
	    mutt_stamp_attachment(idx[menu->current]->content);
	  
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;

      case OP_COMPOSE_NEW_MIME:
	{
	  char type[STRING];
	  char *p;
	  int itype;
	  FILE *fp;

	  CLEARLINE (LINES-1);
	  fname[0] = 0;
	  if (mutt_get_field (_("New file: "), fname, sizeof (fname), M_FILE)
	      != 0 || !fname[0])
	    continue;
	  mutt_expand_path (fname, sizeof (fname));

	  /* Call to lookup_mime_type () ?  maybe later */
	  type[0] = 0;
	  if (mutt_get_field ("Content-Type: ", type, sizeof (type), 0) != 0 
	      || !type[0])
	    continue;

	  if (!(p = strchr (type, '/')))
	  {
	    mutt_error _("Content-Type is of the form base/sub");
	    continue;
	  }
	  *p++ = 0;
	  if ((itype = mutt_check_mime_type (type)) == TYPEOTHER)
	  {
	    mutt_error (_("Unknown Content-Type %s"), type);
	    continue;
	  }
	  if (idxlen == idxmax)
	  {
	    safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5));
	    menu->data = idx;
	  }

	  idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
	  /* Touch the file */
	  if (!(fp = safe_fopen (fname, "w")))
	  {
	    mutt_error (_("Can't create file %s"), fname);
	    FREE (&idx[idxlen]);
	    continue;
	  }
	  safe_fclose (&fp);

	  if ((idx[idxlen]->content = mutt_make_file_attach (fname)) == NULL)
	  {
	    mutt_error _("What we have here is a failure to make an attachment");
	    continue;
	  }
	  update_idx (menu, idx, idxlen++);

	  idx[menu->current]->content->type = itype;
	  mutt_str_replace (&idx[menu->current]->content->subtype, p);
	  idx[menu->current]->content->unlink = 1;
	  menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;

	  if (mutt_compose_attachment (idx[menu->current]->content))
	  {
	    mutt_update_encoding (idx[menu->current]->content);
	    menu->redraw = REDRAW_FULL;
	  }
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);    
        break;

      case OP_COMPOSE_EDIT_MIME:
	CHECK_COUNT;
	if (mutt_edit_attachment (idx[menu->current]->content))
	{
	  mutt_update_encoding (idx[menu->current]->content);
	  menu->redraw = REDRAW_FULL;
	}
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;

      case OP_VIEW_ATTACH:
      case OP_DISPLAY_HEADERS:
	CHECK_COUNT;
	mutt_attach_display_loop (menu, op, NULL, NULL, NULL, &idx, &idxlen, NULL, 0);
	menu->redraw = REDRAW_FULL;
        /* no send2hook, since this doesn't modify the message */
	break;

      case OP_SAVE:
	CHECK_COUNT;
	mutt_save_attachment_list (NULL, menu->tagprefix, menu->tagprefix ?  msg->content : idx[menu->current]->content, NULL, menu);
	MAYBE_REDRAW (menu->redraw);
        /* no send2hook, since this doesn't modify the message */
	break;

      case OP_PRINT:
	CHECK_COUNT;
	mutt_print_attachment_list (NULL, menu->tagprefix, menu->tagprefix ? msg->content : idx[menu->current]->content);
        /* no send2hook, since this doesn't modify the message */
	break;

      case OP_PIPE:
      case OP_FILTER:
        CHECK_COUNT;
	mutt_pipe_attachment_list (NULL, menu->tagprefix, menu->tagprefix ? msg->content : idx[menu->current]->content, op == OP_FILTER);
	if (op == OP_FILTER) /* cte might have changed */
	  menu->redraw = menu->tagprefix ? REDRAW_FULL : REDRAW_CURRENT;
        menu->redraw |= REDRAW_STATUS;
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
	break;

      case OP_EXIT:
	if ((i = query_quadoption (OPT_POSTPONE, _("Postpone this message?"))) == M_NO)
	{
          for (i = 0; i < idxlen; i++)
            if (idx[i]->unowned)
              idx[i]->content->unlink = 0;

          if (!(flags & M_COMPOSE_NOFREEHEADER))
          {
            while (idxlen-- > 0)
            {
              /* avoid freeing other attachments */
              idx[idxlen]->content->next = NULL;
              idx[idxlen]->content->parts = NULL;
              mutt_free_body (&idx[idxlen]->content);
              FREE (&idx[idxlen]->tree);
              FREE (&idx[idxlen]);
            }
            FREE (&idx);
            idxlen = 0;
            idxmax = 0;
          }
	  r = -1;
	  loop = 0;
	  break;
	}
	else if (i == -1)
	  break; /* abort */

	/* fall through to postpone! */

      case OP_COMPOSE_POSTPONE_MESSAGE:

        if(check_attachments(idx, idxlen) != 0)
        {
	  menu->redraw = REDRAW_FULL;
	  break;
	}
      
	loop = 0;
	r = 1;
	break;

      case OP_COMPOSE_ISPELL:
	endwin ();
	snprintf (buf, sizeof (buf), "%s -x %s", NONULL(Ispell), msg->content->filename);
	if (mutt_system (buf) == -1)
	  mutt_error (_("Error running \"%s\"!"), buf);
	else
        {
	  mutt_update_encoding (msg->content);
	  menu->redraw |= REDRAW_STATUS;
	}
	break;

      case OP_COMPOSE_WRITE_MESSAGE:

       fname[0] = '\0';
       if (Context)
       {
	 strfcpy (fname, NONULL (Context->path), sizeof (fname));
	 mutt_pretty_mailbox (fname, sizeof (fname));
       }
       if (idxlen)
         msg->content = idx[0]->content;
       if (mutt_enter_fname (_("Write message to mailbox"), fname, sizeof (fname),
                             &menu->redraw, 1) != -1 && fname[0])
       {
         mutt_message (_("Writing message to %s ..."), fname);
         mutt_expand_path (fname, sizeof (fname));

         if (msg->content->next)
           msg->content = mutt_make_multipart (msg->content);

         if (mutt_write_fcc (fname, msg, NULL, 0, NULL) < 0)
           msg->content = mutt_remove_multipart (msg->content);
         else
           mutt_message _("Message written.");
       }
       break;



      case OP_COMPOSE_PGP_MENU:
        if (!(WithCrypto & APPLICATION_PGP))
          break;
	if ((WithCrypto & APPLICATION_SMIME)
            && (msg->security & APPLICATION_SMIME))
	{
          if (msg->security & (ENCRYPT | SIGN))
          {
            if (mutt_yesorno (_("S/MIME already selected. Clear & continue ? "),
                              M_YES) != M_YES)
            {
              mutt_clear_error ();
              break;
            }
            msg->security &= ~(ENCRYPT | SIGN);
          }
	  msg->security &= ~APPLICATION_SMIME;
	  msg->security |= APPLICATION_PGP;
          crypt_opportunistic_encrypt (msg);
          redraw_crypt_lines (msg);
	}
	msg->security = crypt_pgp_send_menu (msg, &menu->redraw);
	redraw_crypt_lines (msg);
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;


      case OP_FORGET_PASSPHRASE:
	crypt_forget_passphrase ();
	break;


      case OP_COMPOSE_SMIME_MENU:
        if (!(WithCrypto & APPLICATION_SMIME))
          break;

	if ((WithCrypto & APPLICATION_PGP)
            && (msg->security & APPLICATION_PGP))
	{
          if (msg->security & (ENCRYPT | SIGN))
          {
            if (mutt_yesorno (_("PGP already selected. Clear & continue ? "),
                                M_YES) != M_YES)
            {
              mutt_clear_error ();
              break;
            }
            msg->security &= ~(ENCRYPT | SIGN);
          }
	  msg->security &= ~APPLICATION_PGP;
	  msg->security |= APPLICATION_SMIME;
          crypt_opportunistic_encrypt (msg);
          redraw_crypt_lines (msg);
	}
	msg->security = crypt_smime_send_menu(msg, &menu->redraw);
	redraw_crypt_lines (msg);
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;


#ifdef MIXMASTER
      case OP_COMPOSE_MIX:
      
      	mix_make_chain (&msg->chain, &menu->redraw);
        mutt_message_hook (NULL, msg, M_SEND2HOOK);
        break;
#endif

    }

    /* Draw formatted compose status line */
    if (menu->redraw & REDRAW_STATUS) 
    {
	compose_status_line (buf, sizeof (buf), 0, menu, NONULL(ComposeFormat));
	move(option (OPTSTATUSONTOP) ? 0 : LINES-2, 0);
	SETCOLOR (MT_COLOR_STATUS);
	mutt_paddstr (COLS, buf);
	NORMAL_COLOR;
	menu->redraw &= ~REDRAW_STATUS;
    }
  }

  mutt_menuDestroy (&menu);

  if (idxlen)
  {
    msg->content = idx[0]->content;
    for (i = 0; i < idxlen; i++)
    {
      idx[i]->content->aptr = NULL;
      FREE (&idx[i]->tree);
      FREE (&idx[i]);
    }
  }
  else
    msg->content = NULL;

  FREE (&idx);

  return (r);
}
示例#27
0
文件: curs_lib.c 项目: darnir/neomutt
/**
 * mutt_multi_choice - Offer the user a multiple choice question
 * @param prompt  Message prompt
 * @param letters Allowable selection keys
 * @retval >=0 0-based user selection
 * @retval  -1 Selection aborted
 */
int mutt_multi_choice(const char *prompt, const char *letters)
{
  struct Event ch;
  int choice;
  bool redraw = true;
  int prompt_lines = 1;
  char *p = NULL;

  while (true)
  {
    if (redraw || SigWinch)
    {
      redraw = false;
      if (SigWinch)
      {
        SigWinch = 0;
        mutt_resize_screen();
        clearok(stdscr, TRUE);
        mutt_menu_current_redraw();
      }
      if (MuttMessageWindow->cols)
      {
        prompt_lines = (mutt_strwidth(prompt) + MuttMessageWindow->cols - 1) /
                       MuttMessageWindow->cols;
        prompt_lines = MAX(1, MIN(3, prompt_lines));
      }
      if (prompt_lines != MuttMessageWindow->rows)
      {
        mutt_window_reflow_message_rows(prompt_lines);
        mutt_menu_current_redraw();
      }

      SETCOLOR(MT_COLOR_PROMPT);
      mutt_window_mvaddstr(MuttMessageWindow, 0, 0, prompt);
      NORMAL_COLOR;
      mutt_window_clrtoeol(MuttMessageWindow);
    }

    mutt_refresh();
    /* SigWinch is not processed unless timeout is set */
    mutt_getch_timeout(30 * 1000);
    ch = mutt_getch();
    mutt_getch_timeout(-1);
    if (ch.ch == -2)
      continue;
    /* (ch.ch == 0) is technically possible.  Treat the same as < 0 (abort) */
    if ((ch.ch <= 0) || CI_is_return(ch.ch))
    {
      choice = -1;
      break;
    }
    else
    {
      p = strchr(letters, ch.ch);
      if (p)
      {
        choice = p - letters + 1;
        break;
      }
      else if ((ch.ch <= '9') && (ch.ch > '0'))
      {
        choice = ch.ch - '0';
        if (choice <= mutt_str_strlen(letters))
          break;
      }
    }
    BEEP();
  }
  if (MuttMessageWindow->rows != 1)
  {
    mutt_window_reflow_message_rows(1);
    mutt_menu_current_redraw();
  }
  else
    mutt_window_clearline(MuttMessageWindow, 0);
  mutt_refresh();
  return choice;
}
示例#28
0
static void print_enriched_string (int attr, unsigned char *s, int do_color)
{
  wchar_t wc;
  size_t k;
  size_t n = str_len ((char *) s);
  mbstate_t mbstate;

  memset (&mbstate, 0, sizeof (mbstate));
  while (*s) {
    if (*s < M_TREE_MAX) {
      if (do_color)
        SETCOLOR (MT_COLOR_TREE);
      while (*s && *s < M_TREE_MAX) {
        switch (*s) {
        case M_TREE_LLCORNER:
          if (option (OPTASCIICHARS))
            addch ('`');
          else if (Charset_is_utf8)
            addstr ("\342\224\224");    /* WACS_LLCORNER */
          else
            addch (ACS_LLCORNER);
          break;
        case M_TREE_ULCORNER:
          if (option (OPTASCIICHARS))
            addch (',');
          else if (Charset_is_utf8)
            addstr ("\342\224\214");    /* WACS_ULCORNER */
          else
            addch (ACS_ULCORNER);
          break;
        case M_TREE_LTEE:
          if (option (OPTASCIICHARS))
            addch ('|');
          else if (Charset_is_utf8)
            addstr ("\342\224\234");    /* WACS_LTEE */
          else
            addch (ACS_LTEE);
          break;
        case M_TREE_HLINE:
          if (option (OPTASCIICHARS))
            addch ('-');
          else if (Charset_is_utf8)
            addstr ("\342\224\200");    /* WACS_HLINE */
          else
            addch (ACS_HLINE);
          break;
        case M_TREE_VLINE:
          if (option (OPTASCIICHARS))
            addch ('|');
          else if (Charset_is_utf8)
            addstr ("\342\224\202");    /* WACS_VLINE */
          else
            addch (ACS_VLINE);
          break;
        case M_TREE_TTEE:
          if (option (OPTASCIICHARS))
            addch ('-');
          else if (Charset_is_utf8)
            addstr ("\342\224\254");    /* WACS_TTEE */
          else
            addch (ACS_TTEE);
          break;
        case M_TREE_BTEE:
          if (option (OPTASCIICHARS))
            addch ('-');
          else if (Charset_is_utf8)
            addstr ("\342\224\264");    /* WACS_BTEE */
          else
            addch (ACS_BTEE);
          break;
        case M_TREE_SPACE:
          addch (' ');
          break;
        case M_TREE_RARROW:
          addch ('>');
          break;
        case M_TREE_STAR:
          addch ('*');          /* fake thread indicator */
          break;
        case M_TREE_HIDDEN:
          addch ('&');
          break;
        case M_TREE_EQUALS:
          addch ('=');
          break;
        case M_TREE_MISSING:
          addch ('?');
          break;
        }
        s++, n--;
      }
      if (do_color)
        attrset (attr);
    }
    else if ((k = mbrtowc (&wc, (char *) s, n, &mbstate)) > 0) {
      addnstr ((char *) s, k);
      s += k, n -= k;
    }
    else
      break;
  }
}
示例#29
0
int app_main(char * trackerip, DISPLAYINFO * disp)
{
  UINT16 i, j;
  char our_file_name[260] = "TEST";
  char verstr[50];
  int eyelink_ver = 0;
  int tracker_software_ver = 0;
  
  if(trackerip)
		set_eyelink_address(trackerip);
  if(open_eyelink_connection(0)) return -1;    /* abort if we can't open link */
  set_offline_mode();
  flush_getkey_queue();                        /* initialize getkey() system */

  eyelink_ver = eyelink_get_tracker_version(verstr);
  if (eyelink_ver == 3)
	  tracker_software_ver = get_tracker_sw_version(verstr);



  if(init_expt_graphics(NULL, disp))
	  goto shutdown;   /* register window with EXPTSPPT */


  window = SDL_GetVideoSurface();
  get_display_information(&dispinfo);          /* get window size, characteristics */

    /*
		NOTE: Camera display does not support 16-color modes
		NOTE: Picture display examples don't work well with 256-color modes
		However, all other sample programs should work well.
	*/

  if(dispinfo.palsize)     /* 256-color modes: palettes not supported by this example */
      alert_printf("This program is not optimized for 256-color displays");


 

  
  i = SCRWIDTH/60;		  /* select best size for calibration target */
  j = SCRWIDTH/300;       /* and focal spot in target */
  if(j < 2) j = 2;
  set_target_size(i, j);  /* tell DLL the size of target features */


  /* color of calibration target */
  SETCOLOR(target_foreground_color, 0,0,0);
  /* background for calibration and drift correction */
  SETCOLOR(target_background_color, 128,128,128);
  /* tell EXPTSPPT the colors */
  set_calibration_colors(&target_foreground_color, &target_background_color);

  set_cal_sounds("", "", "");
  set_dcorr_sounds("", "off", "off");

  /* draw a title screen */
  clear_full_screen_window(target_background_color);    /* clear screen */
  get_new_font("Times Roman", SCRHEIGHT/32, 1);         /* select a font */
                                                        /* Draw text */
  graphic_printf(window, target_foreground_color,  CENTER, SCRWIDTH/2, 1*SCRHEIGHT/30,
                 "EyeLink Demonstration Experiment: Communicate with Listener");
  graphic_printf(window, target_foreground_color,  CENTER, SCRWIDTH/2, 2*SCRHEIGHT/30,
                 "Included with the Experiment Programming Kit for Windows");
  graphic_printf(window, target_foreground_color,  CENTER, SCRWIDTH/2, 3*SCRHEIGHT/30,
                 "All code is Copyright (c) 1997-2002 SR Research Ltd.");
  graphic_printf(window, target_foreground_color,  CENTER, SCRWIDTH/5, 4*SCRHEIGHT/30,
                 "Source code may be used as template for your experiments.");
  SDL_Flip(window);

  eyelink_set_name("comm_simple");  /* NEW: set our network name */

  if(check_for_listener())   /* check for COMM_LISTENER application */
    {
      alert_printf("Could not communicate with COMM_LISTENER application.");
      goto shutdown;
    }

  if(i==1)  our_file_name[0] = 0;   /* Cancelled: No file name */
  if(our_file_name[0])    /* If file name set, open it */
    {
      if(!strstr(our_file_name, ".")) strcat(our_file_name, ".EDF");  /* add extension   */
      i = open_data_file(our_file_name);                              /* open file       */
      if(i!=0)                                                        /* check for error */
        {
          alert_printf("Cannot create EDF file '%s'", our_file_name);
          goto shutdown;
        }
	  /* add title to preamble */
      eyecmd_printf("add_file_preamble_text 'RECORDED BY %s' ", program_name);
    }
  /*
		SET UP TRACKER CONFIGURATION
		NOTE: set contents before sending messages!
		set EDF file contents
  */
   if(eyelink_ver>=2)
    {
      eyecmd_printf("select_parser_configuration 0");  // 0 = standard sensitivity
	  if(eyelink_ver == 2) //turn off scenelink camera stuff
	  {
		eyecmd_printf("scene_camera_gazemap = NO");
	  }
    }
  else
    {
      eyecmd_printf("saccade_velocity_threshold = 35");
      eyecmd_printf("saccade_acceleration_threshold = 9500");
    }
  // NOTE: set contents before sending messages!
		     // set EDF file contents 
  eyecmd_printf("file_event_filter = LEFT,RIGHT,FIXATION,SACCADE,BLINK,MESSAGE,BUTTON");
  eyecmd_printf("file_sample_data  = LEFT,RIGHT,GAZE,AREA,GAZERES,STATUS%s",(tracker_software_ver>=4)?",HTARGET":"");
		      // set link data (used for gaze cursor) 
  eyecmd_printf("link_event_filter = LEFT,RIGHT,FIXATION,SACCADE,BLINK,BUTTON");
  eyecmd_printf("link_sample_data  = LEFT,RIGHT,GAZE,GAZERES,AREA,STATUS%s",(tracker_software_ver>=4)?",HTARGET":"");

  /* NEW: Allow EyeLink I (v2.1+) to echo messages back to listener */
  eyecmd_printf("link_nonrecord_events = BUTTONS, MESSAGES");

  /* Program button #5 for use in drift correction */
  eyecmd_printf("button_function 5 'accept_target_fixation'");

  /* Now configure tracker for display resolution */
  eyecmd_printf("screen_pixel_coords = %ld %ld %ld %ld",    /* Set display resolution */
                 dispinfo.left, dispinfo.top, dispinfo.right, dispinfo.bottom);
  eyecmd_printf("calibration_type = HV9");       /* Setup calibration type */
  eyemsg_printf("DISPLAY_COORDS %ld %ld %ld %ld",/* Add resolution to EDF file */
                 dispinfo.left, dispinfo.top, dispinfo.right, dispinfo.bottom);
  if(dispinfo.refresh>40)
    eyemsg_printf("FRAMERATE %1.2f Hz.", dispinfo.refresh);

  

  /* make sure we're still alive */
  if(!eyelink_is_connected() || break_pressed()) goto end_expt;

  /*
	 RUN THE EXPERIMENTAL TRIALS (code depends on type of experiment)
     Calling run_trials() performs a calibration followed by trials
     This is equivalent to one block of an experiment
     It will return ABORT_EXPT if the program should exit
   */
  i = run_trials();

end_expt:                /* END: close, transfer EDF file */
  set_offline_mode();    /* set offline mode so we can transfer file */
  pump_delay(500);       /* delay so tracker is ready */
  eyecmd_printf("close_data_file"); /* close data file */

  if(break_pressed()) goto shutdown;/* don't get file if we aborted experiment */
  if(our_file_name[0])              /* make sure we created a file */
    receive_data_file(our_file_name, "", 0);  /* transfer the file, ask for a local name */

shutdown:                /* CLEANUP */
  close_expt_graphics();           /* tell EXPTSPPT to release window */
  close_eyelink_connection();      /* disconnect from tracker */
  return 0;
}
示例#30
0
void loadColors()
{
	memset(colors, 0, sizeof colors);
	SETCOLOR(AIR, 255,255,255,0);
	SETCOLORNOISE(STONE, 128,128,128,255, 16);
	SETCOLORNOISE(GRASS, 102,142,62,255, 14);
	SETCOLORNOISE(DIRT, 134,96,67,255, 22);
	SETCOLORNOISE(COBBLESTONE, 115,115,115,255, 24);
	SETCOLORNOISE(WOOD, 157,128,79,255, 11);
	SETCOLOR(6, 120,120,120,0);
	SETCOLOR(7, 84,84,84,255);
	SETCOLOR(WATER, 38,92,225,36);
	SETCOLOR(STAT_WATER, 38,92,225,36);
	SETCOLOR(10, 255,90,0,255);
	SETCOLOR(11, 255,90,0,255);
	SETCOLORNOISE(SAND, 220,212,160,255, 14);
	SETCOLORNOISE(GRAVEL, 136,126,126,255, 24);
	SETCOLOR(14, 143,140,125,255);
	SETCOLOR(15, 136,130,127,255);
	SETCOLOR(16, 115,115,115,255);
	SETCOLOR(LOG, 102,81,51,255);
	SETCOLORNOISE(LEAVES, 54,135,40,180, 12);
	SETCOLOR(20, 255,255,255,40); //glass
	SETCOLORNOISE(21, 102, 112, 134, 255, 10);
	SETCOLORNOISE(22, 29, 71, 165, 255, 5);
	SETCOLOR(23, 107, 107, 107, 255);
	SETCOLORNOISE(SANDSTONE, 218, 210, 158, 255, 7);
	SETCOLORNOISE(25, 100, 67, 50, 255, 10);
	SETCOLOR(BED, 175,116,116, 254); // Not fully opaque to prevent culling on this one
	SETCOLOR(POW_RAILROAD, 160,134,72,250);
	SETCOLOR(DET_RAILROAD, 120,114,92,250);
	SETCOLOR(29, 106,102,95,255);
	SETCOLOR(COBWEB, 220,220,220,190);
	SETCOLORNOISE(TALL_GRASS, 110,166,68,254, 12);
	SETCOLORNOISE(SHRUB, 123,79,25,254, 25);
	SETCOLOR(33, 106,102,95,255);
	SETCOLOR(34, 153,129,89,255);
	SETCOLOR(WOOL, 222,222,222,255); //Color(143,143,143,255);
	//SETCOLOR(36, 222,222,222,255);
	SETCOLOR(FLOWERR, 255,0,0,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(FLOWERY, 255,255,0,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(MUSHROOMB, 128,100,0,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(MUSHROOMR, 140,12,12,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(41, 231,165,45,255);
	SETCOLOR(42, 191,191,191,255);
	SETCOLOR(DOUBLESTEP, 200,200,200,255);
	SETCOLOR(STEP, 200,200,200,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(UP_STEP, 200,200,200,254); // Not fully opaque to prevent culling on this one
	SETCOLOR(45, 170,86,62,255);
	SETCOLOR(BRICKSTEP, 170,86,62,254);
	SETCOLOR(UP_BRICKSTEP, 170,86,62,254);
	SETCOLOR(46, 160,83,65,255);
	SETCOLORNOISE(48, 90,108,90,255, 27);
	SETCOLOR(49, 26,11,43,255);
	SETCOLOR(TORCH, 245,220,50,200);
	SETCOLOR(FIRE, 255,170,30,200);
	SETCOLOR(52, 20,170,200,255);
	SETCOLOR(53, 157,128,79,255);
	SETCOLOR(54, 125,91,38,255);
	SETCOLOR(REDWIRE, 200,10,10,200);
	SETCOLOR(56, 129,140,143,255);
	SETCOLOR(57, 45,166,152,255);
	SETCOLOR(58, 114,88,56,255);
	SETCOLOR(59, 146,192,0,255);
	SETCOLOR(60, 95,58,30,255);
	SETCOLOR(61, 96,96,96,255);
	SETCOLOR(62, 96,96,96,255);
	SETCOLOR(63, 111,91,54,255);
	SETCOLOR(64, 136,109,67,255);
	SETCOLOR(65, 181,140,64,32);
	SETCOLOR(RAILROAD, 140,134,72,250);
	SETCOLOR(67, 115,115,115,255);
	SETCOLOR(71, 191,191,191,255);
	SETCOLOR(73, 131,107,107,255);
	SETCOLOR(74, 131,107,107,255);
	SETCOLOR(REDTORCH_OFF, 181,100,44,254);
	SETCOLOR(REDTORCH_ON, 255,0,0,254);
	SETCOLORNOISE(SNOW, 245,246,245,254, 13); // Not fully opaque to prevent culling on this one
	SETCOLORNOISE(79, 125,173,255,159, 7);
	SETCOLOR(80, 250,250,250,255);
	SETCOLOR(81, 25,120,25,255);
	SETCOLOR(82, 151,157,169,255);
	SETCOLOR(83, 183,234,150,255);
	SETCOLOR(84, 100,67,50,255);
	SETCOLOR(FENCE, 137,112,65,225); // Not fully opaque to prevent culling on this one
	SETCOLOR(86, 197,120,23,255);
	SETCOLORNOISE(87, 110,53,51,255, 16);
	SETCOLORNOISE(88, 84,64,51,255, 7);
	SETCOLORNOISE(89, 137,112,64,255, 11);
	SETCOLOR(90, 0,42,255,127);
	SETCOLOR(91, 185,133,28,255);
	SETCOLORNOISE(CAKE, 228, 205, 206, 255, 7);
	SETCOLORNOISE(93, 151,147,147, 255, 2);
	SETCOLORNOISE(94, 161,147,147, 255, 2);
	SETCOLOR(95, 125,91,38,255);
	SETCOLORNOISE(TRAPDOOR, 126,93,45,240, 5);
	SETCOLORNOISE(97, 128,128,128,255, 16);
	SETCOLORNOISE(98, 122,122,122,255, 7);
	SETCOLORNOISE(STONEBRICKSTEP, 122,122,122,254, 7);
	SETCOLORNOISE(UP_STONEBRICKSTEP, 122,122,122,254, 7);
	SETCOLORNOISE(99, 141,106,83,255, 0);
	SETCOLORNOISE(100, 182,37,36,255, 6);
	SETCOLORNOISE(IRON_BARS, 109,108,106,254, 6);
	SETCOLOR(102, 255,255,255,40);
	SETCOLORNOISE(103, 151,153,36,255, 10);
	SETCOLOR(PUMPKIN_STEM, 115,170,73,254);
	SETCOLOR(MELON_STEM, 115,170,73,254);
	SETCOLORNOISE(VINES, 51,130,36,180, 12);
	SETCOLOR(FENCE_GATE, 137,112,65,225);
	SETCOLOR(108, 170,86,62,255);
	SETCOLORNOISE(109, 122,122,122,255, 7);
	SETCOLORNOISE(MYCELIUM, 140,115,119,255, 14);
	SETCOLOR(LILYPAD, 85,124,60,254); 
	SETCOLORNOISE(NETHER_BRICK, 54,24,30,255, 7);
	SETCOLOR(NETHER_BRICK_FENCE, 54,24,30,225);
	SETCOLOR(NETHER_BRICK_STAIRS, 54,24,30,255);
	SETCOLOR(NETHER_WART, 112,8,28,254);
	SETCOLORNOISE(116, 103,64,59,255, 6);
	SETCOLORNOISE(117, 124,103,81,255, 25);
	SETCOLOR(118, 55,55,55,255);
	SETCOLOR(119, 18,16,27,127);
	SETCOLORNOISE(120, 89,117,96,255, 6);
	SETCOLORNOISE(121, 221,223,165,255, 3);
	SETCOLOR(122, 20,18,29,255);
	SETCOLORNOISE(123, 70,43,26,255, 2);
	SETCOLORNOISE(124, 119,89,55,255, 7);
	SETCOLORNOISE(PINELEAVES, 44,84,44,160, 20); // Pine leaves
	SETCOLORNOISE(BIRCHLEAVES, 85,124,60,170, 11); // Birch leaves
	SETCOLORNOISE(JUNGLELEAVES, 44,135,50,175, 11); // Birch leaves
	SETCOLORNOISE(SANDSTEP, 218, 210, 158, 254, 7); // Not fully opaque to prevent culling on this one
	SETCOLORNOISE(UP_SANDSTEP, 218, 210, 158, 254, 7); // Not fully opaque to prevent culling on this one
	SETCOLORNOISE(WOODSTEP, 157,128,79,254, 11); // Not fully opaque to prevent culling on this one
	SETCOLORNOISE(UP_WOODSTEP, 157,128,79,254, 11); // Not fully opaque to prevent culling on this one
	SETCOLORNOISE(COBBLESTEP, 115,115,115,254, 26); // Not fully opaque to prevent culling on this one
	SETCOLORNOISE(UP_COBBLESTEP, 115,115,115,254, 26); // Not fully opaque to prevent culling on this one
	SETCOLOR(237, 70,50,32, 255); // Pine trunk
	SETCOLORNOISE(238, 206,206,201, 255, 5); // Birch trunk
	SETCOLOR(239, 122,91,51, 255); // Jungle trunk
	SETCOLOR(240, 244,137,54, 255); // Dyed wool
	SETCOLOR(241, 200,75,210,255);
	SETCOLOR(242, 120,158,241, 255);
	SETCOLOR(243, 204,200,28, 255);
	SETCOLOR(244, 59,210,47, 255);
	SETCOLOR(245, 237,141,164, 255);
	SETCOLOR(246, 76,76,76, 255);
	SETCOLOR(247, 168,172,172, 255);
	SETCOLOR(248, 39,116,149, 255);
	SETCOLOR(249, 133,53,195, 255);
	SETCOLOR(250, 38,51,160, 255);
	SETCOLOR(251, 85,51,27, 255);
	SETCOLOR(252, 55,77,24, 255);
	SETCOLOR(253, 173,44,40, 255);
	SETCOLOR(254, 32,27,27, 255);
}