コード例 #1
0
ファイル: engine.c プロジェクト: liushizhe/yetris
/** Starts all the subscreens of the game */
int engine_windows_init()
{
	window_s  w;
	screen_s* s = &(engine.screen);

	int main_x = 0;
	int main_y = 0;
	if (global.screen_center_horizontally)
		main_x = engine.screen.width/2 - 80/2;

	if (global.screen_center_vertically)
		main_y = engine.screen.height/2 - 24/2;

	/* main window, wrapper of all others */
	w.width  = 80;
	w.height = 24;
	w.x      = main_x;
	w.y      = main_y;
	w.win    = newwin(w.height, w.width, w.y, w.x);
	if (global.screen_show_outer_border)
	{
		if (global.screen_fancy_borders)
			window_fancy_borders(w.win);
		else
			window_normal_borders(w.win);
	}

	wnoutrefresh(w.win);
	s->main = w;

	/* leftmost */
	w.width  = 6 * 2 + 2;
	w.height = s->main.height - 2; /* borders */
	w.x      = 2;
	w.y      = 1;
	w.win    = derwin(s->main.win, w.height, w.width, w.y, w.x);

	if (global.screen_fancy_borders)
	{
		window_fancy_borders(w.win);

		/* If the player has no hold, doesnt make sense printing these parts */
		if (global.game_can_hold)
		{
			/* making the top line between hold and score windows */
			mvwaddch(w.win, 5, 0, ACS_LLCORNER|COLOR_PAIR(WHITE_BLACK));
			my_mvwhline(w.win, 5, 1, ACS_HLINE|COLOR_PAIR(BLACK_BLACK)|A_BOLD, w.width - 2);
			mvwaddch(w.win, 5, w.width - 1, ACS_LRCORNER|COLOR_PAIR(BLACK_BLACK)|A_BOLD);

			/* making the bottom line between hold and score windows */
			mvwaddch(w.win, 6, 0, ACS_ULCORNER|COLOR_PAIR(WHITE_BLACK)|A_BOLD);
			my_mvwhline(w.win, 6, 1, ACS_HLINE|COLOR_PAIR(WHITE_BLACK), w.width - 2);
			mvwaddch(w.win, 6, w.width - 1, ACS_URCORNER|COLOR_PAIR(WHITE_BLACK));
		}

	}
	else
	{
		window_normal_borders(w.win);
		wattrset(w.win, engine_get_color(COLOR_BLACK, COLOR_BLACK, true));
		mvwhline(w.win, 5, 1, '-', w.width - 2);
	}

	wnoutrefresh(w.win);
	s->leftmost = w;

	/* middle-left */
	w.width  = 10 * 2 + 2;
	w.height = s->main.height - 2; /* borders */
	w.x      = s->leftmost.x + s->leftmost.width + 1;
	w.y      = 1;
	w.win    = derwin(s->main.win, w.height, w.width, w.y, w.x);
	if (global.screen_fancy_borders)
		window_fancy_borders(w.win);
	else
		window_normal_borders(w.win);
	wnoutrefresh(w.win);
	s->middle_left = w;

	/* middle-right */
	w.width  = 4 * 2 + 2;
	w.height = s->main.height - 2; /* borders */
	w.x      = s->middle_left.x + s->middle_left.width + 1;
	w.y      = 1;
	w.win    = derwin(s->main.win, w.height, w.width, w.y, w.x);
	if (global.screen_fancy_borders)
	{
		window_fancy_borders(w.win);
		/* making the top line between 1st next and the rest */
		mvwaddch(w.win, 3, 0, ACS_LLCORNER|COLOR_PAIR(WHITE_BLACK));
		mvwhline(w.win, 3, 1, ACS_HLINE|COLOR_PAIR(BLACK_BLACK)|A_BOLD, w.width - 2);
		mvwaddch(w.win, 3, w.width - 1, ACS_LRCORNER|COLOR_PAIR(BLACK_BLACK)|A_BOLD);

		/* making the bottom line between 1st next and the rest */
		mvwaddch(w.win, 4, 0, ACS_ULCORNER|COLOR_PAIR(WHITE_BLACK)|A_BOLD);
		mvwhline(w.win, 4, 1, ACS_HLINE|COLOR_PAIR(WHITE_BLACK), w.width - 2);
		mvwaddch(w.win, 4, w.width - 1, ACS_URCORNER|COLOR_PAIR(WHITE_BLACK));

	}
	else
	{
		window_normal_borders(w.win);
		wattrset(w.win, engine_get_color(COLOR_BLACK, COLOR_BLACK, true));
		mvwhline(w.win, 3, 1, '-', w.width - 2);
	}
	wnoutrefresh(w.win);
	s->middle_right = w;

	/* right-most */
	w.width  = s->main.width - (s->middle_right.x + s->middle_right.width) - 3;
	w.height = s->main.height - 2; /* borders */
	w.x      = s->middle_right.x + s->middle_right.width + 1;
	w.y      = 1;
	w.win    = derwin(s->main.win, w.height, w.width, w.y, w.x);
	if (global.screen_fancy_borders)
		window_fancy_borders(w.win);
	else
		window_normal_borders(w.win);
	wnoutrefresh(w.win);
	s->rightmost = w;

	/* next pieces */
	w.width  = s->middle_right.width  - 2;
	w.height = s->middle_right.height - 2;
	w.x      = 1;
	w.y      = 1;
	w.win    = derwin(s->middle_right.win, w.height, w.width, w.y, w.x);
	wnoutrefresh(w.win);
	s->next_container = w;

	/* first next piece */
	w.width  = s->next_container.width;
	w.height = 2;
	w.x      = 0;
	w.y      = 0;
	w.win    = derwin(s->next_container.win, w.height, w.width, w.y, w.x);
	wnoutrefresh(w.win);
	s->next[0] = w;

	/* the rest */
	int i; int y_offset = 2;
	for (i = 1; i <= global.game_next_no; i++)
	{
		/* making all the next pieces 1 line lower */
		if (i != 1)
			y_offset = 0;

		w.width  = s->next_container.width;
		w.height = 2;
		w.x      = 0;
		w.y      = s->next[i - 1].y + s->next[i - 1].height + 1 + y_offset;
		w.win    = derwin(s->next_container.win, w.height, w.width, w.y, w.x);
		wnoutrefresh(w.win);
		s->next[i] = w;
	}

	s->board = new_sub_win_from(s->middle_left.win, (s->middle_left.width - 2), (s->middle_left.height - 2), 1, 1);

	s->info  = new_sub_win_from(s->rightmost.win,   (s->rightmost.width - 4),   (s->rightmost.height - 2),   2, 1);

	s->leftmost_container = new_sub_win_from(s->leftmost.win,
											 (s->leftmost.width - 2),
											 (s->leftmost.height - 2),
											 1,
											 1);

	s->hold = new_sub_win_from(s->leftmost_container.win,
							   s->leftmost_container.width,
							   4,
							   0,
							   0);

	s->score = new_sub_win_from(s->leftmost_container.win,
								s->leftmost_container.width,
								s->leftmost_container.height - (s->hold.height) - 2,
								0,
								s->hold.y + s->hold.height + 2);

	/* w.width  = s->leftmost_container.width; */
	/* w.height = s->leftmost_container.height - (s->hold.height) - 2; */
	/* w.x      = 0; */
	/* w.y      = s->hold.y + s->hold.height + 2; */
	/* w.win    = derwin(s->leftmost_container.win, w.height, w.width, w.y, w.x); */
	/* wnoutrefresh(w.win); */
	/* s->score = w; */

	w = s->info;
	wattrset(w.win, engine_get_color(COLOR_WHITE, COLOR_BLACK, true));
	mvwaddstr(w.win, w.height - 1, 16 , "Loading");
	wnoutrefresh(w.win);
	return 1;
}
コード例 #2
0
ファイル: NCMenu.cpp プロジェクト: ronw23/prime-osx
void
shNCursesMenu::accumulateResults ()
{
    const int map_end = 64; /* column map ends */
    WINDOW *win, *helpwin = NULL;
    PANEL *panel, *helppanel = NULL;

    int helplines;
    free (prepareHelp (&helplines));

    /* Two additional lines besides all the choices are the menu title
       and --End-- or --More-- at the bottom. */
    mItemHeight = mini (mHeight - helplines, mChoices.count () + 2);
    int width = 10;
    int gap = 0; /* Used to position the menu. */
    for (int i = 0; i < mChoices.count (); ++i) {
        width = maxi (width, strlen (mChoices.get (i)->mText) + 1);
    }
    if (!(mFlags & kNoPick)) width += 10; /* Adjust for "( ) x - " prompts. */
    /* Main header might be still longer. */
    width = maxi (width, strlen (mPrompt) + 2);
    if (mFlags & kCategorizeObjects) { /* Do not center item lists. */
        /* Determine whether window can leave sidebar unobscured. */
        if (width <= map_end) { /* Yes! */
            width = map_end;
        } else {                /* No, so hide it whole. */
            width = mWidth;
        }
    } else {
        width = mini (mWidth, width);
        if (width > map_end) { /* Would obscure side bar window? */
            width = mWidth;    /* Then cover it whole. */
        } else { /* Place small gap between sidebar and menu if possible. */
            gap = mini (10, (map_end - width) / 2);
        }
    }

    win = newwin (mItemHeight, width, 0, maxi (0, map_end - width) - gap);
    if (!win) {
        debug.log ("Unable to create window (%d, %d, %d, %d)",
                  mItemHeight, width, 0, maxi (0, map_end - width));
        I->p ("Uh oh!  Couldn't create window!!");
        mDone = 1;
        return;
    }
    keypad (win, TRUE);
    panel = new_panel (win);
    if (helplines) {
        helpwin = newwin (helplines, 80, mHeight - helplines, 0);
        if (!helpwin) {
            debug.log ("Unable to create help window (%d, %d, %d, %d)",
                      helplines, 80, mHeight - helplines, 0);
            I->p ("Uh oh!  Couldn't create help window!!");
            mDone = 1;
            return;
        }
        helppanel = new_panel (helpwin);
        showHelp (helpwin);
    }

    /* -2 lines to make space for header and --End-- or similar. */
    mLast = mini (mOffset + mItemHeight - 2, mChoices.count ());
    while (1) { /* Menu loop. */
        /* Menu header: */
        wattrset (win, A_BOLD);
        mvwaddnstr (win, 0, 1, mPrompt, width);
        wclrtoeol (win);

        wattrset (win, A_NORMAL);
        int i;
        for (i = mOffset; i < mLast; ++i) {
            /* First, clear line. */
            wmove (win, 1 + i - mOffset, 0);
            wclrtoeol (win);
            /* Then draw. */
            char buf[100];
            shMenuChoice *item = mChoices.get (i);

            if (item->mLetter >= 0 and (shMenu::kCategorizeObjects & mFlags)
                and ((shObject *) item->mValue.mPtr)->isKnownRadioactive ())
            {
                wattrset (win, ColorMap[kGreen]);
            }
            if (-2 == item->mLetter) { /* This is a pretty delimiter. */
                int len = strlen (item->mText);
                int j = (width - len) / 2;
                char *spaces = GetBuf ();
                for (int i = 0; i < j; ++i) {
                    spaces[i] = ' ';
                }
                spaces[j] = '\0';
                snprintf (buf, 100, "%s%s%s", spaces, item->mText, spaces);
            } else if (-1 == item->mLetter) { /* This is a header entry. */
                if (kCategorizeObjects & mFlags and mFlags & kMultiPick) {
                    /* Get category header. */
                    char part[50];
                    snprintf (part, 50, " %s ", item->mText);
                    char *gap = strstr (part, "  "); /* Find gap. */
                    gap[1] = 0; /* Truncate. */
                    wattrset (win, A_REVERSE);
                    mvwaddnstr (win, 1 + i - mOffset, 1, part, width);
                    /* Get (toggle all with X) part. */
                    char *p2 = strstr (item->mText, "(t");
                    int len = strlen (p2);
                    snprintf (part, len-2, "%s", item->mText);
                    wattrset (win, ColorMap[kBlue]);
                    mvwaddnstr (win, 1 + i - mOffset, width-21, p2, width);
                    /* The toggle key should stand out. */
                    snprintf (buf, len - 1, "%c", p2[len - 2]);
                    mvwaddch (win, 1 + i - mOffset, width-21+len-2,
                              p2[len - 2] | ColorMap[kWhite]);
                    buf[0] = 0; /* Printing is done. */
                } else {
                    wattrset (win, A_REVERSE);
                    snprintf (buf, 100, " %s ", item->mText);
                }
            } else if (mFlags & kNoPick) {
                if (' ' == item->mLetter) {
                    snprintf (buf, 100, "%s", item->mText);
                } else {
                    snprintf (buf, 100, "%c - %s", item->mLetter, item->mText);
                }
            } else {
                if (' ' == item->mLetter) {
                    snprintf (buf, 100, "        %s", item->mText);
                } else if (mFlags & kShowCount) {
                    if (item->mSelected) {
                        snprintf (buf, 100, "(%d) %c - %s",
                            item->mSelected, item->mLetter, item->mText);
                    } else {
                        snprintf (buf, 100, "( ) %c - %s",
                            item->mLetter, item->mText);
                    }
                } else {
                    snprintf (buf, 100, "(%c) %c - %s",
                              0 == item->mSelected ? ' ' :
                              item->mCount == item->mSelected ? 'X' : '#',
                              item->mLetter, item->mText);
                }
            }
            mvwaddnstr (win, 1 + i - mOffset, 1, buf, width);
            wattrset (win, A_NORMAL);
        }
        mvwaddnstr (win, 1 + i - mOffset, 1, bottomLine (i), width);

        while (1) {
            if (helplines) {
                showHelp (helpwin);
                touchwin (helpwin);
            }
            update_panels ();
            doupdate();
            int key = I->getChar ();

            if (27 == key or 13 == key or ' ' == key) { /* done */
                mDone = 1; break;
            } else if (KEY_BACKSPACE == key) {
                interpretKey (0, shInterface::kDrop); break;
            } else if (KEY_HOME == key or KEY_A1 == key) {
                interpretKey (0, shInterface::kMoveNW); break;
            } else if (KEY_END == key or KEY_C1 == key) {
                interpretKey (0, shInterface::kMoveSW); break;
            } else if (KEY_UP == key) {
                interpretKey (0, shInterface::kMoveUp); break;
            } else if (KEY_DOWN == key) {
                interpretKey (0, shInterface::kMoveDown); break;
            } else if (KEY_PPAGE == key or KEY_LEFT == key or KEY_A3 == key) {
                interpretKey (0, shInterface::kMoveNE); break;
            } else if (KEY_NPAGE == key or KEY_RIGHT == key or KEY_C3 == key) {
                interpretKey (0, shInterface::kMoveSE); break;
            } else if ('\t' == key and mHelpFileName) { /* invoke help */
                interpretKey (0, shInterface::kHelp); break;
            } else if (mFlags & kNoPick) {
                continue;
            } else {
                if (interpretKey (key)) break;
            }
            if (mDone) break;
        }
        if (mDone) break;
    }
    /* Clean up. */
    hide_panel (panel);
    del_panel (panel);
    delwin (win);
    if (helplines) {
        hide_panel (helppanel);
        del_panel (helppanel);
        delwin (helpwin);
    }
    update_panels ();
    I->drawScreen ();
}
コード例 #3
0
ファイル: help.cpp プロジェクト: alexandruradovici/linuxeyes
void help(int scr)
{
  int v,k;
  char s[200][100];
  strcpy (s[0],"COMMAND LINE");
  strcpy (s[1]," -p           : play");
  strcpy (s[2]," --nocolors   : B&W, for dummy terminals (telnet)");
  strcpy (s[3]," --autoscr    : autodetect the screen's size (BETA)");
  strcpy (s[4]," --fakelines  : draw lines on terminals without ACS");
  strcpy (s[5]," --new_start  : start with default configuration");
  strcpy (s[6],"");
  strcpy (s[7],"PLAYER");
  strcpy (s[8]," z            : previous");
  strcpy (s[9]," x            : play");
  strcpy (s[10]," c            : pause");
  strcpy (s[11]," v            : stop");
  strcpy (s[12]," b            : next");
  strcpy (s[13]," s            : Shuffle On/Off");
  strcpy (s[14]," <ENTER>      : Play ");
  strcpy (s[15]," <SPACE BAR>  : Set As Next ");
  strcpy (s[16]," <TAB>        : Add/Remove to/from filter ");
  strcpy (s[17]," f            : On/Off persistent filter ");
  strcpy (s[18]," F            : Clear filter ");
  strcpy (s[19]," <LEFT>       : Backward");
  strcpy (s[20]," <RIGHT>      : Forward");
  strcpy (s[21]," r            : Repreat current song ");
  strcpy (s[22]," i            : ID3v1.1 TAG Editor (for selected song)");
  strcpy (s[23]," I            : ID3v1.1 TAG Editor (for current song))");
  strcpy (s[24]," j or F3      : Jump to file");
  strcpy (s[25]," <INSERT>     : Volume + ");
  strcpy (s[26]," <DELETE>     : Volume - ");
  strcpy (s[27]," <HOME>       : PCM + ");
  strcpy (s[28]," <END>        : PCM - ");
  strcpy (s[29]," <            : Balance left ");
  strcpy (s[30]," >            : Balance right ");
  strcpy (s[31]," e            : Equalizer");
  strcpy (s[32]," '            : Repaint Desktop");
  strcpy (s[33]," *            : Increase desktop width");
  strcpy (s[34]," /            : Decrease desktop width");
  strcpy (s[35]," +            : Increase desktop height");
  strcpy (s[36]," -            : Decrease desktop height");
  strcpy (s[37]," t            : Switch clock display mode");
  strcpy (s[38]," \\            : Change Password");
  strcpy (s[39]," !            : Lock Display");
  strcpy (s[40]," =            : Switch Status Bar Format");
  strcpy (s[41]," h or F1      : Help");
  strcpy (s[42]," ?            : About and Statistics");
  strcpy (s[43]," {            : Set Alarm (\"Radio\") On");
  strcpy (s[44]," }            : Set Alarm (\"Radio\") Off");
  strcpy (s[45]," T            : Set Sleep mode");
  strcpy (s[46]," |            : On/Off Shut Down mode");
  strcpy (s[47]," o            : Settings");
  strcpy (s[48]," Q            : Quit");
  strcpy (s[49],"");
  strcpy (s[50],"PLAYLIST");
  strcpy (s[51]," a            : Add File");
  strcpy (s[52]," d            : Delete File");
  strcpy (s[53]," D            : Add Directory");
  strcpy (s[54]," R            : Delete All");
  strcpy (s[55]," S            : Sort Playlist");
  strcpy (s[56]," <UP>         : Cursor Up");
  strcpy (s[57]," <DOWN>       : Cursor Down");
  strcpy (s[58]," <PAGE UP>    : Page Up");
  strcpy (s[59]," <PAGE DOWN>  : Page Down");
  strcpy (s[60]," 0..9         : Fast Scroll");
  strcpy (s[61]," [            : Move Up");
  strcpy (s[62]," '            : Move Down");
  strcpy (s[63]," l            : Locate Current Song");
  strcpy (s[64]," L            : Autolocate Current Song");
  strcpy (s[65]," p            : Playlist Options");
  strcpy (s[66]," p,n          : New Playlist");
  strcpy (s[67]," p,l          : Load Playlist");
  strcpy (s[68]," p,s          : Save Playlist");
  strcpy (s[69]," p,i          : Import Playlist");
  strcpy (s[70]," p,e          : Export Playlist");
  strcpy (s[71]," E            : Edit playlist file entry");
  strcpy (s[72]," n            : Refresh list");
  strcpy (s[73]," ;            : On/Off save playlist position on exit");
  strcpy (s[74],"");
  strcpy (s[75],"JUMP TO FILE");
  strcpy (s[76]," <ENTER>      : Play");
  strcpy (s[77]," <SPACE BAR>  : Set as next");
  strcpy (s[78]," <TAB>        : Add/Remove to/from filter");
  strcpy (s[79]," F            : Add/Remove all songs to filter");
  strcpy (s[80]," i            : ID3 TAG Edditor");
  strcpy (s[81]," ESC or q     : Close window");
  strcpy (s[82],"");
  strcpy (s[83],"EQUALIZER WINDOW");
  strcpy (s[84]," <PAGE UP>    : Up ALL");
  strcpy (s[85]," <PAGE DOWN>  : Down ALL");
  strcpy (s[86]," a/z          : Up/Down Band #1");
  strcpy (s[87]," s/x          : Up/Down Band #2");
  strcpy (s[88]," d/c          : Up/Down Band #3");
  strcpy (s[89]," f/v          : Up/Down Band #4");
  strcpy (s[90]," g/b          : Up/Down Band #5");
  strcpy (s[91]," h/n          : Up/Down Band #6");
  strcpy (s[92]," j/m          : Up/Down Band #7");
  strcpy (s[93]," k/,          : Up/Down Band #8");
  strcpy (s[94]," l/.          : Up/Down Band #9");
  strcpy (s[95]," ;//          : Up/Down Band #10");
  strcpy (s[96]," r            : Set all bands to 0 (reset equalizer)");
  strcpy (s[97]," L            : Load Preset");
  strcpy (s[98]," S            : Save Preset");
  strcpy (s[99]," I            : Import Preset(s)");
  strcpy (s[100]," D            : Delete Preset(s)");
  strcpy (s[101]," A            : On/Off Automatic Equalizer");
  strcpy (s[102],"");
  strcpy (s[103],"STATISTICS");
  strcpy (s[104]," R            : Reset current session statistics");
  strcpy (s[105],"");
  strcpy (s[106],"SPECIAL FUNCTIONS");
  strcpy (s[107]," P            : Save playlist for MP3 CD Player");
  strcpy (s[108],"                * Save your playlist (p,s). Make a");
  strcpy (s[109],"                  new playlist (p,n).Load Directory (D)");
  strcpy (s[110],"                  from the CD in your playlist.");
  strcpy (s[111],"                * Tested on JazzPIPER MCD650S");
  strcpy (s[112],"");
  strcpy (s[113],"PLAYER MODES");
  strcpy (s[114]," Normal       : Next song in playlist (don\'t shuffle)");
  strcpy (s[115]," Shuffle      : Random next song (shuffle)");
  strcpy (s[116]," Next Song    : Next song is already selected");
  strcpy (s[117]," Filter       : There are files in the filter");
  strcpy (s[118]," P-Filter     : The filter is persistent");
  strcpy (s[119]," Password     : Display is locked with password");
  strcpy (s[120]," Radio        : Start/Stop music at a specific time");
  strcpy (s[121]," Sleep        : Shut Down at a specific time");
  strcpy (s[122]," Shut Down    : Shut Down after current song");
  WINDOW *w1;
  w1=newwin (scr+2,62,7,(nrcols-62)/2);
  wrefresh (w1);
  werase (w1);
  WINDOW *w;
  w=newwin (scr,60,8,(nrcols-60)/2);
  wsetcolor (w,12,0);
  for (int h=0;h<=scr+2;h++) mvwprintw (w,h,0,"                                                             ");
  wsetcolor (w,12,0);
  le_border (w,60,scr);
  wsetcolor (w,13,1);
  mvwprintw (w,0,1," Help ");
  wsetcolor (w,12,0);
  mvwprintw (w,scr-1,46," ESC - quit ");
  wrefresh(w);
  noecho();
  timeout (1);
  k=0;
  do
  {
    wsetcolor (w,12,0);
    for (int i=0;i<=scr-5;i++) 
    {
      mvwprintw (w,2+i,2,"                                                         ");
      mvwprintw (w,2+i,2,"%s",s[i+k]);
    }
    wsetcolor (w,12,0);
    mvwaddch (w,0,28,ACS_HLINE);
    mvwaddch (w,scr-1,28,ACS_HLINE);
    wsetcolor (w,12,1);
    if (k>0) mvwaddch (w,0,28,ACS_UARROW);
    if (k<93-(scr-5)) mvwaddch (w,scr-1,28,ACS_DARROW);
    wrefresh(w);
    do
    {
      messages();
      v=getch();
    } while (v==ERR);
    if (v == 27) 
    {
      v=getch();
      if (v==ERR) v='q';
      if (v==91)
      {
        v=getch();
	if (v==65) if (k > 0) k--;
        if (v==66) if (k < 122-(scr-5)) k++;
      }
    }
  }    
  while (v!='q');
  werase (w);
  reread=1;
}
コード例 #4
0
void
redraw_attr_dialog(void)
{
	const char *title;
	int x, y;
	size_t title_len;
	int need_ellipsis;

	werase(change_win);
	if(file_is_dir)
		wresize(change_win, 22, 30);
	else
		wresize(change_win, 20, 30);

	mvwaddstr(change_win, 3, 2, "Owner [ ] Read");
	if(perms[0])
		mvwaddch(change_win, 3, 9, (perms[0] < 0) ? 'X' : '*');
	mvwaddstr(change_win, 4, 6, "  [ ] Write");

	if(perms[1])
		mvwaddch(change_win, 4, 9, (perms[1] < 0) ? 'X' : '*');
	mvwaddstr(change_win, 5, 6, "  [ ] Execute");

	if(perms[2])
		mvwaddch(change_win, 5, 9, (perms[2] < 0) ? 'X' : '*');

	mvwaddstr(change_win, 6, 6, "  [ ] SetUID");
	if(perms[3])
		mvwaddch(change_win, 6, 9, (perms[3] < 0) ? 'X' : '*');

	mvwaddstr(change_win, 8, 2, "Group [ ] Read");
	if(perms[4])
		mvwaddch(change_win, 8, 9, (perms[4] < 0) ? 'X' : '*');

	mvwaddstr(change_win, 9, 6, "  [ ] Write");
	if(perms[5])
		mvwaddch(change_win, 9, 9, (perms[5] < 0) ? 'X' : '*');

	mvwaddstr(change_win, 10, 6, "  [ ] Execute");
	if(perms[6])
		mvwaddch(change_win, 10, 9, (perms[6] < 0) ? 'X' : '*');

	mvwaddstr(change_win, 11, 6, "  [ ] SetGID");
	if(perms[7])
		mvwaddch(change_win, 11, 9, (perms[7] < 0) ? 'X' : '*');

	mvwaddstr(change_win, 13, 2, "Other [ ] Read");
	if(perms[8])
		mvwaddch(change_win, 13, 9, (perms[8] < 0) ? 'X' : '*');

	mvwaddstr(change_win, 14, 6, "  [ ] Write");
	if(perms[9])
		mvwaddch(change_win, 14, 9, (perms[9] < 0) ? 'X' : '*');

	mvwaddstr(change_win, 15, 6, "  [ ] Execute");
	if(perms[10])
		mvwaddch(change_win, 15, 9, (perms[10] < 0) ? 'X' : '*');

	mvwaddstr(change_win, 16, 6, "  [ ] Sticky");
	if(perms[11])
		mvwaddch(change_win, 16, 9, (perms[11] < 0) ? 'X' : '*');

	if(file_is_dir)
		mvwaddstr(change_win, 18, 6, "  [ ] Set Recursively");

	getmaxyx(stdscr, y, x);
	mvwin(change_win, (y - (20 + (file_is_dir != 0)*2))/2, (x - 30)/2);
	box(change_win, 0, 0);

	x = getmaxx(change_win);
	title = get_title();
	title_len = strlen(title);
	need_ellipsis = (title_len > (size_t)x - 2);

	if(need_ellipsis)
	{
		x -= 3;
		title_len = x;
	}
	mvwaddnstr(change_win, 0, (getmaxx(change_win) - title_len)/2, title, x - 2);
	if(need_ellipsis)
	{
		waddstr(change_win, "...");
	}

	checked_wmove(change_win, curr, col);
	curs_set(1);
	wrefresh(change_win);
}
コード例 #5
0
ファイル: textbox.c プロジェクト: Mr-Aloof/wl500g
/*
 * Display text from a file in a dialog box.
 */
int dialog_textbox(const char *title, const char *tbuf,
		   int initial_height, int initial_width)
{
	int i, x, y, cur_x, cur_y, key = 0;
	int height, width, boxh, boxw;
	int passed_end;
	WINDOW *dialog, *box;

	begin_reached = 1;
	end_reached = 0;
	page_length = 0;
	hscroll = 0;
	buf = tbuf;
	page = buf;	/* page is pointer to start of page to be displayed */

do_resize:
	getmaxyx(stdscr, height, width);
	if (height < 8 || width < 8)
		return -ERRDISPLAYTOOSMALL;
	if (initial_height != 0)
		height = initial_height;
	else
		if (height > 4)
			height -= 4;
		else
			height = 0;
	if (initial_width != 0)
		width = initial_width;
	else
		if (width > 5)
			width -= 5;
		else
			width = 0;

	/* center dialog box on screen */
	x = (getmaxx(stdscr) - width) / 2;
	y = (getmaxy(stdscr) - height) / 2;

	draw_shadow(stdscr, y, x, height, width);

	dialog = newwin(height, width, y, x);
	keypad(dialog, TRUE);

	/* Create window for box region, used for scrolling text */
	boxh = height - 4;
	boxw = width - 2;
	box = subwin(dialog, boxh, boxw, y + 1, x + 1);
	wattrset(box, dlg.dialog.atr);
	wbkgdset(box, dlg.dialog.atr & A_COLOR);

	keypad(box, TRUE);

	/* register the new window, along with its borders */
	draw_box(dialog, 0, 0, height, width,
		 dlg.dialog.atr, dlg.border.atr);

	wattrset(dialog, dlg.border.atr);
	mvwaddch(dialog, height - 3, 0, ACS_LTEE);
	for (i = 0; i < width - 2; i++)
		waddch(dialog, ACS_HLINE);
	wattrset(dialog, dlg.dialog.atr);
	wbkgdset(dialog, dlg.dialog.atr & A_COLOR);
	waddch(dialog, ACS_RTEE);

	print_title(dialog, title, width);

	print_button(dialog, gettext(" Exit "), height - 2, width / 2 - 4, TRUE);
	wnoutrefresh(dialog);
	getyx(dialog, cur_y, cur_x);	/* Save cursor position */

	/* Print first page of text */
	attr_clear(box, boxh, boxw, dlg.dialog.atr);
	refresh_text_box(dialog, box, boxh, boxw, cur_y, cur_x);

	while ((key != KEY_ESC) && (key != '\n')) {
		key = wgetch(dialog);
		switch (key) {
		case 'E':	/* Exit */
		case 'e':
		case 'X':
		case 'x':
			delwin(box);
			delwin(dialog);
			return 0;
		case 'g':	/* First page */
		case KEY_HOME:
			if (!begin_reached) {
				begin_reached = 1;
				page = buf;
				refresh_text_box(dialog, box, boxh, boxw,
						 cur_y, cur_x);
			}
			break;
		case 'G':	/* Last page */
		case KEY_END:

			end_reached = 1;
			/* point to last char in buf */
			page = buf + strlen(buf);
			back_lines(boxh);
			refresh_text_box(dialog, box, boxh, boxw,
					 cur_y, cur_x);
			break;
		case 'K':	/* Previous line */
		case 'k':
		case KEY_UP:
			if (!begin_reached) {
				back_lines(page_length + 1);

				/* We don't call print_page() here but use
				 * scrolling to ensure faster screen update.
				 * However, 'end_reached' and 'page_length'
				 * should still be updated, and 'page' should
				 * point to start of next page. This is done
				 * by calling get_line() in the following
				 * 'for' loop. */
				scrollok(box, TRUE);
				wscrl(box, -1);	/* Scroll box region down one line */
				scrollok(box, FALSE);
				page_length = 0;
				passed_end = 0;
				for (i = 0; i < boxh; i++) {
					if (!i) {
						/* print first line of page */
						print_line(box, 0, boxw);
						wnoutrefresh(box);
					} else
						/* Called to update 'end_reached' and 'page' */
						get_line();
					if (!passed_end)
						page_length++;
					if (end_reached && !passed_end)
						passed_end = 1;
				}

				print_position(dialog);
				wmove(dialog, cur_y, cur_x);	/* Restore cursor position */
				wrefresh(dialog);
			}
			break;
		case 'B':	/* Previous page */
		case 'b':
		case KEY_PPAGE:
			if (begin_reached)
				break;
			back_lines(page_length + boxh);
			refresh_text_box(dialog, box, boxh, boxw,
					 cur_y, cur_x);
			break;
		case 'J':	/* Next line */
		case 'j':
		case KEY_DOWN:
			if (!end_reached) {
				begin_reached = 0;
				scrollok(box, TRUE);
				scroll(box);	/* Scroll box region up one line */
				scrollok(box, FALSE);
				print_line(box, boxh - 1, boxw);
				wnoutrefresh(box);
				print_position(dialog);
				wmove(dialog, cur_y, cur_x);	/* Restore cursor position */
				wrefresh(dialog);
			}
			break;
		case KEY_NPAGE:	/* Next page */
		case ' ':
			if (end_reached)
				break;

			begin_reached = 0;
			refresh_text_box(dialog, box, boxh, boxw,
					 cur_y, cur_x);
			break;
		case '0':	/* Beginning of line */
		case 'H':	/* Scroll left */
		case 'h':
		case KEY_LEFT:
			if (hscroll <= 0)
				break;

			if (key == '0')
				hscroll = 0;
			else
				hscroll--;
			/* Reprint current page to scroll horizontally */
			back_lines(page_length);
			refresh_text_box(dialog, box, boxh, boxw,
					 cur_y, cur_x);
			break;
		case 'L':	/* Scroll right */
		case 'l':
		case KEY_RIGHT:
			if (hscroll >= MAX_LEN)
				break;
			hscroll++;
			/* Reprint current page to scroll horizontally */
			back_lines(page_length);
			refresh_text_box(dialog, box, boxh, boxw,
					 cur_y, cur_x);
			break;
		case KEY_ESC:
			key = on_key_esc(dialog);
			break;
		case KEY_RESIZE:
			back_lines(height);
			delwin(box);
			delwin(dialog);
			on_key_resize();
			goto do_resize;
		}
	}
	delwin(box);
	delwin(dialog);
	return key;		/* ESC pressed */
}
コード例 #6
0
ファイル: xmas.c プロジェクト: UnitedMarsupials/kame
reindeer()
{
 int looper;

  y_pos = 0;


  for(x_pos = 70; x_pos > 62; x_pos--)
  {
    if(x_pos < 62)
    {
      y_pos = 1;
    }
    for(looper = 0; looper < 4; looper++)
    {
      mvwaddch(dotdeer0, y_pos, x_pos, (chtype)'.');
      wrefresh(dotdeer0);
      wrefresh(w_del_msg);
      werase(dotdeer0);
      wrefresh(dotdeer0);
      wrefresh(w_del_msg);
    }
  }

  y_pos = 2;

  for(; x_pos > 50; x_pos--)
  {

    for(looper = 0; looper < 4; looper++)
    {

      if(x_pos < 56)
      {
        y_pos = 3;

        mvwaddch(stardeer0, y_pos, x_pos, (chtype)'*');
        wrefresh(stardeer0);
        wrefresh(w_del_msg);
        werase(stardeer0);
        wrefresh(stardeer0);
        wrefresh(w_del_msg);
      }
      else
      {
        mvwaddch(dotdeer0, y_pos, x_pos, (chtype)'*');
        wrefresh(dotdeer0);
        wrefresh(w_del_msg);
        werase(dotdeer0);
        wrefresh(dotdeer0);
        wrefresh(w_del_msg);
      }
    }
  }

  x_pos = 58;

  for(y_pos = 2; y_pos < 5; y_pos++)
  {

    touchwin(lildeer0);
    wrefresh(lildeer0);
    wrefresh(w_del_msg);

    for(looper = 0; looper < 4; looper++)
    {
      mvwin(lildeer3, y_pos, x_pos);
      wrefresh(lildeer3);
      wrefresh(w_del_msg);

      mvwin(lildeer2, y_pos, x_pos);
      wrefresh(lildeer2);
      wrefresh(w_del_msg);

      mvwin(lildeer1, y_pos, x_pos);
      wrefresh(lildeer1);
      wrefresh(w_del_msg);

      mvwin(lildeer2, y_pos, x_pos);
      wrefresh(lildeer2);
      wrefresh(w_del_msg);

      mvwin(lildeer3, y_pos, x_pos);
      wrefresh(lildeer3);
      wrefresh(w_del_msg);

      touchwin(lildeer0);
      wrefresh(lildeer0);
      wrefresh(w_del_msg);

      x_pos -= 2;
    }
  }


  x_pos = 35;

  for(y_pos = 5; y_pos < 10; y_pos++)
  {

    touchwin(middeer0);
    wrefresh(middeer0);
    wrefresh(w_del_msg);

    for(looper = 0; looper < 2; looper++)
    {
      mvwin(middeer3, y_pos, x_pos);
      wrefresh(middeer3);
      wrefresh(w_del_msg);

      mvwin(middeer2, y_pos, x_pos);
      wrefresh(middeer2);
      wrefresh(w_del_msg);

      mvwin(middeer1, y_pos, x_pos);
      wrefresh(middeer1);
      wrefresh(w_del_msg);

      mvwin(middeer2, y_pos, x_pos);
      wrefresh(middeer2);
      wrefresh(w_del_msg);

      mvwin(middeer3, y_pos, x_pos);
      wrefresh(middeer3);
      wrefresh(w_del_msg);

      touchwin(middeer0);
      wrefresh(middeer0);
      wrefresh(w_del_msg);

      x_pos -= 3;
    }
  }

  usleep(2000);

  y_pos = 1;

  for(x_pos = 8; x_pos < 16; x_pos++)
  {

      mvwin(bigdeer4, y_pos, x_pos);
      wrefresh(bigdeer4);
      wrefresh(w_del_msg);

      mvwin(bigdeer3, y_pos, x_pos);
      wrefresh(bigdeer3);
      wrefresh(w_del_msg);

      mvwin(bigdeer2, y_pos, x_pos);
      wrefresh(bigdeer2);
      wrefresh(w_del_msg);

      mvwin(bigdeer1, y_pos, x_pos);
      wrefresh(bigdeer1);
      wrefresh(w_del_msg);

      mvwin(bigdeer2, y_pos, x_pos);
      wrefresh(bigdeer2);
      wrefresh(w_del_msg);

      mvwin(bigdeer3, y_pos, x_pos);
      wrefresh(bigdeer3);
      wrefresh(w_del_msg);

      mvwin(bigdeer4, y_pos, x_pos);
      wrefresh(bigdeer4);
      wrefresh(w_del_msg);

      mvwin(bigdeer0, y_pos, x_pos);
      wrefresh(bigdeer0);
      wrefresh(w_del_msg);
  }

    --x_pos;

    for(looper = 0; looper < 6; looper++)
    {
      mvwin(lookdeer4, y_pos, x_pos);
      wrefresh(lookdeer4);
      wrefresh(w_del_msg);

      mvwin(lookdeer3, y_pos, x_pos);
      wrefresh(lookdeer3);
      wrefresh(w_del_msg);

      mvwin(lookdeer2, y_pos, x_pos);
      wrefresh(lookdeer2);
      wrefresh(w_del_msg);

      mvwin(lookdeer1, y_pos, x_pos);
      wrefresh(lookdeer1);
      wrefresh(w_del_msg);

      mvwin(lookdeer2, y_pos, x_pos);
      wrefresh(lookdeer2);
      wrefresh(w_del_msg);

      mvwin(lookdeer3, y_pos, x_pos);
      wrefresh(lookdeer3);
      wrefresh(w_del_msg);

      mvwin(lookdeer4, y_pos, x_pos);
      wrefresh(lookdeer4);
      wrefresh(w_del_msg);

    }

    mvwin(lookdeer0, y_pos, x_pos);
    wrefresh(lookdeer0);
    wrefresh(w_del_msg);

  for(; y_pos < 10; y_pos++)
  {

    for(looper = 0; looper < 2; looper++)
    {
      mvwin(bigdeer4, y_pos, x_pos);
      wrefresh(bigdeer4);
      wrefresh(w_del_msg);

      mvwin(bigdeer3, y_pos, x_pos);
      wrefresh(bigdeer3);
      wrefresh(w_del_msg);

      mvwin(bigdeer2, y_pos, x_pos);
      wrefresh(bigdeer2);
      wrefresh(w_del_msg);

      mvwin(bigdeer1, y_pos, x_pos);
      wrefresh(bigdeer1);
      wrefresh(w_del_msg);

      mvwin(bigdeer2, y_pos, x_pos);
      wrefresh(bigdeer2);
      wrefresh(w_del_msg);

      mvwin(bigdeer3, y_pos, x_pos);
      wrefresh(bigdeer3);
      wrefresh(w_del_msg);

      mvwin(bigdeer4, y_pos, x_pos);
      wrefresh(bigdeer4);
      wrefresh(w_del_msg);
    }
      mvwin(bigdeer0, y_pos, x_pos);
      wrefresh(bigdeer0);
      wrefresh(w_del_msg);
  }

  --y_pos;

  mvwin(lookdeer3, y_pos, x_pos);
  wrefresh(lookdeer3);
  wrefresh(w_del_msg);
  return( 0 );
}
コード例 #7
0
// Pick up items at (posx, posy).
void Pickup::pick_up(int posx, int posy, int min)
{
    //min == -1 is Autopickup

    if (g->m.has_flag("SEALED", posx, posy)) {
        return;
    }

    if (!g->u.can_pickup(min != -1)) { // no message on autopickup (-1)
        return;
    }

    int veh_root_part = 0;
    int cargo_part = -1;

    vehicle *veh = g->m.veh_at (posx, posy, veh_root_part);
    bool from_vehicle = false;

    if( min != -1 ) {
        cargo_part = interact_with_vehicle( veh, posx, posy, veh_root_part );
        from_vehicle = cargo_part >= 0;
        if( cargo_part == -2 ) {
            return;
        }
    }

    if( !from_vehicle ) {
        bool isEmpty = (g->m.i_at(posx, posy).empty());

        // Hide the pickup window if this is a toilet and there's nothing here
        // but water.
        if ((!isEmpty) && g->m.furn(posx, posy) == f_toilet) {
            isEmpty = true;
            for (size_t i = 0; isEmpty && i < g->m.i_at(posx, posy).size(); i++) {
                if (g->m.i_at(posx, posy)[i].typeId() != "water") {
                    isEmpty = false;
                }
            }
        }

        if (isEmpty && (min != -1 || !OPTIONS["AUTO_PICKUP_ADJACENT"] )) {
            return;
        }
    }

    // which items are we grabbing?
    std::vector<item> here = (from_vehicle) ?
        veh->parts[cargo_part].items : g->m.i_at(posx, posy);

    if (min == -1) {
        if (g->checkZone("NO_AUTO_PICKUP", posx, posy)) {
            here.clear();
        }

        // Recursively pick up adjacent items if that option is on.
        if( OPTIONS["AUTO_PICKUP_ADJACENT"] && g->u.posx == posx && g->u.posy == posy ) {
            //Autopickup adjacent
            direction adjacentDir[8] = {NORTH, NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST, NORTHWEST};
            for (int i = 0; i < 8; i++) {

                point apos = direction_XY(adjacentDir[i]);
                apos.x += posx;
                apos.y += posy;

                if( g->m.has_flag( "SEALED", apos.x, apos.y ) ) {
                    continue;
                }
                if( g->checkZone( "NO_AUTO_PICKUP", apos.x, apos.y ) ) {
                    continue;
                }
                pick_up( apos.x, apos.y, min );
            }
        }
    }

    // Not many items, just grab them
    if ((int)here.size() <= min && min != -1) {
        g->u.assign_activity( ACT_PICKUP, 0 );
        g->u.activity.placement = point( posx, posy );
        g->u.activity.values.push_back( from_vehicle );
        // Only one item means index is 0.
        g->u.activity.values.push_back( 0 );
        // auto-pickup means pick up all.
        g->u.activity.values.push_back( 0 );
        return;
    }

    if(min != -1) { // don't bother if we're just autopickup-ing
        g->temp_exit_fullscreen();
    }
    bool sideStyle = use_narrow_sidebar();

    // Otherwise, we have Autopickup, 2 or more items and should list them, etc.
    int maxmaxitems = sideStyle ? TERMY : getmaxy(g->w_messages) - 3;

    int itemsH = std::min(25, TERMY / 2);
    int pickupBorderRows = 3;

    // The pickup list may consume the entire terminal, minus space needed for its
    // header/footer and the item info window.
    int minleftover = itemsH + pickupBorderRows;
    if(maxmaxitems > TERMY - minleftover) {
        maxmaxitems = TERMY - minleftover;
    }

    const int minmaxitems = sideStyle ? 6 : 9;

    std::vector<bool> getitem;
    getitem.resize(here.size(), false);

    int maxitems = here.size();
    maxitems = (maxitems < minmaxitems ? minmaxitems : (maxitems > maxmaxitems ? maxmaxitems :
                maxitems ));

    int pickupH = maxitems + pickupBorderRows;
    int pickupW = getmaxx(g->w_messages);
    int pickupY = VIEW_OFFSET_Y;
    int pickupX = getbegx(g->w_messages);

    int itemsW = pickupW;
    int itemsY = sideStyle ? pickupY + pickupH : TERMY - itemsH;
    int itemsX = pickupX;

    WINDOW *w_pickup    = newwin(pickupH, pickupW, pickupY, pickupX);
    WINDOW *w_item_info = newwin(itemsH,  itemsW,  itemsY,  itemsX);

    int ch = ' ';
    int start = 0, cur_it;
    int new_weight = g->u.weight_carried(), new_volume = g->u.volume_carried();
    bool update = true;
    mvwprintw(w_pickup, 0, 0, _("PICK UP"));
    int selected = 0;
    int last_selected = -1;

    int itemcount = 0;
    std::map<int, unsigned int> pickup_count; // Count of how many we'll pick up from each stack

    if (min == -1) { //Auto Pickup, select matching items
        if( !select_autopickup_items( here, getitem) ) {
            // If we didn't find anything, bail out now.
            return;
        }
    } else {
        if(g->was_fullscreen) {
            g->draw_ter();
        }
        // Now print the two lists; those on the ground and about to be added to inv
        // Continue until we hit return or space
        do {
            static const std::string pickup_chars =
                "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ:;";
            int idx = -1;
            for (int i = 1; i < pickupH; i++) {
                mvwprintw(w_pickup, i, 0,
                          "                                                ");
            }
            if (ch >= '0' && ch <= '9') {
                ch = (char)ch - '0';
                itemcount *= 10;
                itemcount += ch;
            } else if ((ch == '<' || ch == KEY_PPAGE) && start > 0) {
                start -= maxitems;
                selected = start;
                mvwprintw(w_pickup, maxitems + 2, 0, "         ");
            } else if ((ch == '>' || ch == KEY_NPAGE) && start + maxitems < (int)here.size()) {
                start += maxitems;
                selected = start;
                mvwprintw(w_pickup, maxitems + 2, pickupH, "            ");
            } else if ( ch == KEY_UP ) {
                selected--;
                if ( selected < 0 ) {
                    selected = here.size() - 1;
                    start = (int)( here.size() / maxitems ) * maxitems;
                    if (start >= (int)here.size()) {
                        start -= maxitems;
                    }
                } else if ( selected < start ) {
                    start -= maxitems;
                }
            } else if ( ch == KEY_DOWN ) {
                selected++;
                if ( selected >= (int)here.size() ) {
                    selected = 0;
                    start = 0;
                } else if ( selected >= start + maxitems ) {
                    start += maxitems;
                }
            } else if ( selected >= 0 && (
                            ( ch == KEY_RIGHT && !getitem[selected]) ||
                            ( ch == KEY_LEFT && getitem[selected] )
                        ) ) {
                idx = selected;
            } else if ( ch == '`' ) {
                std::string ext = string_input_popup(
                                      _("Enter 2 letters (case sensitive):"), 3, "", "", "", 2);
                if(ext.size() == 2) {
                    int p1 = pickup_chars.find(ext.at(0));
                    int p2 = pickup_chars.find(ext.at(1));
                    if ( p1 != -1 && p2 != -1 ) {
                        idx = pickup_chars.size() + ( p1 * pickup_chars.size() ) + p2;
                    }
                }
            } else {
                idx = pickup_chars.find(ch);
            }

            if( idx >= 0 && idx < (int)here.size()) {
                if (itemcount != 0 || pickup_count[idx] == 0) {
                    if (itemcount >= here[idx].charges || !here[idx].count_by_charges()) {
                        // Ignore the count if we pickup the whole stack anyway
                        // or something that is not counted by charges (tools)
                        itemcount = 0;
                    }
                    pickup_count[idx] = itemcount;
                    itemcount = 0;
                }

                getitem[idx] = ( ch == KEY_RIGHT ? true : ( ch == KEY_LEFT ? false : !getitem[idx] ) );
                if ( ch != KEY_RIGHT && ch != KEY_LEFT) {
                    selected = idx;
                    start = (int)( idx / maxitems ) * maxitems;
                }

                if (getitem[idx]) {
                    if (pickup_count[idx] != 0 &&
                        (int)pickup_count[idx] < here[idx].charges) {
                        item temp = here[idx].clone();
                        temp.charges = pickup_count[idx];
                        new_weight += temp.weight();
                        new_volume += temp.volume();
                    } else {
                        new_weight += here[idx].weight();
                        new_volume += here[idx].volume();
                    }
                } else if (pickup_count[idx] != 0 &&
                           (int)pickup_count[idx] < here[idx].charges) {
                    item temp = here[idx].clone();
                    temp.charges = pickup_count[idx];
                    new_weight -= temp.weight();
                    new_volume -= temp.volume();
                    pickup_count[idx] = 0;
                } else {
                    new_weight -= here[idx].weight();
                    new_volume -= here[idx].volume();
                }
                update = true;
            }

            if ( selected != last_selected ) {
                last_selected = selected;
                werase(w_item_info);
                if ( selected >= 0 && selected <= (int)here.size() - 1 ) {
                    std::vector<iteminfo> vThisItem, vDummy;
                    here[selected].info(true, &vThisItem);

                    draw_item_info(w_item_info, "", vThisItem, vDummy, 0, true, true);
                }
                draw_border(w_item_info);
                mvwprintz(w_item_info, 0, 2, c_white, "< %s >", here[selected].display_name().c_str());
                wrefresh(w_item_info);
            }

            if (ch == ',') {
                int count = 0;
                for (size_t i = 0; i < here.size(); i++) {
                    if (getitem[i]) {
                        count++;
                    } else {
                        new_weight += here[i].weight();
                        new_volume += here[i].volume();
                    }
                    getitem[i] = true;
                }
                if (count == (int)here.size()) {
                    for (size_t i = 0; i < here.size(); i++) {
                        getitem[i] = false;
                    }
                    new_weight = g->u.weight_carried();
                    new_volume = g->u.volume_carried();
                }
                update = true;
            }

            for (cur_it = start; cur_it < start + maxitems; cur_it++) {
                mvwprintw(w_pickup, 1 + (cur_it % maxitems), 0,
                          "                                        ");
                if (cur_it < (int)here.size()) {
                    nc_color icolor = here[cur_it].color(&g->u);
                    if (cur_it == selected) {
                        icolor = hilite(icolor);
                    }

                    if (cur_it < (int)pickup_chars.size() ) {
                        mvwputch(w_pickup, 1 + (cur_it % maxitems), 0, icolor,
                                 char(pickup_chars[cur_it]));
                    } else {
                        int p = cur_it - pickup_chars.size();
                        int p1 = p / pickup_chars.size();
                        int p2 = p % pickup_chars.size();
                        mvwprintz(w_pickup, 1 + (cur_it % maxitems), 0, icolor, "`%c%c",
                                  char(pickup_chars[p1]), char(pickup_chars[p2]));
                    }
                    if (getitem[cur_it]) {
                        if (pickup_count[cur_it] == 0) {
                            wprintz(w_pickup, c_ltblue, " + ");
                        } else {
                            wprintz(w_pickup, c_ltblue, " # ");
                        }
                    } else {
                        wprintw(w_pickup, " - ");
                    }
                    wprintz(w_pickup, icolor, "%s", here[cur_it].display_name().c_str());
                }
            }

            int pw = pickupW;
            const char *unmark = _("[left] Unmark");
            const char *scroll = _("[up/dn] Scroll");
            const char *mark   = _("[right] Mark");
            mvwprintw(w_pickup, maxitems + 1, 0,                         unmark);
            mvwprintw(w_pickup, maxitems + 1, (pw - strlen(scroll)) / 2, scroll);
            mvwprintw(w_pickup, maxitems + 1,  pw - strlen(mark),        mark);
            const char *prev = _("[pgup] Prev");
            const char *all = _("[,] All");
            const char *next   = _("[pgdn] Next");
            if (start > 0) {
                mvwprintw(w_pickup, maxitems + 2, 0, prev);
            }
            mvwprintw(w_pickup, maxitems + 2, (pw - strlen(all)) / 2, all);
            if (cur_it < (int)here.size()) {
                mvwprintw(w_pickup, maxitems + 2, pw - strlen(next), next);
            }

            if (update) { // Update weight & volume information
                update = false;
                for (int i = 9; i < pickupW; ++i) {
                    mvwaddch(w_pickup, 0, i, ' ');
                }
                mvwprintz(w_pickup, 0,  9,
                          (new_weight >= g->u.weight_capacity() ? c_red : c_white),
                          _("Wgt %.1f"), g->u.convert_weight(new_weight));
                wprintz(w_pickup, c_white, "/%.1f", g->u.convert_weight(g->u.weight_capacity()));
                mvwprintz(w_pickup, 0, 24,
                          (new_volume > g->u.volume_capacity() - 2 ? c_red : c_white),
                          _("Vol %d"), new_volume);
                wprintz(w_pickup, c_white, "/%d", g->u.volume_capacity() - 2);
            }
            wrefresh(w_pickup);

            ch = (int)getch();

        } while (ch != ' ' && ch != '\n' && ch != KEY_ESCAPE);

        if (ch != '\n') {
            werase(w_pickup);
            wrefresh(w_pickup);
            werase(w_item_info);
            wrefresh(w_item_info);
            delwin(w_pickup);
            delwin(w_item_info);
            add_msg(_("Never mind."));
            g->reenter_fullscreen();
            g->refresh_all();
            return;
        }
    }

    // At this point we've selected our items, register an activity to pick them up.
    g->u.assign_activity( ACT_PICKUP, 0 );
    g->u.activity.placement = point( posx, posy );
    g->u.activity.values.push_back( from_vehicle );
    for (size_t i = 0; i < here.size(); i++) {
        if( getitem[i] ) {
            g->u.activity.values.push_back( i );
            g->u.activity.values.push_back( pickup_count[i] );
        }
    }

    g->reenter_fullscreen();
    werase(w_pickup);
    wrefresh(w_pickup);
    werase(w_item_info);
    wrefresh(w_item_info);
    delwin(w_pickup);
    delwin(w_item_info);
}
コード例 #8
0
/*
 * Display a dialog box for inputing a string
 */
int dialog_inputbox(const char *title, const char *prompt, int height, int width,
                    const char *init)
{
	int i, x, y, box_y, box_x, box_width;
	int input_x = 0, scroll = 0, key = 0, button = -1;
	char *instr = dialog_input_result;
	WINDOW *dialog;

	if (!init)
		instr[0] = '\0';
	else
		strcpy(instr, init);

do_resize:
	if (getmaxy(stdscr) <= (height - 2))
		return -ERRDISPLAYTOOSMALL;
	if (getmaxx(stdscr) <= (width - 2))
		return -ERRDISPLAYTOOSMALL;

	/* center dialog box on screen */
	x = (COLS - width) / 2;
	y = (LINES - height) / 2;

	draw_shadow(stdscr, y, x, height, width);

	dialog = newwin(height, width, y, x);
	keypad(dialog, TRUE);

	draw_box(dialog, 0, 0, height, width,
		 dlg.dialog.atr, dlg.border.atr);
	(void)wattrset(dialog, dlg.border.atr);
	mvwaddch(dialog, height - 3, 0, ACS_LTEE);
	for (i = 0; i < width - 2; i++)
		waddch(dialog, ACS_HLINE);
	(void)wattrset(dialog, dlg.dialog.atr);
	waddch(dialog, ACS_RTEE);

	print_title(dialog, title, width);

	(void)wattrset(dialog, dlg.dialog.atr);
	print_autowrap(dialog, prompt, width - 2, 1, 3);

	/* Draw the input field box */
	box_width = width - 6;
	getyx(dialog, y, x);
	box_y = y + 2;
	box_x = (width - box_width) / 2;
	draw_box(dialog, y + 1, box_x - 1, 3, box_width + 2,
		 dlg.dialog.atr, dlg.border.atr);

	print_buttons(dialog, height, width, 0);

	/* Set up the initial value */
	wmove(dialog, box_y, box_x);
	(void)wattrset(dialog, dlg.inputbox.atr);

	input_x = strlen(instr);

	if (input_x >= box_width) {
		scroll = input_x - box_width + 1;
		input_x = box_width - 1;
		for (i = 0; i < box_width - 1; i++)
			waddch(dialog, instr[scroll + i]);
	} else {
		waddstr(dialog, instr);
	}

	wmove(dialog, box_y, box_x + input_x);

	wrefresh(dialog);

	while (key != KEY_ESC) {
		key = wgetch(dialog);

		if (button == -1) {	/* Input box selected */
			switch (key) {
			case TAB:
			case KEY_UP:
			case KEY_DOWN:
				break;
			case KEY_LEFT:
				continue;
			case KEY_RIGHT:
				continue;
			case KEY_BACKSPACE:
			case 127:
				if (input_x || scroll) {
					(void)wattrset(dialog, dlg.inputbox.atr);
					if (!input_x) {
						scroll = scroll < box_width - 1 ? 0 : scroll - (box_width - 1);
						wmove(dialog, box_y, box_x);
						for (i = 0; i < box_width; i++)
							waddch(dialog,
							       instr[scroll + input_x + i] ?
							       instr[scroll + input_x + i] : ' ');
						input_x = strlen(instr) - scroll;
					} else
						input_x--;
					instr[scroll + input_x] = '\0';
					mvwaddch(dialog, box_y, input_x + box_x, ' ');
					wmove(dialog, box_y, input_x + box_x);
					wrefresh(dialog);
				}
				continue;
			default:
				if (key < 0x100 && isprint(key)) {
					if (scroll + input_x < MAX_LEN) {
						(void)wattrset(dialog, dlg.inputbox.atr);
						instr[scroll + input_x] = key;
						instr[scroll + input_x + 1] = '\0';
						if (input_x == box_width - 1) {
							scroll++;
							wmove(dialog, box_y, box_x);
							for (i = 0; i < box_width - 1; i++)
								waddch(dialog, instr [scroll + i]);
						} else {
							wmove(dialog, box_y, input_x++ + box_x);
							waddch(dialog, key);
						}
						wrefresh(dialog);
					} else
						flash();	/* Alarm user about overflow */
					continue;
				}
			}
		}
		switch (key) {
		case 'O':
		case 'o':
			delwin(dialog);
			return 0;
		case 'H':
		case 'h':
			delwin(dialog);
			return 1;
		case KEY_UP:
		case KEY_LEFT:
			switch (button) {
			case -1:
				button = 1;	/* Indicates "Help" button is selected */
				print_buttons(dialog, height, width, 1);
				break;
			case 0:
				button = -1;	/* Indicates input box is selected */
				print_buttons(dialog, height, width, 0);
				wmove(dialog, box_y, box_x + input_x);
				wrefresh(dialog);
				break;
			case 1:
				button = 0;	/* Indicates "OK" button is selected */
				print_buttons(dialog, height, width, 0);
				break;
			}
			break;
		case TAB:
		case KEY_DOWN:
		case KEY_RIGHT:
			switch (button) {
			case -1:
				button = 0;	/* Indicates "OK" button is selected */
				print_buttons(dialog, height, width, 0);
				break;
			case 0:
				button = 1;	/* Indicates "Help" button is selected */
				print_buttons(dialog, height, width, 1);
				break;
			case 1:
				button = -1;	/* Indicates input box is selected */
				print_buttons(dialog, height, width, 0);
				wmove(dialog, box_y, box_x + input_x);
				wrefresh(dialog);
				break;
			}
			break;
		case ' ':
		case '\n':
			delwin(dialog);
			return (button == -1 ? 0 : button);
		case 'X':
		case 'x':
			key = KEY_ESC;
			break;
		case KEY_ESC:
			key = on_key_esc(dialog);
			break;
		case KEY_RESIZE:
			delwin(dialog);
			on_key_resize();
			goto do_resize;
		}
	}

	delwin(dialog);
	return KEY_ESC;		/* ESC pressed */
}
コード例 #9
0
ファイル: infopanel.cpp プロジェクト: grcjamezz/boinctui
void InfoPanel::refresh()
{
    if (srv == NULL)
	return;
    if (srv->statedom.empty())
    {
	needrefresh = true;
	werase(win);
	mvwprintw(win,0,0,"%s:%s\noffline",srv->gethost(),srv->getport());
	NView::refresh();
	return;
    }
    wattrset(win,getcolorpair(COLOR_WHITE,COLOR_BLACK));
    wattron(win, A_REVERSE);
    mvwprintw(win,0,0,"       Tasks        ");
    wattroff(win, A_REVERSE);

    mvwprintw(win,1,0,"all              %3d",nalltasks);
    mvwprintw(win,2,0,"active           %3d",nactivetasks);
    mvwprintw(win,3,0,"run              %3d",nruntasks);
    mvwprintw(win,4,0,"wait             %3d",nqueuetasks);
    mvwprintw(win,5,0,"done             %3d",ndonetasks);
    mvwprintw(win,6,0,"other            %3d",nothertasks);

    wattron(win,A_REVERSE);
    mvwprintw(win,7,0,"      Storage       ");
    wattroff(win,A_REVERSE);

    mvwprintw(win,8,0, "total     %8.2fGb",dtotal/(1024*1024*1024));
    mvwprintw(win,9,0, "free      %8.2fGb",dfree/(1024*1024*1024));
    mvwprintw(win,10,0,"allowed   %8.2fGb",dallowed/(1024*1024*1024));
    mvwprintw(win,11,0,"boinc     %8.2fGb",dboinc/(1024*1024*1024));

    wattron(win,A_REVERSE);
    mvwprintw(win,12,0,"     Statistics     ");
    wattroff(win,A_REVERSE);

    bool compact = true; //компактный вывод статистики если user=host
    int line,col;
    getyx(win,line,col);
    if ( (!compact)||(abs(usertotal - hosttotal) > 1) )
    {
	mvwprintw(win,line++,0,"user total%10.0f\n",usertotal);
	mvwprintw(win,line++,0,"host total%10.0f\n",hosttotal);
    }
    else
	mvwprintw(win,line++,0,"total     %10.0f\n",usertotal);
    if ( (!compact)||(abs(useravg - hostavg) > 1) )
    {
	mvwprintw(win,line++,0,"user avg  %10.0f\n",useravg);
	mvwprintw(win,line++,0,"host avg  %10.0f\n",hostavg);
    }
    else
	mvwprintw(win,line++,0,"average   %10.0f\n",useravg);
    tm* ltime = localtime(&laststattime);
    char buf[128];
    strftime(buf, sizeof(buf),"%-e %b",ltime); //"%-e %b %-k:%M"
    mvwprintw(win,line++,0,"%-s %s\n", buf, getdayname(laststattime).c_str()); //дата/время последней статистики
    //wattrset(win,0);
    if ( (!compact)||(abs(lastdayuser - lastdayhost) > 1) )
    {
	if ( asciilinedraw == 1)
	{
	    wmove(win,line++,0); wprintw(win,"+->user   %10.0f\n",lastdayuser);
	    wmove(win,line++,0); wprintw(win,"+->host   %10.0f\n",lastdayhost);
	}
	else
	{
	    mvwaddch(win,line++,0,ACS_LTEE);     waddch(win,ACS_HLINE); wprintw(win,">user   %10.0f\n",lastdayuser);
	    mvwaddch(win,line++,0,ACS_LLCORNER); waddch(win,ACS_HLINE); wprintw(win,">host   %10.0f\n",lastdayhost);
	}
    }
    else
    {
	if( asciilinedraw == 1)
	{
	    wmove(win,line++,0); wprintw(win,"-->daily  %10.0f\n",lastdayhost);
	}
	else
	{
	    mvwaddch(win,line++,0,ACS_LLCORNER); waddch(win,ACS_HLINE); wprintw(win,">daily  %10.0f\n",lastdayhost);
	}
    }
    //по проектам
    mvwprintw(win, line++,0,"\n");
    for (int i = 0; i < projects.size(); i++) //цикл по названиям проектов
    {
	//расчитываем нужное кол-во строк
	int needlines = 2;
	if (!projects[i].sstatus.empty())
	    needlines++;
	if ( (!compact)||(abs(projects[i].user - projects[i].host) > 1) )
	    needlines += 2;
	else
	    needlines++;
	if ( (!compact)||(abs(projects[i].userlastday - projects[i].hostlastday) > 1) )
	    needlines += 2;
	else
	    needlines++;
	//проверяем сколько свободных строк осталось в окне
	if ( ( getheight()-line ) < needlines )
	    break; //не выводим если осталось мало строк
	//вывод на экран о проекте
	wattrset(win,getcolorpair(COLOR_YELLOW,COLOR_BLACK));
	mvwprintw(win,line++,0,"%s\n",projects[i].name.c_str());
	if (!projects[i].sstatus.empty())
	{
	    wattrset(win,getcolorpair(COLOR_RED,COLOR_BLACK));
	    mvwprintw(win,line++,0,"%s\n",projects[i].sstatus.c_str());
	}
	wattrset(win,getcolorpair(COLOR_WHITE,COLOR_BLACK));
	if ( (!compact)||(abs(projects[i].user - projects[i].host) > 1) )
	{
	    mvwprintw(win,line++,0,"user total%10.0f\n",projects[i].user);
	    mvwprintw(win,line++,0,"host total%10.0f\n",projects[i].host);
	}
	else
	    mvwprintw(win,line++,0,"total     %10.0f\n",projects[i].user);
	ltime = localtime(&projects[i].laststattime);
	strftime(buf, sizeof(buf),"%-e %b",ltime); //"%-e %b %-k:%M"
	mvwprintw(win,line++,0,"%-s %s\n",buf, getdayname(projects[i].laststattime).c_str());
	if ( (!compact)||(abs(projects[i].userlastday - projects[i].hostlastday) > 1) )
	{
	    if (asciilinedraw == 1)
	    {
		wmove(win,line++,0); wprintw(win,"+->user   %10.0f\n",projects[i].userlastday);
		wmove(win,line++,0); wprintw(win,"+->host   %10.0f\n",projects[i].hostlastday);
	    }
	    else
	    {
		mvwaddch(win,line++,0,ACS_LTEE);     waddch(win,ACS_HLINE); wprintw(win,">user   %10.0f\n",projects[i].userlastday);
		mvwaddch(win,line++,0,ACS_LLCORNER); waddch(win,ACS_HLINE); wprintw(win,">host   %10.0f\n",projects[i].hostlastday);
	    }
	}
	else
	{
	    if (asciilinedraw == 1)
	    {
		wmove(win,line++,0); wprintw(win,"-->daily  %10.0f\n",projects[i].userlastday);
	    }
	    else
	    {
		mvwaddch(win,line++,0,ACS_LLCORNER); waddch(win,ACS_HLINE); wprintw(win,">daily  %10.0f\n",projects[i].userlastday);
	    }
	}
    }
    if ( line < getheight() )
	wclrtobot(win); //чистим нижню часть окна (если не это не последняя строка иначе сотрем символ в правом нижнем)
    NView::refresh();
}
コード例 #10
0
ファイル: client.cpp プロジェクト: Kavarenshko/Eurisko
void drawTree(WINDOW** tv, Group* current, int start_y, int start_x, int highlighted_id)
{
    wmove(*tv, start_y, start_x);
    wattron(*tv, A_BOLD);
    if (highlighted_id == current->id)
        wattron(*tv, COLOR_PAIR(2));
    wprintw(*tv, current->name.c_str());
    wattron(*tv, COLOR_PAIR(1));
    wattroff(*tv, A_BOLD);
    if (current->id == 2)
    {
        wprintw(*tv, " - Data&Ora");
    }
    //wprintw(*tv, " %s%s%s%s%s%s%s", (current->attrs & (1<<7)? "RT ":""), (current->attrs & (1<<6))? "AB ":""), (current->attrs & (1<<5)? "PW ":""), (current->attrs & (1<<4)? "WH ":""), (current->attrs & (1<<3)? "CA ":""), (current->attrs & (1<<2)? "FC ":""), (current->attrs & (1<<1)? "UNK ":""));
    //wprintw(*tv, " %s", getAttrs(current).c_str());
    start_y += 1;

    for(auto it = current->children.begin(); it < current->children.end(); it++)
    {
        if (it == current->children.begin()) // VLINE + TEE
        {
            mvwaddch(*tv, start_y++, start_x, ACS_VLINE);
            mvwaddch(*tv, start_y, start_x++, ACS_LTEE);
            mvwaddch(*tv, start_y, start_x++, ACS_HLINE);
            mvwaddch(*tv, start_y, start_x++, ACS_HLINE);
            mvwaddch(*tv, start_y, start_x++, ACS_HLINE);
            drawTree(tv, *it, start_y, start_x+1, highlighted_id);
        }
        else if (it == (current->children.end()-1)) // last element, VLINE + LRCORNER
        {
            start_x -= 4;
            start_y += 1;
            for(unsigned i=0; i < (*(it-1))->total_subgroups; i++)
            {
                // 2*VLINE + VLINE + TEE
                mvwaddch(*tv, start_y++, start_x, ACS_VLINE);
                mvwaddch(*tv, start_y++, start_x, ACS_VLINE);
            }
            mvwaddch(*tv, start_y++, start_x, ACS_VLINE);
            mvwaddch(*tv, start_y, start_x++, ACS_LLCORNER);
            mvwaddch(*tv, start_y, start_x++, ACS_HLINE);
            mvwaddch(*tv, start_y, start_x++, ACS_HLINE);
            mvwaddch(*tv, start_y, start_x++, ACS_HLINE);
            drawTree(tv, *it, start_y, start_x+1, highlighted_id);
        }
        else
        {
            // get the total_subgroup count of the group before in order to know how many VLINEs we need
            start_x -= 4;
            start_y += 1;
            for(unsigned i=0; i < (*(it-1))->total_subgroups; i++)
            {
                // 2*VLINE + VLINE + TEE
                mvwaddch(*tv, start_y++, start_x, ACS_VLINE);
                mvwaddch(*tv, start_y++, start_x, ACS_VLINE);
            }
            mvwaddch(*tv, start_y++, start_x, ACS_VLINE);
            mvwaddch(*tv, start_y, start_x++, ACS_LTEE);
            mvwaddch(*tv, start_y, start_x++, ACS_HLINE);
            mvwaddch(*tv, start_y, start_x++, ACS_HLINE);
            mvwaddch(*tv, start_y, start_x++, ACS_HLINE);
            drawTree(tv, *it, start_y, start_x+1, highlighted_id);
        }
    }

    wrefresh(*tv);
}
コード例 #11
0
ファイル: client.cpp プロジェクト: Kavarenshko/Eurisko
int main()
{
    int max_rows, max_cols;
    int fake = 7;

	WINDOW* statusbar = nullptr;
	WINDOW* treeview = nullptr;
	WINDOW* commandline = nullptr;

	pugi::xml_document doc;
	pugi::xml_parse_result result;
	struct Group* root;
    struct Group* current_selection;

	std::string command = "";

	char server_addr[IP_ADDRLEN] = "127.0.0.1";
	char buffer[8192];
	unsigned short port = 26750;
	struct sockaddr_in server;
	struct in_addr addr;
	socklen_t server_size = sizeof server;
	int sock;
	int packlen;

	initscr();
    getmaxyx(stdscr, max_rows, max_cols);

	if (has_colors() == FALSE)
	{
		endwin();
		std::cerr << "\nncurses: colors not supported.\n";
		return 1;
	}

	start_color();
	init_pair(1, COLOR_WHITE, COLOR_BLACK);
	init_pair(2, COLOR_RED, COLOR_BLACK);

	attron(COLOR_PAIR(1));
	//attron(A_BOLD);

	cbreak(); // we don't need to push [enter]
	noecho(); // pressed keys are not displayed
	keypad(stdscr, TRUE);
    keypad(commandline, TRUE);

	move(7,1);
	printw("Sending request to %s:%i...", server_addr, port);

	std::string packet_1 = "1oeila";
	const unsigned packet_1_len = packet_1.length();

	if (inet_pton(AF_INET, server_addr, &addr) <= 0) // returns 1 on success
    {
        printw("Invalid IP address (inet_pton).");
        refresh();
        getch();
        endwin();
        return 1;
    }

	memset(&server, 0, sizeof server);
	server.sin_family = AF_INET;
    server.sin_port = htons(port);
    server.sin_addr = addr;

	sock = socket(AF_INET, SOCK_DGRAM, 0);

	packlen = sendto(sock, packet_1.c_str(), packet_1_len, 0, (struct sockaddr*)&server, sizeof(server));
	if (packlen <= 0)
	{
		printw("error");
		refresh();
		getch();
		endwin();
		return 1;
	}
	printw("done");
	move(8,1);
	printw("Waiting for response...");
	refresh();

	packlen = recvfrom(sock, buffer, sizeof buffer, 0, (struct sockaddr*)&server, &server_size);
	if (packlen <= 0)
	{
		printw("error");
		refresh();
		getch();
		endwin();
		return 1;
	}
	printw("done");

	move(9,1);
    printw("Loading tree...");
	result = doc.load_buffer(buffer, sizeof buffer);

	switch (result.status)
    {
        case pugi::status_ok:
        {
        	printw("done");
        	move(10,1);
        	printw("Rebuilding tree...");
        	root = populate_tree(doc.first_child().first_child());  // -> TreeStructure -> Root 
        	if (root == nullptr)
        	{
        		refresh();
        		getch();
        		endwin();
        		return 1;
        	}
        	else
            {
        		printw("done");
                getch();
            }
            break;
        }
        case pugi::status_io_error:
        case pugi::status_file_not_found:
        {
            printw("IO error.");
            refresh();
            getchar();
            endwin();
            return 1;
        }
        case pugi::status_out_of_memory:
        {
            printw("out of memory.");
            refresh();
            getchar();
            endwin();
            return 1;
        }
        case pugi::status_internal_error:
        {
            printw("internal error while loading.");
            refresh();
            getchar();
            endwin();
            return 1;
        }
        default:
        {
            printw("error while parsing.");
            refresh();
            getchar();
            endwin();
            return 1;
        }
    }

    drawWindows(&statusbar, &treeview, &commandline);
    drawTree(&treeview, root, 2, 3, 1);
    mvwprintw(statusbar, 1, max_cols-18, "Total groups: %i", root->total_subgroups+1);
    wrefresh(statusbar);

    wmove(commandline, 1, 3);

    current_selection = root;

    while (1)
    {
    	int keypress = getch();

        if (keypress == KEY_LEFT) // return to father node
        {
            if (current_selection->father != nullptr) // if not root
            {
                current_selection = current_selection->father;
                drawTree(&treeview, root, 2, 3, current_selection->id);
            }
        }
        else if (keypress == KEY_RIGHT) // enter the first child
        {
            if (current_selection->total_subgroups) // if has children
            {
                current_selection = current_selection->children[0];
                drawTree(&treeview, root, 2, 3, current_selection->id);
            }
        }
        else if (keypress == KEY_UP) // navigate through siblings
        {
            if (current_selection->id > 1) // if not root
            {
                int sibling_index = getIndexById(current_selection->father, current_selection->id) - 1;

                if (sibling_index >= 0) // check bounds
                {
                    current_selection = current_selection->father->children[sibling_index];
                    drawTree(&treeview, root, 2, 3, current_selection->id);
                }
            }
        }
        else if (keypress == KEY_DOWN) // navigate through siblings
        {
            if (current_selection->id > 1) // if not root
            {
                int sibling_index = getIndexById(current_selection->father, current_selection->id) + 1;

                if (sibling_index < current_selection->father->children.size()) // check bounds
                {
                    current_selection = current_selection->father->children[sibling_index];
                    drawTree(&treeview, root, 2, 3, current_selection->id);
                }
            }
        }
    	else if ((keypress >= 'A' && keypress <= 'Z') || (keypress >= 'a' && keypress <= 'z') || (keypress >= '0' && keypress <= '9') || keypress == ' ') // command
    	{
    		command += (char)keypress;
    		waddch(commandline, keypress);
    		wrefresh(commandline);
    	}
    	else if (keypress == 127 || keypress == 8) // backspace
    	{
    		int slen = command.length(), c_y, c_x;
    		if (slen > 0)
    		{
    			command.erase(command.end()-1);
    			getyx(commandline, c_y, c_x);
    			mvwaddch(commandline, c_y, c_x-1, ' ');
                wmove(commandline, c_y, c_x-1);
                wrefresh(commandline);
    		}
        }
    	else if (keypress == 10) // enter
    	{
            if (command == "")
            {
                endwin();
                delete root;
                return 1;
            }

            std::string buf;
            std::vector<std::string> tokens;
            std::stringstream ss(command);

            // split the command into individual words (delim == ' ')

            while (ss >> buf)
            {
                tokens.push_back(buf);
            }

            /*if (tokens[0] == "datetime")
            {
                time_t current_time;
                struct tm* time_info;
                char timeString[9];

                time(&current_time);
                time_info = localtime(&current_time);
                strftime(timeString, sizeof(timeString), "%H:%M:%S", time_info);

                mvwprintw(treeview, fake++, 50, ">> server replies: %s", timeString);
                wrefresh(treeview);
            }
            else
            {
                endwin();
                delete root;
                return 1;
            }*/
    	}
        else if (keypress == KEY_LEFT)
        {
            endwin();
            delete root;
            return 1;
        }
    }
コード例 #12
0
ファイル: monitor_ubx.c プロジェクト: idaohang/gpsd-2
/*@ -mustfreeonly -compdestroy @*/
static void display_nav_sol(unsigned char *buf, size_t data_len)
{
    unsigned short gw = 0;
    unsigned int tow = 0, flags;
    double epx, epy, epz, evx, evy, evz;
    unsigned char navmode;
    struct gps_data_t g;
    double separation;

    if (data_len != 52)
	return;

#ifdef S_SPLINT_S
    assert(navsolwin != NULL);
#endif /* S_SPLINT_S */

    navmode = (unsigned char)getub(buf, 10);
    flags = (unsigned int)getub(buf, 11);

    if ((flags & (UBX_SOL_VALID_WEEK | UBX_SOL_VALID_TIME)) != 0) {
	tow = (unsigned int)getleu32(buf, 0);
	gw = (unsigned short)getles16(buf, 8);
    }

    epx = (double)(getles32(buf, 12) / 100.0);
    epy = (double)(getles32(buf, 16) / 100.0);
    epz = (double)(getles32(buf, 20) / 100.0);
    evx = (double)(getles32(buf, 28) / 100.0);
    evy = (double)(getles32(buf, 32) / 100.0);
    evz = (double)(getles32(buf, 36) / 100.0);
    ecef_to_wgs84fix(&g.fix, &separation, epx, epy, epz, evx, evy, evz);
    g.fix.epx = g.fix.epy = (double)(getles32(buf, 24) / 100.0);
    g.fix.eps = (double)(getles32(buf, 40) / 100.0);
    g.dop.pdop = (double)(getleu16(buf, 44) / 100.0);
    g.satellites_used = (int)getub(buf, 47);

    (void)wmove(navsolwin, 1, 11);
    (void)wprintw(navsolwin, "%+10.2fm %+10.2fm %+10.2fm", epx, epy, epz);
    (void)wmove(navsolwin, 2, 11);
    (void)wprintw(navsolwin, "%+9.2fm/s %+9.2fm/s %+9.2fm/s", evx, evy, evz);

    (void)wmove(navsolwin, 4, 11);
    (void)wattrset(navsolwin, A_UNDERLINE);
    (void)wprintw(navsolwin, "%12.9f  %13.9f  %8.2fm",
		  g.fix.latitude, g.fix.longitude, g.fix.altitude);
    (void)mvwaddch(navsolwin, 4, 23, ACS_DEGREE);
    (void)mvwaddch(navsolwin, 4, 38, ACS_DEGREE);
    (void)wmove(navsolwin, 5, 11);
    (void)wprintw(navsolwin, "%6.2fm/s %5.1fo %6.2fm/s",
		  g.fix.speed, g.fix.track, g.fix.climb);
    (void)mvwaddch(navsolwin, 5, 26, ACS_DEGREE);
    (void)wattrset(navsolwin, A_NORMAL);

    (void)wmove(navsolwin, 7, 7);
    /*@ -compdef @*/
    {
	unsigned int day = tow / 8640000;
	unsigned int tod = tow % 8640000;
	unsigned int h = tod / 360000;
	unsigned int m = tod % 360000;
	unsigned int s = m % 6000;

	m = (m - s) / 6000;

	(void)wattrset(navsolwin, A_UNDERLINE);
	(void)wprintw(navsolwin, "%u %02u:%02u:%05.2f", day, h, m, (double)s / 100);
	(void)wattrset(navsolwin, A_NORMAL);
    }
    /*@ +compdef @*/
    (void)wmove(navsolwin, 8, 11);
    if ((flags & (UBX_SOL_VALID_WEEK | UBX_SOL_VALID_TIME)) != 0) {
	(void)wprintw(navsolwin, "%d+%10.3lf", gw, (double)(tow / 1000.0));
	(void)wmove(navsolwin, 8, 36);
	(void)wprintw(navsolwin, "%d", (tow / 86400000));
    }

    /* relies on the fact that epx and epy are set to same value */
    (void)wmove(navsolwin, 10, 12);
    (void)wprintw(navsolwin, "%7.2f", g.fix.epx);
    (void)wmove(navsolwin, 10, 33);
    (void)wprintw(navsolwin, "%6.2f", g.fix.epv);
    (void)wmove(navsolwin, 11, 7);
    (void)wprintw(navsolwin, "%2d", g.satellites_used);
    (void)wmove(navsolwin, 11, 15);
    (void)wprintw(navsolwin, "%5.1f", g.dop.pdop);
    (void)wmove(navsolwin, 11, 25);
    (void)wprintw(navsolwin, "0x%02x", navmode);
    (void)wmove(navsolwin, 11, 36);
    (void)wprintw(navsolwin, "0x%02x", flags);
    (void)wnoutrefresh(navsolwin);
}
コード例 #13
0
ファイル: yesno.c プロジェクト: jnow-87/foo
/*
 * Display a dialog box with two buttons - Yes and No
 */
int dialog_yesno(const char *title, const char *prompt, int height, int width)
{
	int i, x, y, key = 0, button = 0;
	WINDOW *dialog;

do_resize:
	if (getmaxy(stdscr) < (height + 4))
		return -ERRDISPLAYTOOSMALL;
	if (getmaxx(stdscr) < (width + 4))
		return -ERRDISPLAYTOOSMALL;

	/* center dialog box on screen */
	x = (COLS - width) / 2;
	y = (LINES - height) / 2;

	draw_shadow(stdscr, y, x, height, width);

	dialog = newwin(height, width, y, x);
	keypad(dialog, TRUE);

	draw_box(dialog, 0, 0, height, width,
		 dlg.dialog.atr, dlg.border.atr);
	wattrset(dialog, dlg.border.atr);
	mvwaddch(dialog, height - 3, 0, ACS_LTEE);
	for (i = 0; i < width - 2; i++)
		waddch(dialog, ACS_HLINE);
	wattrset(dialog, dlg.dialog.atr);
	waddch(dialog, ACS_RTEE);

	print_title(dialog, title, width);

	wattrset(dialog, dlg.dialog.atr);
	print_autowrap(dialog, prompt, width - 2, 1, 3);

	print_buttons(dialog, height, width, 0);

	while (key != KEY_ESC) {
		key = wgetch(dialog);
		switch (key) {
		case 'Y':
		case 'y':
			delwin(dialog);
			return 0;
		case 'N':
		case 'n':
			delwin(dialog);
			return 1;

		case TAB:
		case KEY_LEFT:
		case KEY_RIGHT:
			button = ((key == KEY_LEFT ? --button : ++button) < 0) ? 1 : (button > 1 ? 0 : button);

			print_buttons(dialog, height, width, button);
			wrefresh(dialog);
			break;
		case ' ':
		case '\n':
			delwin(dialog);
			return button;
		case KEY_ESC:
			key = on_key_esc(dialog);
			break;
		case KEY_RESIZE:
			delwin(dialog);
			on_key_resize();
			goto do_resize;
		}
	}

	delwin(dialog);
	return key;		/* ESC pressed */
}
コード例 #14
0
ファイル: engine.c プロジェクト: liushizhe/yetris
void engine_draw_next_pieces(game_s* g)
{
	WINDOW* w = NULL;
	int i, k;
	for (i = 0; i < global.game_next_no; i++)
	{
		piece_s p = g->piece_next[i];
		w = engine.screen.next[i].win;

		werase(w);

		/* This is a little hack to pretty-print pieces
		 * TODO somehow manage to fix this */
		for (k = 0; k < 4; k++)
		{
			/* shifting them to the left */
			p.block[k].x -= p.x + 1;
			p.block[k].y -= p.y;

			p.block[k].y--;

			if (p.type == PIECE_O)
				p.block[k].y -= 1;
		}
		engine_draw_piece(&p, w);
		wnoutrefresh(w);
	}

	w = engine.screen.middle_right.win;

	if (global.screen_fancy_borders)
	{
		mvwaddch(w, 3, 0, ACS_LLCORNER|COLOR_PAIR(WHITE_BLACK));
		mvwhline(w, 3, 1, ACS_HLINE|COLOR_PAIR(BLACK_BLACK)|A_BOLD, 8);
		mvwaddch(w, 3, 9, ACS_LRCORNER|COLOR_PAIR(BLACK_BLACK)|A_BOLD);
	}
	else
	{
		wattrset(w, engine_get_color(COLOR_BLACK, COLOR_BLACK, true));
		mvwhline(w, 3, 1, '-', 8);
	}

	wattrset(w, engine_get_color(COLOR_BLUE, COLOR_BLACK, false));
	mvwaddstr(w, 0, 1, "Next");
	wnoutrefresh(w);

	window_s* win = &(engine.screen.middle_right);

	/* RE-DRAWING BORDERS (damn this sucks) */
	if (global.screen_fancy_borders)
	{
		window_fancy_borders(win->win);
		/* making the top line between 1st next and the rest */
		mvwaddch(win->win, 3, 0, ACS_LLCORNER|COLOR_PAIR(WHITE_BLACK));
		mvwhline(win->win, 3, 1, ACS_HLINE|COLOR_PAIR(BLACK_BLACK)|A_BOLD, win->width - 2);
		mvwaddch(win->win, 3, win->width - 1, ACS_LRCORNER|COLOR_PAIR(BLACK_BLACK)|A_BOLD);

		/* making the bottom line between 1st next and the rest */
		mvwaddch(win->win, 4, 0, ACS_ULCORNER|COLOR_PAIR(WHITE_BLACK)|A_BOLD);
		mvwhline(win->win, 4, 1, ACS_HLINE|COLOR_PAIR(WHITE_BLACK), win->width - 2);
		mvwaddch(win->win, 4, win->width - 1, ACS_URCORNER|COLOR_PAIR(WHITE_BLACK));

	}
	else
	{
		window_normal_borders(win->win);
		wattrset(win->win, engine_get_color(COLOR_BLACK, COLOR_BLACK, true));
		mvwhline(win->win, 3, 1, '-', win->width - 2);
	}

}
コード例 #15
0
ファイル: xmas.c プロジェクト: UnitedMarsupials/kame
balls()
{

  overlay(treescrn, treescrn2);

  mvwaddch(treescrn2, 3, 9, (chtype)'@');
  mvwaddch(treescrn2, 3, 15, (chtype)'@');
  mvwaddch(treescrn2, 4, 8, (chtype)'@');
  mvwaddch(treescrn2, 4, 16, (chtype)'@');
  mvwaddch(treescrn2, 5, 7, (chtype)'@');
  mvwaddch(treescrn2, 5, 17, (chtype)'@');
  mvwaddch(treescrn2, 7, 6, (chtype)'@');
  mvwaddch(treescrn2, 7, 18, (chtype)'@');
  mvwaddch(treescrn2, 8, 5, (chtype)'@');
  mvwaddch(treescrn2, 8, 19, (chtype)'@');
  mvwaddch(treescrn2, 10, 4, (chtype)'@');
  mvwaddch(treescrn2, 10, 20, (chtype)'@');
  mvwaddch(treescrn2, 11, 2, (chtype)'@');
  mvwaddch(treescrn2, 11, 22, (chtype)'@');
  mvwaddch(treescrn2, 12, 1, (chtype)'@');
  mvwaddch(treescrn2, 12, 23, (chtype)'@');

  wrefresh(treescrn2);
  wrefresh(w_del_msg);
  return( 0 );
}
コード例 #16
0
ファイル: item.cpp プロジェクト: CIB/Cataclysm
int item::pick_reload_ammo(player &u, bool interactive)
{
 if (!type->is_gun() && !type->is_tool()) {
  debugmsg("RELOADING NON-GUN NON-TOOL");
  return false;
 }
 bool has_m203 = false;
 for (int i = 0; i < contents.size() && !has_m203; i++) {
  if (contents[i].type->id == itm_m203)
   has_m203 = true;
 }

 std::vector<int> am;	// List of indicies of valid ammo

 if (type->is_gun()) {
  if (charges > 0) {
   itype_id aid = itype_id(curammo->id);
   for (int i = 0; i < u.inv.size(); i++) {
    if (u.inv[i].type->id == aid)
     am.push_back(i);
   }
  } else {
  it_gun* tmp = dynamic_cast<it_gun*>(type);
   am = u.has_ammo(ammo_type());
   if (has_m203) {
    std::vector<int> grenades = u.has_ammo(AT_40MM);
    for (int i = 0; i < grenades.size(); i++)
     am.push_back(grenades[i]);
   }
  }
 } else {
  it_tool* tmp = dynamic_cast<it_tool*>(type);
  am = u.has_ammo(ammo_type());
 }

 int index = -1;

 if (am.size() > 1 && interactive) {// More than one option; list 'em and pick
  WINDOW* w_ammo = newwin(am.size() + 1, 80, 0, 0);
  if (charges == 0) {
   char ch;
   clear();
   it_ammo* ammo_type;
   mvwprintw(w_ammo, 0, 0, "\
Choose ammo type:         Damage     Armor Pierce     Range     Accuracy");
   for (int i = 0; i < am.size(); i++) {
    ammo_type = dynamic_cast<it_ammo*>(u.inv[am[i]].type);
    mvwaddch(w_ammo, i + 1, 1, i + 'a');
    mvwprintw(w_ammo, i + 1, 3, "%s (%d)", u.inv[am[i]].tname().c_str(),
                                           u.inv[am[i]].charges);
    mvwprintw(w_ammo, i + 1, 27, "%d", ammo_type->damage);
    mvwprintw(w_ammo, i + 1, 38, "%d", ammo_type->pierce);
    mvwprintw(w_ammo, i + 1, 55, "%d", ammo_type->range);
    mvwprintw(w_ammo, i + 1, 65, "%d", 100 - ammo_type->accuracy);
   }
   refresh();
   wrefresh(w_ammo);
   do
    ch = getch();
   while ((ch < 'a' || ch - 'a' > am.size() - 1) && ch != ' ' && ch != 27);
   werase(w_ammo);
   delwin(w_ammo);
   erase();
   if (ch == ' ' || ch == 27)
    index = -1;
   else
    index = am[ch - 'a'];
  } else {
コード例 #17
0
ファイル: xmas.c プロジェクト: UnitedMarsupials/kame
strng4()
{
  mvwaddch(treescrn2, 9, 17, (chtype)'\'');
  mvwaddch(treescrn2, 9, 16, (chtype)':');
  mvwaddch(treescrn2, 9, 15, (chtype)'.');
  mvwaddch(treescrn2, 9, 14, (chtype)',');
  mvwaddch(treescrn2, 10, 13, (chtype)'\'');
  mvwaddch(treescrn2, 10, 12, (chtype)':');
  mvwaddch(treescrn2, 10, 11, (chtype)'.');
  mvwaddch(treescrn2, 10, 10, (chtype)',');
  mvwaddch(treescrn2, 11, 9, (chtype)'\'');
  mvwaddch(treescrn2, 11, 8, (chtype)':');
  mvwaddch(treescrn2, 11, 7, (chtype)'.');
  mvwaddch(treescrn2, 11, 6, (chtype)',');
  mvwaddch(treescrn2, 12, 5, (chtype)'\'');

  wrefresh(treescrn2);
  wrefresh(w_del_msg);
  return( 0 );
}
コード例 #18
0
/*
 * chase:
 *	Find the spot for the chaser(er) to move closer to the
 *	chasee(ee).  Returns TRUE if we want to keep on chasing later
 *	FALSE if we reach the goal.
 */
int
chase(struct thing *tp, coord *ee, int flee, int *mdead)
{
    register int x, y;
    register int dist, thisdist, monst_dist = MAXINT;
    register struct linked_list *weapon;
    register coord *er = &tp->t_pos, *shoot_dir;
    register int ch, mch;
    register int next_player = FALSE;
    int deadflg;

	if (mdead != NULL)
		*mdead = 0;

	shoot_dir = can_shoot(er, ee);
    weapon = get_hurl(tp);

    /*
     * If the thing is confused, let it move randomly. Invisible
     * Stalkers are slightly confused all of the time.
     */
    if ((on(*tp, ISHUH) && rnd(10) < 8) ||
	((on(*tp, ISINVIS) || on(*tp, ISSHADOW)) && rnd(100) < 20) ||
	(on(player, ISINVIS) && off(*tp, CANSEE))) { /* Player is invisible */
	/*
	 * get a valid random move
	 */
	ch_ret = *rndmove(tp);
	dist = DISTANCE(ch_ret.y, ch_ret.x, ee->y, ee->x);

    if (on(*tp, ISHUH) && rnd(20) == 0)  /* monster might lose confusion */
        turn_off(*tp, ISHUH);

	/*
	 * check to see if random move takes creature away from player
	 * if it does then turn off ISHELD
	 */
	if (dist > 1 && on(*tp, DIDHOLD)) {
	    turn_off(*tp, DIDHOLD);
	    turn_on(*tp, CANHOLD);
	    if (--hold_count <= 0)
	    {
	        hold_count = 0;
	        turn_off(player, ISHELD);
	    }
	}
    }

    /* If we can breathe, we may do so */
    else if (on(*tp, CANBREATHE) && (shoot_dir) &&
	     (rnd(100) < 67) &&
		 (off(player, ISDISGUISE) || (rnd(tp->t_stats.s_lvl) > 6)) &&
	     (DISTANCE(er->y, er->x, ee->y, ee->x) < BOLT_LENGTH*BOLT_LENGTH)) {
		register int chance;
		register char *breath;

		/* Will it breathe at random */
		if (on(*tp, CANBRANDOM)) {
		    if (rnd(level/20) == 0 && tp->t_index != NUMMONST+1)
			turn_off(*tp, CANBRANDOM);

		    /* Select type of breath */
		    chance = rnd(100);
		    if (chance < 11) breath = "acid";
		    else if (chance < 22) breath = "flame";
		    else if (chance < 33) breath = "lightning bolt";
		    else if (chance < 44) breath = "chlorine gas";
		    else if (chance < 55) breath = "ice";
		    else if (chance < 66) breath = "nerve gas";
		    else if (chance < 77) breath = "sleeping gas";
		    else if (chance < 88) breath = "slow gas";
		    else breath = "fear gas";
		}

		/* Or can it breathe acid? */
		else if (on(*tp, CANBACID)) {
		    if (rnd(level/20) == 0)
			turn_off(*tp, CANBACID);
		    breath = "acid";
		}

		/* Or can it breathe fire */
		else if (on(*tp, CANBFIRE)) {
		    if (rnd(level/20) == 0)
			turn_off(*tp, CANBFIRE);
		    breath = "flame";
		}

		/* Or can it breathe electricity? */
		else if (on(*tp, CANBBOLT)) {
		    if (rnd(level/20) == 0)
			turn_off(*tp, CANBBOLT);
		    breath = "lightning bolt";
		}

		/* Or can it breathe gas? */
		else if (on(*tp, CANBGAS)) {
		    if (rnd(level/20) == 0)
			turn_off(*tp, CANBGAS);
		    breath = "chlorine gas";
		}

		/* Or can it breathe ice? */
		else if (on(*tp, CANBICE)) {
		    if (rnd(level/20) == 0)
			turn_off(*tp, CANBICE);
		    breath = "ice";
		}

		else if (on(*tp, CANBPGAS)) {
		    if (rnd(level/20) == 0)
			turn_off(*tp, CANBPGAS);
		    breath = "nerve gas";
		}

		else if (on(*tp, CANBSGAS)) {
		    if (rnd(level/20) == 0)
			turn_off(*tp, CANBSGAS);
		    breath = "sleeping gas";
		}

		else if (on(*tp, CANBSLGAS)) {
		    if (rnd(level/20) == 0)
			turn_off(*tp, CANBSLGAS);
		    breath = "slow gas";
		}

		else {
		    if (rnd(level/20) == 0)
			turn_off(*tp, CANBFGAS);
		    breath = "fear gas";
		}

		/* Now breathe -- returns TRUE if kills itself */
		deadflg =
		    shoot_bolt(tp, *er, *shoot_dir, FALSE, tp->t_index, breath,
			       (save(VS_BREATH) ? tp->t_stats.s_hpt/2
					        : tp->t_stats.s_hpt));

		if (deadflg && mdead != NULL)
			*mdead = 1;

		ch_ret = *er;
		dist = DISTANCE(ch_ret.y, ch_ret.x, ee->y, ee->x);
		if (deadflg) return(TRUE);
	}

    /* 
     * If we can shoot or throw something, we might do so 
     * if we are running away, we may decide to shoot anyway if we are far 
     * enough
     */
    else if((off(*tp, ISFLEE) || rnd(DISTANCE(er->y,er->x,ee->y,ee->x)) > 2) && 
	     on(*tp, CANSHOOT) && (off(player, ISDISGUISE) ||
		 (rnd(tp->t_stats.s_lvl) > 6)) &&
	    (shoot_dir) &&
	    (weapon)) {
		missile(shoot_dir->y, shoot_dir->x, weapon, tp);
		ch_ret = *er;
		dist = DISTANCE(ch_ret.y, ch_ret.x, ee->y, ee->x);
	}

    /*
     * Otherwise, find the empty spot next to the chaser that is
     * closest to the chasee.
     */
    else {
	register int ey, ex;
	register struct room *rer, *ree;
	register int dist_to_old = MININT; /* Dist from goal to old position */

	/* Get rooms */
	rer = roomin(er);
	ree = roomin(ee);

	/*
	 * This will eventually hold where we move to get closer
	 * If we can't find an empty spot, we stay where we are.
	 */
	dist = flee ? 0 : MAXINT;
	ch_ret = *er;

	/* Are we at our goal already? */
	if (!flee && ce(ch_ret, *ee)) return(FALSE);

	ey = er->y + 1;
	ex = er->x + 1;
	for (x = er->x - 1; x <= ex; x++)
	    for (y = er->y - 1; y <= ey; y++) {
		coord tryp;

		/* Don't try off the board */
		if ((x < 0) || (x >= COLS) || (y < 1) || (y >= LINES - 2))
		    continue;

		/* Don't try the player if not going after the player */
		/* or he's disguised */
		if ( ((off(*tp, ISFLEE) && !ce(hero, *ee)) ||
			(on(player, ISDISGUISE) && (rnd(tp->t_stats.s_lvl) < 6))) &&
			x == hero.x && y == hero.y)
		    continue;

		tryp.x = x;
		tryp.y = y;

		/* Is there a monster on this spot closer to our goal?
		 * Don't look in our spot or where we were.
		 */
		if (!ce(tryp, *er) && !ce(tryp, tp->t_oldpos) &&
		    isalpha(mch = CCHAR( mvwinch(mw, y, x) ))) {
		    register int test_dist;

		    test_dist = DISTANCE(y, x, ee->y, ee->x);
		    if (test_dist <= 25 &&   /* Let's be fairly close */
			test_dist < monst_dist) {
			/* Could we really move there? */
			mvwaddch(mw, y, x, ' '); /* Temporarily blank monst */
			if (diag_ok(er, &tryp, tp)) monst_dist = test_dist;
			mvwaddch(mw, y, x, mch); /* Restore monster */
		    }
		}

		if (!diag_ok(er, &tryp, tp))
		    continue;
		ch = CCHAR( mvwinch(cw, y, x) );	/* Screen character */
		if (on(*tp, ISFLEE) && (ch == PLAYER)) next_player = TRUE;

		/* Stepping on player is NOT okay if we are fleeing */
		if (step_ok(y, x, NOMONST, tp) &&
		    (off(*tp, ISFLEE) || ch != PLAYER))
		{
		    /*
		     * If it is a trap, an intelligent monster may not
		     * step on it (unless our hero is on top!)
		     */
		    if (isatrap(ch)) {
			if (!(ch == RUSTTRAP) &&
				!(ch == FIRETRAP && on(*tp,NOFIRE)) &&
			    rnd(10) < tp->t_stats.s_intel &&
			    (y != hero.y || x != hero.x))
				continue;
		    }

		    /*
		     * OK -- this place counts
		     */
		    thisdist = DISTANCE(y, x, ee->y, ee->x);

		    /* Adjust distance if we are being shot at */
		    if (tp->t_wasshot && tp->t_stats.s_intel > 5 &&
			ce(hero, *ee)) {
			/* Move out of line of sight */
			if (straight_shot(tryp.y, tryp.x, ee->y, ee->x, NULL)) {
			    if (flee) thisdist -= SHOTPENALTY;
			    else thisdist += SHOTPENALTY;
			}

			/* But do we want to leave the room? */
			else if (rer && rer == ree && ch == DOOR)
			    thisdist += DOORPENALTY;
		    }

		    /* Don't move to the last position if we can help it */
		    if (ce(tryp, tp->t_oldpos)) dist_to_old = thisdist;

		    else if ((flee && (thisdist > dist)) ||
			(!flee && (thisdist < dist)))
		    {
			ch_ret = tryp;
			dist = thisdist;
		    }
		}
	    }

	/* If we are running from the player and he is in our way,
	 * go ahead and slug him.
	 */
	if (next_player && DISTANCE(er->y, er->x, ee->y, ee->x) < dist &&
	    step_ok(tp->t_dest->y, tp->t_dest->x, NOMONST, tp)) {
	    ch_ret = *(tp->t_dest);	/* Okay to hit player */
	    return FALSE;
	}


	/* If we can't get closer to the player (if that's our goal)
	 * because other monsters are in the way, just stay put
	 */
	if (!flee && ce(hero, *ee) && monst_dist < MAXINT &&
	    DISTANCE(er->y, er->x, hero.y, hero.x) < dist)
		ch_ret = *er;

	/* Do we want to go back to the last position? */
	else if (dist_to_old != MININT &&      /* It is possible to move back */
	    ((flee && dist == 0) ||	/* No other possible moves */
	     (!flee && dist == MAXINT))) {
	    /* Do we move back or just stay put (default)? */
	    dist = DISTANCE(er->y, er->x, ee->y, ee->x); /* Current distance */
	    if (!flee || (flee && (dist_to_old > dist))) ch_ret = tp->t_oldpos;
	}
    }

    /* Make sure we have the real distance now */
    dist = DISTANCE(ch_ret.y, ch_ret.x, ee->y, ee->x);

    /* Mark monsters in a wall */
    if (isrock(CCHAR( mvinch(ch_ret.y, ch_ret.x) ))) 
	turn_on(*tp, ISINWALL);
    else 
	turn_off(*tp, ISINWALL);

    if (off(*tp, ISFLEE) &&
	((tp->t_dest != &hero) || off(player, ISINWALL) || on(*tp, CANINWALL)))
	return (dist != 0);

    /* May actually hit here from a confused move */
    else return(!ce(ch_ret, hero));
}
コード例 #19
0
ファイル: yesno.c プロジェクト: ilusion-linux/LuCAS
/*
 * Display a dialog box with two buttons - Yes and No
 */
int
dialog_yesno (const char *title, const char *prompt, int height, int width)
{
    int i, x, y, key = 0, button = 0;
    WINDOW *dialog;

    /* center dialog box on screen */
    x = (COLS - width) / 2;
    y = (LINES - height) / 2;

    draw_shadow (stdscr, y, x, height, width);

    dialog = newwin (height, width, y, x);
    keypad (dialog, TRUE);

    draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr);
    wattrset (dialog, border_attr);
    mvwaddch (dialog, height-3, 0, ACS_LTEE);
    for (i = 0; i < width - 2; i++)
	waddch (dialog, ACS_HLINE);
    wattrset (dialog, dialog_attr);
    waddch (dialog, ACS_RTEE);

    if (title != NULL && strlen(title) >= width-2 ) {
	/* truncate long title -- mec */
	char * title2 = malloc(width-2+1);
	memcpy( title2, title, width-2 );
	title2[width-2] = '\0';
	title = title2;
    }

    if (title != NULL) {
	wattrset (dialog, title_attr);
	mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
	waddstr (dialog, (char *)title);
	waddch (dialog, ' ');
    }

    wattrset (dialog, dialog_attr);
    print_autowrap (dialog, prompt, width - 2, 1, 3);

    print_buttons(dialog, height, width, 0);

    while (key != ESC) {
	key = wgetch (dialog);
	switch (key) {
	case 'Y':
	case 'y':
	case 'S':
	case 's':
	    delwin (dialog);
	    return 0;
	case 'N':
	case 'n':
	    delwin (dialog);
	    return 1;

	case TAB:
	case KEY_LEFT:
	case KEY_RIGHT:
	    button = ((key == KEY_LEFT ? --button : ++button) < 0)
			? 1 : (button > 1 ? 0 : button);

	    print_buttons(dialog, height, width, button);
	    wrefresh (dialog);
	    break;
	case ' ':
	case '\n':
	    delwin (dialog);
	    return button;
	case ESC:
	    break;
	}
    }

    delwin (dialog);
    return -1;			/* ESC pressed */
}
コード例 #20
0
int
can_blink(struct thing *tp)
{
    register int y, x, index=9;
    coord tryp;	/* To hold the coordinates for use in diag_ok */
    int spots[9], found_one=FALSE;

    /* First, can the monster even blink?  And if so, there is only a 50%
     * chance that it will do so.  And it won't blink if it is running.
     */
    if (off(*tp, CANBLINK) || (on(*tp, ISHELD)) ||
	on(*tp, ISFLEE) ||
	(on(*tp, ISSLOW) && off(*tp, ISHASTE) && !(tp->t_turn)) ||
	(rnd(12) < 6)) return(FALSE);


    /* Initialize the spots as illegal */
    do {
	spots[--index] = FALSE;
    } while (index > 0);

    /* Find a suitable spot next to the player */
    for (y=hero.y-1; y<hero.y+2; y++)
	for (x=hero.x-1; x<hero.x+2; x++, index++) {
	    /* Make sure x coordinate is in range and that we are
	     * not at the player's position
	     */
	    if (x<0 || x >= COLS || index == 4) continue;

	    /* Is it OK to move there? */
	    if (!step_ok(y, x, NOMONST, tp)) spots[index] = FALSE;
	    else {
		/* OK, we can go here.  But don't go there if
		 * monster can't get at player from there
		 */
		tryp.y = y;
		tryp.x = x;
		if (diag_ok(&tryp, &hero, tp)) {
		    spots[index] = TRUE;
		    found_one = TRUE;
		}
	    }
	}

    /* If we found one, go to it */
    if (found_one) {
	/* Find a legal spot */
	while (spots[index=rnd(9)] == FALSE) continue;

	/* Get the coordinates */
	y = hero.y + (index/3) - 1;
	x = hero.x + (index % 3) - 1;

	/* Move the monster from the old space */
	mvwaddch(cw, tp->t_pos.y, tp->t_pos.x, tp->t_oldch);

	/* Move it to the new space */
	tp->t_oldch = CCHAR( mvwinch(cw, y, x) );

	if (cansee(y, x) &&
	    off(*tp, ISINWALL) &&
	    ((off(*tp, ISINVIS) && 
	      (off(*tp, ISSHADOW) || rnd(100) < 10)) || on(player, CANSEE)) &&
	    off(*tp, CANSURPRISE))
	    mvwaddch(cw, y, x, tp->t_type);
	mvwaddch(mw, tp->t_pos.y, tp->t_pos.x, ' '); /* Clear old position */
	mvwaddch(mw, y, x, tp->t_type);
	tp->t_pos.y = y;
	tp->t_pos.x = x;
    }

    return(found_one);
}
コード例 #21
0
/*
 * Display a dialog box with a list of options that can be turned on or off
 * in the style of radiolist (only one option turned on at a time).
 */
int dialog_checklist(const char *title, const char *prompt, int height,
		     int width, int list_height, int item_no,
		     const char *const *items)
{
	int i, x, y, box_x, box_y;
	int key = 0, button = 0, choice = 0, scroll = 0, max_choice, *status;
	WINDOW *dialog, *list;

	/* Allocate space for storing item on/off status */
	if ((status = malloc(sizeof(int) * item_no)) == NULL) {
		endwin();
		fprintf(stderr,
			"\nCan't allocate memory in dialog_checklist().\n");
		exit(-1);
	}

	/* Initializes status */
	for (i = 0; i < item_no; i++) {
		status[i] = !strcasecmp(items[i * 3 + 2], "on");
		if ((!choice && status[i])
		    || !strcasecmp(items[i * 3 + 2], "selected"))
			choice = i + 1;
	}
	if (choice)
		choice--;

	max_choice = MIN(list_height, item_no);

	/* center dialog box on screen */
	x = (COLS - width) / 2;
	y = (LINES - height) / 2;

	draw_shadow(stdscr, y, x, height, width);

	dialog = newwin(height, width, y, x);
	keypad(dialog, TRUE);

	draw_box(dialog, 0, 0, height, width, dialog_attr, border_attr);
	wattrset(dialog, border_attr);
	mvwaddch(dialog, height - 3, 0, ACS_LTEE);
	for (i = 0; i < width - 2; i++)
		waddch(dialog, ACS_HLINE);
	wattrset(dialog, dialog_attr);
	waddch(dialog, ACS_RTEE);

	print_title(dialog, title, width);

	wattrset(dialog, dialog_attr);
	print_autowrap(dialog, prompt, width - 2, 1, 3);

	list_width = width - 6;
	box_y = height - list_height - 5;
	box_x = (width - list_width) / 2 - 1;

	/* create new window for the list */
	list = subwin(dialog, list_height, list_width, y + box_y + 1,
	              x + box_x + 1);

	keypad(list, TRUE);

	/* draw a box around the list items */
	draw_box(dialog, box_y, box_x, list_height + 2, list_width + 2,
	         menubox_border_attr, menubox_attr);

	/* Find length of longest item in order to center checklist */
	check_x = 0;
	for (i = 0; i < item_no; i++)
		check_x = MAX(check_x, +strlen(items[i * 3 + 1]) + 4);

	check_x = (list_width - check_x) / 2;
	item_x = check_x + 4;

	if (choice >= list_height) {
		scroll = choice - list_height + 1;
		choice -= scroll;
	}

	/* Print the list */
	for (i = 0; i < max_choice; i++) {
		print_item(list, items[(scroll + i) * 3 + 1],
			   status[i + scroll], i, i == choice);
	}

	print_arrows(dialog, choice, item_no, scroll,
		     box_y, box_x + check_x + 5, list_height);

	print_buttons(dialog, height, width, 0);

	wnoutrefresh(dialog);
	wnoutrefresh(list);
	doupdate();

	while (key != ESC) {
		key = wgetch(dialog);

		for (i = 0; i < max_choice; i++)
			if (toupper(key) ==
			    toupper(items[(scroll + i) * 3 + 1][0]))
				break;

		if (i < max_choice || key == KEY_UP || key == KEY_DOWN ||
		    key == '+' || key == '-') {
			if (key == KEY_UP || key == '-') {
				if (!choice) {
					if (!scroll)
						continue;
					/* Scroll list down */
					if (list_height > 1) {
						/* De-highlight current first item */
						print_item(list, items[scroll * 3 + 1],
							   status[scroll], 0, FALSE);
						scrollok(list, TRUE);
						wscrl(list, -1);
						scrollok(list, FALSE);
					}
					scroll--;
					print_item(list, items[scroll * 3 + 1], status[scroll], 0, TRUE);
					print_arrows(dialog, choice, item_no,
						     scroll, box_y, box_x + check_x + 5, list_height);

					wnoutrefresh(dialog);
					wrefresh(list);

					continue;	/* wait for another key press */
				} else
					i = choice - 1;
			} else if (key == KEY_DOWN || key == '+') {
				if (choice == max_choice - 1) {
					if (scroll + choice >= item_no - 1)
						continue;
					/* Scroll list up */
					if (list_height > 1) {
						/* De-highlight current last item before scrolling up */
						print_item(list, items[(scroll + max_choice - 1) * 3 + 1],
							   status[scroll + max_choice - 1],
							   max_choice - 1, FALSE);
						scrollok(list, TRUE);
						wscrl(list, 1);
						scrollok(list, FALSE);
					}
					scroll++;
					print_item(list, items[(scroll + max_choice - 1) * 3 + 1],
						   status[scroll + max_choice - 1], max_choice - 1, TRUE);

					print_arrows(dialog, choice, item_no,
						     scroll, box_y, box_x + check_x + 5, list_height);

					wnoutrefresh(dialog);
					wrefresh(list);

					continue;	/* wait for another key press */
				} else
					i = choice + 1;
			}
			if (i != choice) {
				/* De-highlight current item */
				print_item(list, items[(scroll + choice) * 3 + 1],
					   status[scroll + choice], choice, FALSE);
				/* Highlight new item */
				choice = i;
				print_item(list, items[(scroll + choice) * 3 + 1],
					   status[scroll + choice], choice, TRUE);
				wnoutrefresh(dialog);
				wrefresh(list);
			}
			continue;	/* wait for another key press */
		}
		switch (key) {
		case 'H':
		case 'h':
		case '?':
			fprintf(stderr, "%s", items[(scroll + choice) * 3]);
			delwin(dialog);
			free(status);
			return 1;
		case TAB:
		case KEY_LEFT:
		case KEY_RIGHT:
			button = ((key == KEY_LEFT ? --button : ++button) < 0)
			    ? 1 : (button > 1 ? 0 : button);

			print_buttons(dialog, height, width, button);
			wrefresh(dialog);
			break;
		case 'S':
		case 's':
		case ' ':
		case '\n':
			if (!button) {
				if (!status[scroll + choice]) {
					for (i = 0; i < item_no; i++)
						status[i] = 0;
					status[scroll + choice] = 1;
					for (i = 0; i < max_choice; i++)
						print_item(list, items[(scroll + i) * 3 + 1],
							   status[scroll + i], i, i == choice);
				}
				wnoutrefresh(dialog);
				wrefresh(list);

				for (i = 0; i < item_no; i++)
					if (status[i])
						fprintf(stderr, "%s", items[i * 3]);
			} else
				fprintf(stderr, "%s", items[(scroll + choice) * 3]);
			delwin(dialog);
			free(status);
			return button;
		case 'X':
		case 'x':
			key = ESC;
		case ESC:
			break;
		}

		/* Now, update everything... */
		doupdate();
	}

	delwin(dialog);
	free(status);
	return -1;		/* ESC pressed */
}
コード例 #22
0
/*
 * do_chase:
 *	Make one thing chase another.
 */
void
do_chase(struct thing *th, int flee)
{
    register struct room *rer, *ree,	/* room of chaser, room of chasee */
			*old_room,	/* old room of monster */
			*new_room;	/* new room of monster */
    register int mindist = MAXINT, maxdist = MININT, dist = MININT, i,
		 last_door = -1;	/* Door we just came from */
    register int stoprun = FALSE,	/* TRUE means we are there */
		  rundoor;		/* TRUE means run to a door */
	int mdead = 0;
    register int sch;
    coord this;				/* Temporary destination for chaser */

    /* Make sure the monster can move */
    if (th->t_no_move != 0) {
	th->t_no_move--;
	return;
    }

    rer = roomin(&th->t_pos);	/* Find room of chaser */
    ree = roomin(th->t_dest);	/* Find room of chasee */

    /*
     * We don't count doors as inside rooms for this routine
     */
    if (mvwinch(stdscr, th->t_pos.y, th->t_pos.x) == DOOR)
	rer = NULL;
    this = *th->t_dest;

    /*
     * If we are not in a corridor and not a Xorn, then if we are running
     * after the player, we run to a door if he is not in the same room.
     * If we are fleeing, we run to a door if he IS in the same room.
     * Note:  We don't bother with doors in mazes.
     */
    if (levtype != MAZELEV && rer != NULL && off(*th, CANINWALL)) {
	if (flee) rundoor = (rer == ree);
	else rundoor = (rer != ree);
    }
    else rundoor = FALSE;

    if (rundoor) {
	coord exit;	/* A particular door */
	int exity, exitx;	/* Door's coordinates */

	if (th->t_doorgoal != -1) {	/* Do we already have the goal? */
	    this = rer->r_exit[th->t_doorgoal];
	    dist = 0;	/* Indicate that we have our door */
	}

	else for (i = 0; i < rer->r_nexits; i++) {	/* Loop through doors */
	    exit = rer->r_exit[i];
	    exity = exit.y;
	    exitx = exit.x;

	    /* Avoid secret doors */
	    if (mvwinch(stdscr, exity, exitx) == DOOR) {
		/* Were we just on this door? */
		if (ce(exit, th->t_oldpos)) last_door = i;

		else {
		    dist = DISTANCE(th->t_dest->y, th->t_dest->x, exity, exitx);

		    /* If fleeing, we want to maximize distance from door to
		     * what we flee, and minimize distance from door to us.
		     */
		    if (flee)
		       dist -= DISTANCE(th->t_pos.y, th->t_pos.x, exity, exitx);

		    /* Maximize distance if fleeing, otherwise minimize it */
		    if ((flee && (dist > maxdist)) ||
			(!flee && (dist < mindist))) {
			th->t_doorgoal = i;	/* Use this door */
			this = exit;
			mindist = maxdist = dist;
		    }
		}
	    }
	}

	/* Could we not find a door? */
	if (dist == MININT) {
	    /* If we were on a door, go ahead and use it */
	    if (last_door != -1) {
		th->t_doorgoal = last_door;
		this = th->t_oldpos;
		dist = 0;	/* Indicate that we found a door */
	    }
	}

	/* Indicate that we do not want to flee from the door */
	if (dist != MININT) flee = FALSE;
    }

    else th->t_doorgoal = -1;	/* Not going to any door */
    /*
     * this now contains what we want to run to this time
     * so we run to it.  If we hit it we either want to fight it
     * or stop running
     */
    if (!chase(th, &this, flee, &mdead)) {
	if (ce(ch_ret, hero)) {
	    /* merchants try to sell something */
	    if (on(*th, CANSELL)) 
		sell(th);
	    else if (on(*th, ISCHARMED))
		{}				/* future enhancements */
	    else if (on(*th, ISFRIENDLY))
		{}
	    else
		attack(th, NULL, FALSE);
	    return;
	}
	else if (on(*th, NOMOVE))
	    stoprun = TRUE;
    }

    if (on(*th, ISDEAD))
		return;	/* Did monster get itself killed? */

    if (on(*th, NOMOVE)) 
	return;

    /* If we have a scavenger, it can pick something up */
    if (on(*th, ISSCAVENGE)) {
	register struct linked_list *item;

	if ((item = find_obj(ch_ret.y, ch_ret.x)) != NULL) {
	    register int floor = (roomin(&ch_ret) == NULL) ? PASSAGE : FLOOR;

	    detach(lvl_obj, item);
	    mvaddch(ch_ret.y, ch_ret.x, floor);
	    mvwaddch(cw, ch_ret.y, ch_ret.x, floor);
	    attach(th->t_pack, item);
	}
    }

    mvwaddch(cw, th->t_pos.y, th->t_pos.x, th->t_oldch);
    sch = CCHAR( mvwinch(cw, ch_ret.y, ch_ret.x) );

    /* Get old and new room of monster */
    old_room=roomin(&th->t_pos);
    new_room=roomin(&ch_ret);

    /* If the monster can illuminate rooms, check for a change */
    if (on(*th, HASFIRE)) {
	/* Is monster entering a room? */
	if (old_room != new_room && new_room != NULL) {
	    new_room->r_flags |= HASFIRE;
	    new_room->r_fires++;
	    if (cansee(ch_ret.y, ch_ret.x) && new_room->r_fires == 1)
		light(&hero);
	}

	/* Is monster leaving a room? */
	if (old_room != new_room && old_room != NULL) {
	    if (--(old_room->r_fires) <= 0) {
		old_room->r_flags &= ~HASFIRE;
		if (cansee(th->t_pos.y, th->t_pos.x)) light(&th->t_pos);
	    }
	}
    }

    /* If monster is entering player's room and player can see it,
     * stop the player's running.
     */
    if (new_room != old_room && new_room != NULL &&
	new_room == ree && cansee(unc(ch_ret)) &&
	(off(*th, ISINVIS) || (off(*th, ISSHADOW) || rnd(10) == 0) ||
	on(player, CANSEE)) && off(*th, CANSURPRISE))
		running = FALSE;

    if (rer != NULL && (rer->r_flags & ISDARK) && 
	!(rer->r_flags & HASFIRE) && sch == FLOOR &&
	DISTANCE(ch_ret.y, ch_ret.x, th->t_pos.y, th->t_pos.x) < see_dist &&
	off(player, ISBLIND))
	    th->t_oldch = ' ';
    else
	th->t_oldch = sch;

    if (cansee(unc(ch_ret)) &&
	off(*th, ISINWALL) &&
	((off(*th, ISINVIS) && (off(*th, ISSHADOW) || rnd(100) < 10)) ||
	 on(player, CANSEE)) &&
	off(*th, CANSURPRISE))
        mvwaddch(cw, ch_ret.y, ch_ret.x, th->t_type);
    mvwaddch(mw, th->t_pos.y, th->t_pos.x, ' ');
    mvwaddch(mw, ch_ret.y, ch_ret.x, th->t_type);

    /* Record monster's last position (if new one is different) */
    if (!ce(ch_ret, th->t_pos)) th->t_oldpos = th->t_pos;
    th->t_pos = ch_ret;		/* Mark the monster's new position */

    /* If the monster is on a trap, trap it */
    sch = CCHAR( mvinch(ch_ret.y, ch_ret.x) );
    if (isatrap(sch)) {
	debug("Monster trapped by %c.", sch);
	if (cansee(ch_ret.y, ch_ret.x)) th->t_oldch = sch;
	be_trapped(th, &ch_ret);
    }


    /*
     * And stop running if need be
     */
    if (stoprun && ce(th->t_pos, *(th->t_dest)))
	turn_off(*th, ISRUN);
}
コード例 #23
0
static void
cmd_space(key_info_t key_info, keys_info_t *keys_info)
{
	char c;
	changed = 1;

	if(perms[permnum] < 0)
	{
		c = ' ';
		perms[permnum] = 0;
	}
	else if(curr == 5 || curr == 10 || curr == 15)
	{
		int i = curr/5 - 1;
		if(!perms[permnum])
		{
			c = '*';
			perms[permnum] = 1;
		}
		else
		{
			if(!adv_perms[i])
			{
				c = 'd';
			}
			else
			{
				if(origin_perms[permnum] < 0)
				{
					c = 'X';
					perms[permnum] = -1;
				}
				else
				{
					c = ' ';
					perms[permnum] = 0;
				}
			}
			adv_perms[i] = !adv_perms[i];
		}
	}
	else if(origin_perms[permnum] < 0)
	{
		if(perms[permnum] > 0)
		{
			c = 'X';
			perms[permnum] = -1;
		}
		else if(perms[permnum] == 0)
		{
			c = '*';
			perms[permnum] = 1;
		}
		else
		{
			c = ' ';
			perms[permnum] = 0;
		}
	}
	else
	{
		c = perms[permnum] ? ' ' : '*';
		perms[permnum] = !perms[permnum];
	}
	mvwaddch(change_win, curr, col, c);

	checked_wmove(change_win, curr, col);
	wrefresh(change_win);
}
コード例 #24
0
ファイル: pickup.cpp プロジェクト: KrazyTheFox/Cataclysm-DDA
// Pick up items at (pos).
void Pickup::pick_up( const tripoint &p, int min )
{
    int cargo_part = -1;

    const optional_vpart_position vp = g->m.veh_at( p );
    vehicle *const veh = veh_pointer_or_null( vp );
    bool from_vehicle = false;

    if( min != -1 ) {
        veh_interact_results get_items_from = ITEMS_FROM_GROUND;
        if( veh != nullptr ) {
            get_items_from = veh->interact_with( p, vp->part_index() );
        }
        switch( get_items_from ) {
            case DONE:
                return;
            case ITEMS_FROM_CARGO: {
                const cata::optional<vpart_reference> carg = vp.part_with_feature( "CARGO", false );
                cargo_part = carg ? carg->part_index() : -1;
                from_vehicle = cargo_part >= 0;
                break;
            }
            case ITEMS_FROM_GROUND:
                // Nothing to change, default is to pick from ground anyway.
                if( g->m.has_flag( "SEALED", p ) ) {
                    return;
                }
                break;
        }
    }

    if( !from_vehicle ) {
        bool isEmpty = ( g->m.i_at( p ).empty() );

        // Hide the pickup window if this is a toilet and there's nothing here
        // but water.
        if( ( !isEmpty ) && g->m.furn( p ) == f_toilet ) {
            isEmpty = true;
            for( const item &maybe_water : g->m.i_at( p ) ) {
                if( maybe_water.typeId() != "water" ) {
                    isEmpty = false;
                    break;
                }
            }
        }

        if( isEmpty && ( min != -1 || !get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
            return;
        }
    }

    // which items are we grabbing?
    std::vector<item> here;
    if( from_vehicle ) {
        auto vehitems = veh->get_items( cargo_part );
        here.resize( vehitems.size() );
        std::copy( vehitems.begin(), vehitems.end(), here.begin() );
    } else {
        auto mapitems = g->m.i_at( p );
        here.resize( mapitems.size() );
        std::copy( mapitems.begin(), mapitems.end(), here.begin() );
    }

    if( min == -1 ) {
        // Recursively pick up adjacent items if that option is on.
        if( get_option<bool>( "AUTO_PICKUP_ADJACENT" ) && g->u.pos() == p ) {
            //Autopickup adjacent
            direction adjacentDir[8] = {NORTH, NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST, NORTHWEST};
            for( auto &elem : adjacentDir ) {

                tripoint apos = tripoint( direction_XY( elem ), 0 );
                apos += p;

                pick_up( apos, min );
            }
        }

        // Bail out if this square cannot be auto-picked-up
        if( g->check_zone( zone_type_id( "NO_AUTO_PICKUP" ), p ) ) {
            return;
        } else if( g->m.has_flag( "SEALED", p ) ) {
            return;
        }
    }

    // Not many items, just grab them
    if( static_cast<int>( here.size() ) <= min && min != -1 ) {
        g->u.assign_activity( activity_id( "ACT_PICKUP" ) );
        g->u.activity.placement = p - g->u.pos();
        g->u.activity.values.push_back( from_vehicle );
        // Only one item means index is 0.
        g->u.activity.values.push_back( 0 );
        // auto-pickup means pick up all.
        g->u.activity.values.push_back( 0 );
        return;
    }

    std::vector<std::list<item_idx>> stacked_here;
    for( size_t i = 0; i < here.size(); i++ ) {
        item &it = here[i];
        bool found_stack = false;
        for( auto &stack : stacked_here ) {
            if( stack.begin()->_item.stacks_with( it ) ) {
                item_idx el = { it, i };
                stack.push_back( el );
                found_stack = true;
                break;
            }
        }
        if( !found_stack ) {
            std::list<item_idx> newstack;
            newstack.push_back( { it, i } );
            stacked_here.push_back( newstack );
        }
    }
    std::reverse( stacked_here.begin(), stacked_here.end() );

    if( min != -1 ) { // don't bother if we're just autopickuping
        g->temp_exit_fullscreen();
    }
    // Otherwise, we have Autopickup, 2 or more items and should list them, etc.
    int maxmaxitems = TERMY;

    int itemsH = std::min( 25, TERMY / 2 );
    int pickupBorderRows = 3;

    // The pickup list may consume the entire terminal, minus space needed for its
    // header/footer and the item info window.
    int minleftover = itemsH + pickupBorderRows;
    if( maxmaxitems > TERMY - minleftover ) {
        maxmaxitems = TERMY - minleftover;
    }

    const int minmaxitems = 9;

    std::vector<pickup_count> getitem( stacked_here.size() );

    int maxitems = stacked_here.size();
    maxitems = ( maxitems < minmaxitems ? minmaxitems : ( maxitems > maxmaxitems ? maxmaxitems :
                 maxitems ) );

    int itemcount = 0;

    if( min == -1 ) { //Auto Pickup, select matching items
        if( !select_autopickup_items( stacked_here, getitem ) ) {
            // If we didn't find anything, bail out now.
            return;
        }
    } else {
        int pickupH = maxitems + pickupBorderRows;
        int pickupW = 44;

        int itemsW = pickupW;

        catacurses::window w_pickup = catacurses::newwin( pickupH, pickupW, 0, 0 );
        catacurses::window w_item_info = catacurses::newwin( TERMY - pickupH,
                                         pickupW,  pickupH,  0 );

        std::string action;
        long raw_input_char = ' ';
        input_context ctxt( "PICKUP" );
        ctxt.register_action( "UP" );
        ctxt.register_action( "DOWN" );
        ctxt.register_action( "RIGHT" );
        ctxt.register_action( "LEFT" );
        ctxt.register_action( "NEXT_TAB", _( "Next page" ) );
        ctxt.register_action( "PREV_TAB", _( "Previous page" ) );
        ctxt.register_action( "SCROLL_UP" );
        ctxt.register_action( "SCROLL_DOWN" );
        ctxt.register_action( "CONFIRM" );
        ctxt.register_action( "SELECT_ALL" );
        ctxt.register_action( "QUIT", _( "Cancel" ) );
        ctxt.register_action( "ANY_INPUT" );
        ctxt.register_action( "HELP_KEYBINDINGS" );
        ctxt.register_action( "FILTER" );
#if defined(__ANDROID__)
        ctxt.allow_text_entry = true; // allow user to specify pickup amount
#endif

        int start = 0;
        int cur_it = 0;
        bool update = true;
        mvwprintw( w_pickup, 0, 0, _( "PICK" ) );
        int selected = 0;
        int iScrollPos = 0;

        std::string filter;
        std::string new_filter;
        std::vector<int> matches;//Indexes of items that match the filter
        bool filter_changed = true;
        if( g->was_fullscreen ) {
            g->draw_ter();
        }
        // Now print the two lists; those on the ground and about to be added to inv
        // Continue until we hit return or space
        do {
            const std::string pickup_chars =
                ctxt.get_available_single_char_hotkeys( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ:;" );
            int idx = -1;
            for( int i = 1; i < pickupH; i++ ) {
                mvwprintw( w_pickup, i, 0,
                           "                                                " );
            }
            if( action == "ANY_INPUT" &&
                raw_input_char >= '0' && raw_input_char <= '9' ) {
                int raw_input_char_value = static_cast<char>( raw_input_char ) - '0';
                itemcount *= 10;
                itemcount += raw_input_char_value;
                if( itemcount < 0 ) {
                    itemcount = 0;
                }
            } else if( action == "SCROLL_UP" ) {
                iScrollPos--;
            } else if( action == "SCROLL_DOWN" ) {
                iScrollPos++;
            } else if( action == "PREV_TAB" ) {
                if( start > 0 ) {
                    start -= maxitems;
                } else {
                    start = static_cast<int>( ( matches.size() - 1 ) / maxitems ) * maxitems;
                }
                selected = start;
                mvwprintw( w_pickup, maxitems + 2, 0, "         " );
            } else if( action == "NEXT_TAB" ) {
                if( start + maxitems < static_cast<int>( matches.size() ) ) {
                    start += maxitems;
                } else {
                    start = 0;
                }
                iScrollPos = 0;
                selected = start;
                mvwprintw( w_pickup, maxitems + 2, pickupH, "            " );
            } else if( action == "UP" ) {
                selected--;
                iScrollPos = 0;
                if( selected < 0 ) {
                    selected = matches.size() - 1;
                    start = static_cast<int>( matches.size() / maxitems ) * maxitems;
                    if( start >= static_cast<int>( matches.size() ) ) {
                        start -= maxitems;
                    }
                } else if( selected < start ) {
                    start -= maxitems;
                }
            } else if( action == "DOWN" ) {
                selected++;
                iScrollPos = 0;
                if( selected >= static_cast<int>( matches.size() ) ) {
                    selected = 0;
                    start = 0;
                } else if( selected >= start + maxitems ) {
                    start += maxitems;
                }
            } else if( selected >= 0 && selected < static_cast<int>( matches.size() ) &&
                       ( ( action == "RIGHT" && !getitem[matches[selected]].pick ) ||
                         ( action == "LEFT" && getitem[matches[selected]].pick ) ) ) {
                idx = selected;
            } else if( action == "FILTER" ) {
                new_filter = filter;
                string_input_popup popup;
                popup
                .title( _( "Set filter" ) )
                .width( 30 )
                .edit( new_filter );
                if( !popup.canceled() ) {
                    filter_changed = true;
                } else {
                    wrefresh( g->w_terrain );
                    g->draw_panels();
                }
            } else if( action == "ANY_INPUT" && raw_input_char == '`' ) {
                std::string ext = string_input_popup()
                                  .title( _( "Enter 2 letters (case sensitive):" ) )
                                  .width( 3 )
                                  .max_length( 2 )
                                  .query_string();
                if( ext.size() == 2 ) {
                    int p1 = pickup_chars.find( ext.at( 0 ) );
                    int p2 = pickup_chars.find( ext.at( 1 ) );
                    if( p1 != -1 && p2 != -1 ) {
                        idx = pickup_chars.size() + ( p1 * pickup_chars.size() ) + p2;
                    }
                }
            } else if( action == "ANY_INPUT" ) {
                idx = ( raw_input_char <= 127 ) ? pickup_chars.find( raw_input_char ) : -1;
                iScrollPos = 0;
            }

            if( idx >= 0 && idx < static_cast<int>( matches.size() ) ) {
                size_t true_idx = matches[idx];
                if( itemcount != 0 || getitem[true_idx].count == 0 ) {
                    item &temp = stacked_here[true_idx].begin()->_item;
                    int amount_available = temp.count_by_charges() ? temp.charges : stacked_here[true_idx].size();
                    if( itemcount >= amount_available ) {
                        itemcount = 0;
                    }
                    getitem[true_idx].count = itemcount;
                    itemcount = 0;
                }

                // Note: this might not change the value of getitem[idx] at all!
                getitem[true_idx].pick = ( action == "RIGHT" ? true :
                                           ( action == "LEFT" ? false :
                                             !getitem[true_idx].pick ) );
                if( action != "RIGHT" && action != "LEFT" ) {
                    selected = idx;
                    start = static_cast<int>( idx / maxitems ) * maxitems;
                }

                if( !getitem[true_idx].pick ) {
                    getitem[true_idx].count = 0;
                }
                update = true;
            }
            if( filter_changed ) {
                matches.clear();
                while( matches.empty() ) {
                    auto filter_func = item_filter_from_string( new_filter );
                    for( size_t index = 0; index < stacked_here.size(); index++ ) {
                        if( filter_func( stacked_here[index].begin()->_item ) ) {
                            matches.push_back( index );
                        }
                    }
                    if( matches.empty() ) {
                        popup( _( "Your filter returned no results" ) );
                        wrefresh( g->w_terrain );
                        g->draw_panels();
                        // The filter must have results, or simply be emptied or canceled,
                        // as this screen can't be reached without there being
                        // items available
                        string_input_popup popup;
                        popup
                        .title( _( "Set filter" ) )
                        .width( 30 )
                        .edit( new_filter );
                        if( popup.canceled() ) {
                            new_filter = filter;
                            filter_changed = false;
                        }
                    }
                }
                if( filter_changed ) {
                    filter = new_filter;
                    filter_changed = false;
                    selected = 0;
                    start = 0;
                    iScrollPos = 0;
                }
                wrefresh( g->w_terrain );
                g->draw_panels();
            }
            item &selected_item = stacked_here[matches[selected]].begin()->_item;

            werase( w_item_info );
            if( selected >= 0 && selected <= static_cast<int>( stacked_here.size() ) - 1 ) {
                std::vector<iteminfo> vThisItem;
                std::vector<iteminfo> vDummy;
                selected_item.info( true, vThisItem );

                draw_item_info( w_item_info, "", "", vThisItem, vDummy, iScrollPos, true, true );
            }
            draw_custom_border( w_item_info, 0 );
            mvwprintw( w_item_info, 0, 2, "< " );
            trim_and_print( w_item_info, 0, 4, itemsW - 8, c_white, "%s >",
                            selected_item.display_name() );
            wrefresh( w_item_info );

            if( action == "SELECT_ALL" ) {
                int count = 0;
                for( auto i : matches ) {
                    if( getitem[i].pick ) {
                        count++;
                    }
                    getitem[i].pick = true;
                }
                if( count == static_cast<int>( stacked_here.size() ) ) {
                    for( size_t i = 0; i < stacked_here.size(); i++ ) {
                        getitem[i].pick = false;
                    }
                }
                update = true;
            }
            for( cur_it = start; cur_it < start + maxitems; cur_it++ ) {
                mvwprintw( w_pickup, 1 + ( cur_it % maxitems ), 0,
                           "                                        " );
                if( cur_it < static_cast<int>( matches.size() ) ) {
                    int true_it = matches[cur_it];
                    item &this_item = stacked_here[ true_it ].begin()->_item;
                    nc_color icolor = this_item.color_in_inventory();
                    if( cur_it == selected ) {
                        icolor = hilite( c_white );
                    }

                    if( cur_it < static_cast<int>( pickup_chars.size() ) ) {
                        mvwputch( w_pickup, 1 + ( cur_it % maxitems ), 0, icolor,
                                  static_cast<char>( pickup_chars[cur_it] ) );
                    } else if( cur_it < static_cast<int>( pickup_chars.size() ) + static_cast<int>
                               ( pickup_chars.size() ) *
                               static_cast<int>( pickup_chars.size() ) ) {
                        int p = cur_it - pickup_chars.size();
                        int p1 = p / pickup_chars.size();
                        int p2 = p % pickup_chars.size();
                        mvwprintz( w_pickup, 1 + ( cur_it % maxitems ), 0, icolor, "`%c%c",
                                   static_cast<char>( pickup_chars[p1] ), static_cast<char>( pickup_chars[p2] ) );
                    } else {
                        mvwputch( w_pickup, 1 + ( cur_it % maxitems ), 0, icolor, ' ' );
                    }
                    if( getitem[true_it].pick ) {
                        if( getitem[true_it].count == 0 ) {
                            wprintz( w_pickup, c_light_blue, " + " );
                        } else {
                            wprintz( w_pickup, c_light_blue, " # " );
                        }
                    } else {
                        wprintw( w_pickup, " - " );
                    }
                    std::string item_name;
                    if( stacked_here[true_it].begin()->_item.ammo_type() == "money" ) {
                        //Count charges
                        // TODO: transition to the item_location system used for the inventory
                        unsigned long charges_total = 0;
                        for( const auto &item : stacked_here[true_it] ) {
                            charges_total += item._item.charges;
                        }
                        //Picking up none or all the cards in a stack
                        if( !getitem[true_it].pick || getitem[true_it].count == 0 ) {
                            item_name = stacked_here[true_it].begin()->_item.display_money( stacked_here[true_it].size(),
                                        charges_total );
                        } else {
                            unsigned long charges = 0;
                            int c = getitem[true_it].count;
                            for( auto it = stacked_here[true_it].begin(); it != stacked_here[true_it].end() &&
                                 c > 0; ++it, --c ) {
                                charges += it->_item.charges;
                            }
                            item_name = string_format( _( "%s of %s" ),
                                                       stacked_here[true_it].begin()->_item.display_money( getitem[true_it].count, charges ),
                                                       format_money( charges_total ) );
                        }
                    } else {
                        item_name = this_item.display_name( stacked_here[true_it].size() );
                    }
                    if( stacked_here[true_it].size() > 1 ) {
                        item_name = string_format( "%d %s", stacked_here[true_it].size(), item_name );
                    }
                    if( get_option<bool>( "ITEM_SYMBOLS" ) ) {
                        item_name = string_format( "%s %s", this_item.symbol(), item_name );
                    }
                    trim_and_print( w_pickup, 1 + ( cur_it % maxitems ), 6, pickupW - 4, icolor,
                                    item_name );
                }
            }

            mvwprintw( w_pickup, maxitems + 1, 0, _( "[%s] Unmark" ),
                       ctxt.get_desc( "LEFT", 1 ) );

            center_print( w_pickup, maxitems + 1, c_light_gray, string_format( _( "[%s] Help" ),
                          ctxt.get_desc( "HELP_KEYBINDINGS", 1 ) ) );

            right_print( w_pickup, maxitems + 1, 0, c_light_gray, string_format( _( "[%s] Mark" ),
                         ctxt.get_desc( "RIGHT", 1 ) ) );

            mvwprintw( w_pickup, maxitems + 2, 0, _( "[%s] Prev" ),
                       ctxt.get_desc( "PREV_TAB", 1 ) );

            center_print( w_pickup, maxitems + 2, c_light_gray, string_format( _( "[%s] All" ),
                          ctxt.get_desc( "SELECT_ALL", 1 ) ) );

            right_print( w_pickup, maxitems + 2, 0, c_light_gray, string_format( _( "[%s] Next" ),
                         ctxt.get_desc( "NEXT_TAB", 1 ) ) );

            if( update ) { // Update weight & volume information
                update = false;
                for( int i = 9; i < pickupW; ++i ) {
                    mvwaddch( w_pickup, 0, i, ' ' );
                }
                units::mass weight_picked_up = 0_gram;
                units::volume volume_picked_up = 0_ml;
                for( size_t i = 0; i < getitem.size(); i++ ) {
                    if( getitem[i].pick ) {
                        item temp = stacked_here[i].begin()->_item;
                        if( temp.count_by_charges() && getitem[i].count < temp.charges && getitem[i].count != 0 ) {
                            temp.charges = getitem[i].count;
                        }
                        int num_picked = std::min( stacked_here[i].size(),
                                                   getitem[i].count == 0 ? stacked_here[i].size() : getitem[i].count );
                        weight_picked_up += temp.weight() * num_picked;
                        volume_picked_up += temp.volume() * num_picked;
                    }
                }

                auto weight_predict = g->u.weight_carried() + weight_picked_up;
                auto volume_predict = g->u.volume_carried() + volume_picked_up;

                mvwprintz( w_pickup, 0, 5, weight_predict > g->u.weight_capacity() ? c_red : c_white,
                           _( "Wgt %.1f" ), round_up( convert_weight( weight_predict ), 1 ) );

                wprintz( w_pickup, c_white, "/%.1f", round_up( convert_weight( g->u.weight_capacity() ), 1 ) );

                std::string fmted_volume_predict = format_volume( volume_predict );
                mvwprintz( w_pickup, 0, 18, volume_predict > g->u.volume_capacity() ? c_red : c_white,
                           _( "Vol %s" ), fmted_volume_predict );

                std::string fmted_volume_capacity = format_volume( g->u.volume_capacity() );
                wprintz( w_pickup, c_white, "/%s", fmted_volume_capacity );
            }

            wrefresh( w_pickup );

            action = ctxt.handle_input();
            raw_input_char = ctxt.get_raw_input().get_first_input();

        } while( action != "QUIT" && action != "CONFIRM" );

        bool item_selected = false;
        // Check if we have selected an item.
        for( auto selection : getitem ) {
            if( selection.pick ) {
                item_selected = true;
            }
        }
        if( action != "CONFIRM" || !item_selected ) {
            w_pickup = catacurses::window();
            w_item_info = catacurses::window();
            add_msg( _( "Never mind." ) );
            g->reenter_fullscreen();
            g->refresh_all();
            return;
        }
    }

    // At this point we've selected our items, register an activity to pick them up.
    g->u.assign_activity( activity_id( "ACT_PICKUP" ) );
    g->u.activity.placement = p - g->u.pos();
    g->u.activity.values.push_back( from_vehicle );
    if( min == -1 ) {
        // Auto pickup will need to auto resume since there can be several of them on the stack.
        g->u.activity.auto_resume = true;
    }
    std::vector<std::pair<int, int>> pick_values;
    for( size_t i = 0; i < stacked_here.size(); i++ ) {
        const auto &selection = getitem[i];
        if( !selection.pick ) {
            continue;
        }

        const auto &stack = stacked_here[i];
        // Note: items can be both charged and stacked
        // For robustness, let's assume they can be both in the same stack
        bool pick_all = selection.count == 0;
        size_t count = selection.count;
        for( const item_idx &it : stack ) {
            if( !pick_all && count == 0 ) {
                break;
            }

            if( it._item.count_by_charges() ) {
                size_t num_picked = std::min( static_cast<size_t>( it._item.charges ), count );
                pick_values.push_back( { static_cast<int>( it.idx ), static_cast<int>( num_picked ) } );
                count -= num_picked;
            } else {
                size_t num_picked = 1;
                pick_values.push_back( { static_cast<int>( it.idx ), 0 } );
                count -= num_picked;
            }
        }
    }
    // The pickup activity picks up items last-to-first from its values list, so make sure the
    // higher indices are at the end.
    std::sort( pick_values.begin(), pick_values.end() );
    for( auto &it : pick_values ) {
        g->u.activity.values.push_back( it.first );
        g->u.activity.values.push_back( it.second );
    }

    g->reenter_fullscreen();
}
コード例 #25
0
ファイル: catacurse.cpp プロジェクト: Doohl/Cataclysm
int mvaddch(int y, int x, const chtype ch)
{
    return mvwaddch(mainwin,y,x,ch);
};
コード例 #26
0
ファイル: xmas.c プロジェクト: UnitedMarsupials/kame
void main()
{
 void done();
 int loopy;

  initscr();
  noecho();
  nonl();
  refresh();
  signal(SIGINT,done);
  signal(SIGTERM,done);
#if !defined	DOS && !defined OS2
  signal(SIGHUP,done);
  signal(SIGQUIT,done);
#endif



  treescrn = newwin(16,27,3,53);
  treescrn2 = newwin(16,27,3,53);
  treescrn3 = newwin(16,27,3,53);
  treescrn4 = newwin(16,27,3,53);
  treescrn5 = newwin(16,27,3,53);
  treescrn6 = newwin(16,27,3,53);
  treescrn7 = newwin(16,27,3,53);
  treescrn8 = newwin(16,27,3,53);

  dotdeer0 = newwin(3,71,0,8);

  stardeer0 = newwin(4,56,0,8);

  lildeer0 = newwin(7,53,0,8);
  lildeer1 = newwin(2,4,0,0);
  lildeer2 = newwin(2,4,0,0);
  lildeer3 = newwin(2,4,0,0);

  middeer0 = newwin(15,42,0,8);
  middeer1 = newwin(3,7,0,0);
  middeer2 = newwin(3,7,0,0);
  middeer3 = newwin(3,7,0,0);

  bigdeer0 = newwin(10,23,0,0);
  bigdeer1 = newwin(10,23,0,0);
  bigdeer2 = newwin(10,23,0,0);
  bigdeer3 = newwin(10,23,0,0);
  bigdeer4 = newwin(10,23,0,0);

  lookdeer0 = newwin(10,25,0,0);
  lookdeer1 = newwin(10,25,0,0);
  lookdeer2 = newwin(10,25,0,0);
  lookdeer3 = newwin(10,25,0,0);
  lookdeer4 = newwin(10,25,0,0);

  w_holiday = newwin(1,26,3,27);

  w_del_msg = newwin(1,12,23,60);

  mvwaddstr(w_del_msg,0,0,"Hit any key to quit");

  mvwaddstr(w_holiday,0,0,"H A P P Y  H O L I D A Y S");

  /* set up the windows for our various reindeer */

  /* lildeer1 */
  mvwaddch(lildeer1,0,0,(chtype)'V');
  mvwaddch(lildeer1,1,0,(chtype)'@');
  mvwaddch(lildeer1,1,1,(chtype)'<');
  mvwaddch(lildeer1,1,2,(chtype)'>');
  mvwaddch(lildeer1,1,3,(chtype)'~');

  /* lildeer2 */
  mvwaddch(lildeer2,0,0,(chtype)'V');
  mvwaddch(lildeer2,1,0,(chtype)'@');
  mvwaddch(lildeer2,1,1,(chtype)'|');
  mvwaddch(lildeer2,1,2,(chtype)'|');
  mvwaddch(lildeer2,1,3,(chtype)'~');

  /* lildeer3 */
  mvwaddch(lildeer3,0,0,(chtype)'V');
  mvwaddch(lildeer3,1,0,(chtype)'@');
  mvwaddch(lildeer3,1,1,(chtype)'>');
  mvwaddch(lildeer3,1,2,(chtype)'<');
  mvwaddch(lildeer2,1,3,(chtype)'~');


  /* middeer1 */
  mvwaddch(middeer1,0,2,(chtype)'y');
  mvwaddch(middeer1,0,3,(chtype)'y');
  mvwaddch(middeer1,1,2,(chtype)'0');
  mvwaddch(middeer1,1,3,(chtype)'(');
  mvwaddch(middeer1,1,4,(chtype)'=');
  mvwaddch(middeer1,1,5,(chtype)')');
  mvwaddch(middeer1,1,6,(chtype)'~');
  mvwaddch(middeer1,2,3,(chtype)'\\');
  mvwaddch(middeer1,2,4,(chtype)'/');

  /* middeer2 */
  mvwaddch(middeer2,0,2,(chtype)'y');
  mvwaddch(middeer2,0,3,(chtype)'y');
  mvwaddch(middeer2,1,2,(chtype)'0');
  mvwaddch(middeer2,1,3,(chtype)'(');
  mvwaddch(middeer2,1,4,(chtype)'=');
  mvwaddch(middeer2,1,5,(chtype)')');
  mvwaddch(middeer2,1,6,(chtype)'~');
  mvwaddch(middeer2,2,3,(chtype)'|');
  mvwaddch(middeer2,2,5,(chtype)'|');

  /* middeer3 */
  mvwaddch(middeer3,0,2,(chtype)'y');
  mvwaddch(middeer3,0,3,(chtype)'y');
  mvwaddch(middeer3,1,2,(chtype)'0');
  mvwaddch(middeer3,1,3,(chtype)'(');
  mvwaddch(middeer3,1,4,(chtype)'=');
  mvwaddch(middeer3,1,5,(chtype)')');
  mvwaddch(middeer3,1,6,(chtype)'~');
  mvwaddch(middeer3,2,2,(chtype)'/');
  mvwaddch(middeer3,2,6,(chtype)'\\');


  /* bigdeer1 */
  mvwaddch(bigdeer1,0,17,(chtype)'\\');
  mvwaddch(bigdeer1,0,18,(chtype)'/');
  mvwaddch(bigdeer1,0,20,(chtype)'\\');
  mvwaddch(bigdeer1,0,21,(chtype)'/');
  mvwaddch(bigdeer1,1,18,(chtype)'\\');
  mvwaddch(bigdeer1,1,20,(chtype)'/');
  mvwaddch(bigdeer1,2,19,(chtype)'|');
  mvwaddch(bigdeer1,2,20,(chtype)'_');
  mvwaddch(bigdeer1,3,18,(chtype)'/');
  mvwaddch(bigdeer1,3,19,(chtype)'^');
  mvwaddch(bigdeer1,3,20,(chtype)'0');
  mvwaddch(bigdeer1,3,21,(chtype)'\\');
  mvwaddch(bigdeer1,4,17,(chtype)'/');
  mvwaddch(bigdeer1,4,18,(chtype)'/');
  mvwaddch(bigdeer1,4,19,(chtype)'\\');
  mvwaddch(bigdeer1,4,22,(chtype)'\\');
  mvwaddstr(bigdeer1,5,7,"^~~~~~~~~//  ~~U");
  mvwaddstr(bigdeer1,6,7,"( \\_____( /");
  mvwaddstr(bigdeer1,7,8,"( )    /");
  mvwaddstr(bigdeer1,8,9,"\\\\   /");
  mvwaddstr(bigdeer1,9,11,"\\>/>");

  /* bigdeer2 */
  mvwaddch(bigdeer2,0,17,(chtype)'\\');
  mvwaddch(bigdeer2,0,18,(chtype)'/');
  mvwaddch(bigdeer2,0,20,(chtype)'\\');
  mvwaddch(bigdeer2,0,21,(chtype)'/');
  mvwaddch(bigdeer2,1,18,(chtype)'\\');
  mvwaddch(bigdeer2,1,20,(chtype)'/');
  mvwaddch(bigdeer2,2,19,(chtype)'|');
  mvwaddch(bigdeer2,2,20,(chtype)'_');
  mvwaddch(bigdeer2,3,18,(chtype)'/');
  mvwaddch(bigdeer2,3,19,(chtype)'^');
  mvwaddch(bigdeer2,3,20,(chtype)'0');
  mvwaddch(bigdeer2,3,21,(chtype)'\\');
  mvwaddch(bigdeer2,4,17,(chtype)'/');
  mvwaddch(bigdeer2,4,18,(chtype)'/');
  mvwaddch(bigdeer2,4,19,(chtype)'\\');
  mvwaddch(bigdeer2,4,22,(chtype)'\\');
  mvwaddstr(bigdeer2,5,7,"^~~~~~~~~//  ~~U");
  mvwaddstr(bigdeer2,6,7,"(( )____( /");
  mvwaddstr(bigdeer2,7,7,"( /      |");
  mvwaddstr(bigdeer2,8,8,"\\/      |");
  mvwaddstr(bigdeer2,9,9,"|>     |>");

  /* bigdeer3 */
  mvwaddch(bigdeer3,0,17,(chtype)'\\');
  mvwaddch(bigdeer3,0,18,(chtype)'/');
  mvwaddch(bigdeer3,0,20,(chtype)'\\');
  mvwaddch(bigdeer3,0,21,(chtype)'/');
  mvwaddch(bigdeer3,1,18,(chtype)'\\');
  mvwaddch(bigdeer3,1,20,(chtype)'/');
  mvwaddch(bigdeer3,2,19,(chtype)'|');
  mvwaddch(bigdeer3,2,20,(chtype)'_');
  mvwaddch(bigdeer3,3,18,(chtype)'/');
  mvwaddch(bigdeer3,3,19,(chtype)'^');
  mvwaddch(bigdeer3,3,20,(chtype)'0');
  mvwaddch(bigdeer3,3,21,(chtype)'\\');
  mvwaddch(bigdeer3,4,17,(chtype)'/');
  mvwaddch(bigdeer3,4,18,(chtype)'/');
  mvwaddch(bigdeer3,4,19,(chtype)'\\');
  mvwaddch(bigdeer3,4,22,(chtype)'\\');
  mvwaddstr(bigdeer3,5,7,"^~~~~~~~~//  ~~U");
  mvwaddstr(bigdeer3,6,6,"( ()_____( /");
  mvwaddstr(bigdeer3,7,6,"/ /       /");
  mvwaddstr(bigdeer3,8,5,"|/          \\");
  mvwaddstr(bigdeer3,9,5,"/>           \\>");

  /* bigdeer4 */
  mvwaddch(bigdeer4,0,17,(chtype)'\\');
  mvwaddch(bigdeer4,0,18,(chtype)'/');
  mvwaddch(bigdeer4,0,20,(chtype)'\\');
  mvwaddch(bigdeer4,0,21,(chtype)'/');
  mvwaddch(bigdeer4,1,18,(chtype)'\\');
  mvwaddch(bigdeer4,1,20,(chtype)'/');
  mvwaddch(bigdeer4,2,19,(chtype)'|');
  mvwaddch(bigdeer4,2,20,(chtype)'_');
  mvwaddch(bigdeer4,3,18,(chtype)'/');
  mvwaddch(bigdeer4,3,19,(chtype)'^');
  mvwaddch(bigdeer4,3,20,(chtype)'0');
  mvwaddch(bigdeer4,3,21,(chtype)'\\');
  mvwaddch(bigdeer4,4,17,(chtype)'/');
  mvwaddch(bigdeer4,4,18,(chtype)'/');
  mvwaddch(bigdeer4,4,19,(chtype)'\\');
  mvwaddch(bigdeer4,4,22,(chtype)'\\');
  mvwaddstr(bigdeer4,5,7,"^~~~~~~~~//  ~~U");
  mvwaddstr(bigdeer4,6,6,"( )______( /");
  mvwaddstr(bigdeer4,7,5,"(/          \\");
  mvwaddstr(bigdeer4,8,0,"v___=             ----^");


  /* lookdeer1 */
  mvwaddstr(lookdeer1,0,16,"\\/     \\/");
  mvwaddstr(lookdeer1,1,17,"\\Y/ \\Y/");
  mvwaddstr(lookdeer1,2,19,"\\=/");
  mvwaddstr(lookdeer1,3,17,"^\\o o/^");
  mvwaddstr(lookdeer1,4,17,"//( )");
  mvwaddstr(lookdeer1,5,7,"^~~~~~~~~// \\O/");
  mvwaddstr(lookdeer1,6,7,"( \\_____( /");
  mvwaddstr(lookdeer1,7,8,"( )    /");
  mvwaddstr(lookdeer1,8,9,"\\\\   /");
  mvwaddstr(lookdeer1,9,11,"\\>/>");

  /* lookdeer2 */
  mvwaddstr(lookdeer2,0,16,"\\/     \\/");
  mvwaddstr(lookdeer2,1,17,"\\Y/ \\Y/");
  mvwaddstr(lookdeer2,2,19,"\\=/");
  mvwaddstr(lookdeer2,3,17,"^\\o o/^");
  mvwaddstr(lookdeer2,4,17,"//( )");
  mvwaddstr(lookdeer2,5,7,"^~~~~~~~~// \\O/");
  mvwaddstr(lookdeer2,6,7,"(( )____( /");
  mvwaddstr(lookdeer2,7,7,"( /      |");
  mvwaddstr(lookdeer2,8,8,"\\/      |");
  mvwaddstr(lookdeer2,9,9,"|>     |>");

  /* lookdeer3 */
  mvwaddstr(lookdeer3,0,16,"\\/     \\/");
  mvwaddstr(lookdeer3,1,17,"\\Y/ \\Y/");
  mvwaddstr(lookdeer3,2,19,"\\=/");
  mvwaddstr(lookdeer3,3,17,"^\\o o/^");
  mvwaddstr(lookdeer3,4,17,"//( )");
  mvwaddstr(lookdeer3,5,7,"^~~~~~~~~// \\O/");
  mvwaddstr(lookdeer3,6,6,"( ()_____( /");
  mvwaddstr(lookdeer3,7,6,"/ /       /");
  mvwaddstr(lookdeer3,8,5,"|/          \\");
  mvwaddstr(lookdeer3,9,5,"/>           \\>");

  /* lookdeer4 */
  mvwaddstr(lookdeer4,0,16,"\\/     \\/");
  mvwaddstr(lookdeer4,1,17,"\\Y/ \\Y/");
  mvwaddstr(lookdeer4,2,19,"\\=/");
  mvwaddstr(lookdeer4,3,17,"^\\o o/^");
  mvwaddstr(lookdeer4,4,17,"//( )");
  mvwaddstr(lookdeer4,5,7,"^~~~~~~~~// \\O/");
  mvwaddstr(lookdeer4,6,6,"( )______( /");
  mvwaddstr(lookdeer4,7,5,"(/          \\");
  mvwaddstr(lookdeer4,8,0,"v___=             ----^");



  /***********************************************/
  cbreak();
  nodelay(stdscr,TRUE);
  do
  {
    clear();
    werase(treescrn);
    touchwin(treescrn);
    werase(treescrn2);
    touchwin(treescrn2);
    werase(treescrn8);
    touchwin(treescrn8);
    refresh();
    usleep(1000);
    boxit();
    refresh();
    usleep(1000);
    seas();
    refresh();
    usleep(1000);
    greet();
    refresh();
    usleep(1000);
    fromwho();
    refresh();
    usleep(1000);
    tree();
    usleep(1000);
    balls();
    usleep(1000);
    star();
    usleep(1000);
    strng1();
    strng2();
    strng3();
    strng4();
    strng5();


  /* set up the windows for our blinking trees */
  /* **************************************** */
  /* treescrn3 */

               overlay(treescrn, treescrn3);

             /*balls*/
               mvwaddch(treescrn3, 4, 18, ' ');
               mvwaddch(treescrn3, 7, 6, ' ');
               mvwaddch(treescrn3, 8, 19, ' ');
               mvwaddch(treescrn3, 11, 22, ' ');

             /*star*/
               mvwaddch(treescrn3, 0, 12, '*');

             /*strng1*/
               mvwaddch(treescrn3, 3, 11, ' ');

             /*strng2*/
               mvwaddch(treescrn3, 5, 13, ' ');
               mvwaddch(treescrn3, 6, 10, ' ');

             /*strng3*/
               mvwaddch(treescrn3, 7, 16, ' ');
               mvwaddch(treescrn3, 7, 14, ' ');

             /*strng4*/
               mvwaddch(treescrn3, 10, 13, ' ');
               mvwaddch(treescrn3, 10, 10, ' ');
               mvwaddch(treescrn3, 11, 8, ' ');

             /*strng5*/
               mvwaddch(treescrn3, 11, 18, ' ');
               mvwaddch(treescrn3, 12, 13, ' ');


  /* treescrn4 */

               overlay(treescrn, treescrn4);

             /*balls*/
               mvwaddch(treescrn4, 3, 9, ' ');
               mvwaddch(treescrn4, 4, 16, ' ');
               mvwaddch(treescrn4, 7, 6, ' ');
               mvwaddch(treescrn4, 8, 19, ' ');
               mvwaddch(treescrn4, 11, 2, ' ');
               mvwaddch(treescrn4, 12, 23, ' ');

             /*star*/
               wstandout(treescrn4);
               mvwaddch(treescrn4, 0, 12, '*');
               wstandend(treescrn4);

             /*strng1*/
               mvwaddch(treescrn4, 3, 13, ' ');

             /*strng2*/

	     /*strng3*/
               mvwaddch(treescrn4, 7, 15, ' ');
               mvwaddch(treescrn4, 8, 11, ' ');

             /*strng4*/
               mvwaddch(treescrn4, 9, 16, ' ');
               mvwaddch(treescrn4, 10, 12, ' ');
               mvwaddch(treescrn4, 11, 8, ' ');

             /*strng5*/
               mvwaddch(treescrn4, 11, 18, ' ');
	       mvwaddch(treescrn4, 12, 14, ' ');


  /* treescrn5 */

               overlay(treescrn, treescrn5);

             /*balls*/
               mvwaddch(treescrn5, 3, 15, ' ');
               mvwaddch(treescrn5, 10, 20, ' ');
               mvwaddch(treescrn5, 12, 1, ' ');

             /*star*/
               mvwaddch(treescrn5, 0, 12, '*');

             /*strng1*/
               mvwaddch(treescrn5, 3, 11, ' ');

             /*strng2*/
               mvwaddch(treescrn5, 5, 12, ' ');

             /*strng3*/
	       mvwaddch(treescrn5, 7, 14, ' ');
               mvwaddch(treescrn5, 8, 10, ' ');

             /*strng4*/
               mvwaddch(treescrn5, 9, 15, ' ');
               mvwaddch(treescrn5, 10, 11, ' ');
               mvwaddch(treescrn5, 11, 7, ' ');

             /*strng5*/
               mvwaddch(treescrn5, 11, 17, ' ');
               mvwaddch(treescrn5, 12, 13, ' ');

  /* treescrn6 */

               overlay(treescrn, treescrn6);

             /*balls*/
               mvwaddch(treescrn6, 6, 7, ' ');
               mvwaddch(treescrn6, 7, 18, ' ');
               mvwaddch(treescrn6, 10, 4, ' ');
               mvwaddch(treescrn6, 11, 23, ' ');

	     /*star*/
               wstandout(treescrn6);
               mvwaddch(treescrn6, 0, 12, '*');
               wstandend(treescrn6);

             /*strng1*/

             /*strng2*/
               mvwaddch(treescrn6, 5, 11, ' ');

             /*strng3*/
	       mvwaddch(treescrn6, 7, 13, ' ');
               mvwaddch(treescrn6, 8, 9, ' ');

             /*strng4*/
               mvwaddch(treescrn6, 9, 14, ' ');
               mvwaddch(treescrn6, 10, 10, ' ');
               mvwaddch(treescrn6, 11, 6, ' ');

             /*strng5*/
               mvwaddch(treescrn6, 11, 16, ' ');
               mvwaddch(treescrn6, 12, 12, ' ');

  /* treescrn7 */

               overlay(treescrn, treescrn7);

             /*balls*/
               mvwaddch(treescrn7, 3, 15, ' ');
               mvwaddch(treescrn7, 6, 7, ' ');
               mvwaddch(treescrn7, 7, 18, ' ');
               mvwaddch(treescrn7, 10, 4, ' ');
               mvwaddch(treescrn7, 11, 22, ' ');

             /*star*/
               mvwaddch(treescrn7, 0, 12, '*');

             /*strng1*/
               mvwaddch(treescrn7, 3, 12, ' ');

             /*strng2*/
               mvwaddch(treescrn7, 5, 13, ' ');
               mvwaddch(treescrn7, 6, 9, ' ');

	     /*strng3*/
               mvwaddch(treescrn7, 7, 15, ' ');
               mvwaddch(treescrn7, 8, 11, ' ');

             /*strng4*/
               mvwaddch(treescrn7, 9, 16, ' ');
               mvwaddch(treescrn7, 10, 12, ' ');
               mvwaddch(treescrn7, 11, 8, ' ');

             /*strng5*/
               mvwaddch(treescrn7, 11, 18, ' ');
	       mvwaddch(treescrn7, 12, 14, ' ');


    usleep(1000);
    reindeer();

    touchwin(w_holiday);
    wrefresh(w_holiday);
    wrefresh(w_del_msg);

    usleep(1000);
    for(loopy = 0;loopy < 100;loopy++)
    {
      blinkit();
    }

#ifdef NOLOOP
    done();
#endif

  }
  while(getch() == (ERR));
/*  while(!typeahead(stdin));*/
  done();
}
コード例 #27
0
ファイル: help.cpp プロジェクト: alexandruradovici/linuxeyes
void about(int scr)
{
/*    initscr();
    WINDOW *w;
    w=newwin (16,78,7,1);
    werase(w);
    setcolor (1,1);
    mvprintw (7,34,"LinuxEyes");
    setcolor (1,1);
    mvprintw (9,2,"AUTHOR");
    mvprintw (13,2,"COPYRIGHT");
    mvprintw (17,2,"LOTS OF THANKS TO");
    mvprintw (20,2,"BUGS AND SUGGESTIONS");
    setcolor (1,0);
    mvprintw (10,5,"Alexandru Radovici - [email protected]");
    mvprintw (11,5,"                     [email protected]");
    mvprintw (14,5,"This program is free. You may use it on your own risk. You may distribute");
    mvprintw (15,2,"it only integral.");
    mvprintw (18,5,"Xaudio - http://www.xaudio.com"); 
    mvprintw (21,5,"If you have found bugs or have some suggestions to make please send me an");
    mvprintw (22,2,"e-mail. Thank you.");
    wrefresh (w); */
  int v,k;
  char s[100][100];
  strcpy (s[0],"AUTHOR");
  strcpy (s[1],"    Alexandru Radovici - [email protected]");
  strcpy (s[2],"");
  strcpy (s[3],"VERSION");
  strcpy (s[4],"    LinuxEyes 0.8, build 0.8.6 (February 8, 2003)");
  strcpy (s[5],"");
  strcpy (s[6],"ROMANIAN SOFTWARE");
  strcpy (s[7],"    This software was made in Romania!");
  strcpy (s[8],"");
  strcpy (s[9],"WEBSITE");
  strcpy (s[10],"    http://lug.orizont.net/~linuxeyes");
  strcpy (s[11],"");
  strcpy (s[12],"COPYRIGHT & DISTRIBUTION");
  strcpy (s[13],"    This software is freeware, you may use it on your");
  strcpy (s[14],"own risk. You may distribute it only integral.");
  strcpy (s[15],"");
  strcpy (s[16],"MPEG Audio Layer 3");
  strcpy (s[17],"    Xaudio - http://www.xaudio.com");
  strcpy (s[18],"");
  strcpy (s[19],"BUGS & SUGGESTIONS");
  strcpy (s[20],"    If you find any bugs or have any suggestion please");
  strcpy (s[21],"email me. ([email protected]) Thank you!");
  strcpy (s[22],"");
  strcpy (s[23],"LOTS OF THANKS TO");
  strcpy (s[24],"    Vera and Iuliu Radovici");
  strcpy (s[25],"    Ovidiu Stoica - [email protected]");
  strcpy (s[26],"    Alexandru Armean - [email protected]");
  strcpy (s[27],"    Valeriu Moldovan - [email protected]");
  strcpy (s[28],"    Cristian Klein - [email protected]");
  strcpy (s[29],"");
  strcpy (s[30],"CURRENT SESSION STATISTICS");
  sprintf (s[31],"    Songs Played: %d",(int)n_songs);
  sprintf (s[32],"    Time Played: %d:%.2d:%.2d",(int)n_secs/(60*60),(int)(n_secs/60)%60,(int)n_secs%60);
  strcpy (s[33],"");
  strcpy (s[34],"GLOBAL STATISTICS");
  sprintf (s[35],"    Songs Played: %d",(int)songs);
  sprintf (s[36],"    Time Played: %d:%.2d:%.2d",(int)secs/(60*60),(int)(secs/60)%60,(int)secs%60);
  WINDOW *w1;
  w1=newwin (scr+2,62,7,(nrcols-62)/2);
  wrefresh (w1);
  werase (w1);
  WINDOW *w;
  w=newwin (scr,60,8,(nrcols-60)/2);
  wsetcolor (w,12,0);
  for (int h=0;h<=scr+2;h++) mvwprintw (w,h,0,"                                                            ");
  wsetcolor (w,12,0);
  le_border (w,60,scr);
  wsetcolor (w,13,1);
  mvwprintw (w,0,1," About LinuxEyes ");
  wsetcolor (w,12,0);
  mvwprintw (w,scr-1,46," ESC - quit ");
  wrefresh(w);
  noecho();
  timeout (1);
  k=0;
  do
  {
    wsetcolor (w,12,0);
    for (int i=0;i<=scr-5;i++) 
    {
      mvwprintw (w,2+i,2,"                                                         ");
      mvwprintw (w,2+i,2,"%s",s[i+k]);
    }
    wsetcolor (w,12,0);
    mvwaddch (w,0,28,ACS_HLINE);
    mvwaddch (w,scr-1,28,ACS_HLINE);
    wsetcolor (w,12,1);
    if (k>0) mvwaddch (w,0,28,ACS_UARROW);
    if (k<35-(scr-5)) mvwaddch (w,scr-1,28,ACS_DARROW);
    wrefresh(w);
    do
    {
      sprintf (s[31],"    Songs Played: %d",(int)n_songs);
      sprintf (s[32],"    Time Played: %d:%.2d:%.2d",(int)n_secs/(60*60),(int)(n_secs/60)%60,(int)n_secs%60);
      sprintf (s[35],"    Songs Played: %d",(int)songs);
      sprintf (s[36],"    Time Played: %d:%.2d:%.2d",(int)secs/(60*60),(int)(secs/60)%60,(int)secs%60);
      for (int i=0;i<=scr-5;i++) if (((i+k)==30) || ((i+k)==31) || ((i+k)==34) || ((i+k)==35))
      {
        wsetcolor (w,12,0);
        mvwprintw (w,2+i,2,"                                                         ");
        mvwprintw (w,2+i,2,"%s",s[i+k]);
	wrefresh (w);
      }
      messages();
      v=getch();
    } while (v==ERR);
    if (v == 27) 
    {
      v=getch();
      if (v==ERR) v='q';
      if (v==91)
      {
        v=getch();
	if (v==65) if (k > 0) k--;
        if (v==66) if (k < 36-(scr-5)) k++;
      }
    }
    if (v=='R')
    {
      n_songs=0;
      n_secs=0;
    }
  }    
  while (v!='q');
  werase (w);
  reread=1;
}
コード例 #28
0
ファイル: xmas.c プロジェクト: UnitedMarsupials/kame
tree()
{
  mvwaddch(treescrn, 1, 11, (chtype)'/');
  mvwaddch(treescrn, 2, 11, (chtype)'/');
  mvwaddch(treescrn, 3, 10, (chtype)'/');
  mvwaddch(treescrn, 4, 9, (chtype)'/');
  mvwaddch(treescrn, 5, 9, (chtype)'/');
  mvwaddch(treescrn, 6, 8, (chtype)'/');
  mvwaddch(treescrn, 7, 7, (chtype)'/');
  mvwaddch(treescrn, 8, 6, (chtype)'/');
  mvwaddch(treescrn, 9, 6, (chtype)'/');
  mvwaddch(treescrn, 10, 5, (chtype)'/');
  mvwaddch(treescrn, 11, 3, (chtype)'/');
  mvwaddch(treescrn, 12, 2, (chtype)'/');

  mvwaddch(treescrn, 1, 13, (chtype)'\\');
  mvwaddch(treescrn, 2, 13, (chtype)'\\');
  mvwaddch(treescrn, 3, 14, (chtype)'\\');
  mvwaddch(treescrn, 4, 15, (chtype)'\\');
  mvwaddch(treescrn, 5, 15, (chtype)'\\');
  mvwaddch(treescrn, 6, 16, (chtype)'\\');
  mvwaddch(treescrn, 7, 17, (chtype)'\\');
  mvwaddch(treescrn, 8, 18, (chtype)'\\');
  mvwaddch(treescrn, 9, 18, (chtype)'\\');
  mvwaddch(treescrn, 10, 19, (chtype)'\\');
  mvwaddch(treescrn, 11, 21, (chtype)'\\');
  mvwaddch(treescrn, 12, 22, (chtype)'\\');

  mvwaddch(treescrn, 4, 10, (chtype)'_');
  mvwaddch(treescrn, 4, 14, (chtype)'_');
  mvwaddch(treescrn, 8, 7, (chtype)'_');
  mvwaddch(treescrn, 8, 17, (chtype)'_');

  mvwaddstr(treescrn, 13, 0, "//////////// \\\\\\\\\\\\\\\\\\\\\\\\");

  mvwaddstr(treescrn, 14, 11, "| |");
  mvwaddstr(treescrn, 15, 11, "|_|");

  wrefresh(treescrn);
  wrefresh(w_del_msg);

  return( 0 );
}
コード例 #29
0
static bool garmin_bin_initialize(void)
{
    /*@-globstate@*/
    unsigned int i;

#ifndef CONTROLSEND_ENABLE
    if(serial) {
	monitor_complain("Direct mode doesn't supported.");
	return false;
    }
#endif

    /*@ -onlytrans @*/
    miscwin = subwin(devicewin, 1, 80, 1, 0);
    mid51win = subwin(devicewin, 12, 18, 2, 0);
    mid114win = subwin(devicewin, GARMIN_CHANNELS + 3, 23, 2, 18);
    if (miscwin == NULL || mid51win == NULL || mid114win == NULL)
	return false;

    (void)syncok(miscwin, true);
    (void)syncok(mid51win, true);
    (void)syncok(mid114win, true);

    /*@ -nullpass @*/
    (void)wattrset(miscwin, A_BOLD);
    display(miscwin, 0, 0, "Time:");
    (void)wattrset(miscwin, A_NORMAL);

    (void)wborder(mid51win, 0, 0, 0, 0, 0, 0, 0, 0),
    (void)wattrset(mid51win, A_BOLD);
    display(mid51win, 0, 4, " Position ");
    display(mid51win, 1, 2, "Fix:");
    display(mid51win, 2, 2, "Lat:");
    (void)mvwaddch(mid51win, 2, 16, ACS_DEGREE);
    display(mid51win, 3, 2, "Lon:");
    (void)mvwaddch(mid51win, 3, 16, ACS_DEGREE);
    display(mid51win, 4, 2, "Alt:          m");
    display(mid51win, 5, 2, "Speed:      m/s");
    display(mid51win, 6, 2, "Climb:      m/s");
    display(mid51win, 7, 2, "Leap:   sec");
    display(mid51win, 8, 2, "epe:       m");
    display(mid51win, 9, 2, "eph:       m");
    display(mid51win, 10, 2, "epv:       m");
    display(mid51win, 11, 3, " ID 51 (0x33) ");
    (void)wattrset(mid51win, A_NORMAL);

    (void)wborder(mid114win, 0, 0, 0, 0, 0, 0, 0, 0),
	(void)wattrset(mid114win, A_BOLD);
    display(mid114win, 1, 1, "Ch PRN  Az El  SNR ST");
    for (i = 0; i < GARMIN_CHANNELS; i++) {
	display(mid114win, (int)i + 2, 1, "%2d", i);
    }
    display(mid114win, 0, 5, " Satellite ");
    display(mid114win, 14, 4, " ID 114 (0x72) ");
    (void)wattrset(mid114win, A_NORMAL);

    /* initialize the GPS context's time fields */
    gpsd_time_init(session.context, time(NULL));

    return true;
    /*@+globstate@*/
}
コード例 #30
0
ファイル: engine.c プロジェクト: liushizhe/yetris
/** PDCurses (on Windows) doesn't have this function, so I need
 *  to re-implement it.
 *  TODO: implement more features - see 'man mvwhline'
 */
void my_mvwhline(WINDOW* win, int y, int x, chtype ch, int num)
{
	int i;
	for (i = 0; i < num; i++)
		mvwaddch(win, y, (x + i), ch);
}