int main(int argc, char *argv[]) { int right[4], guess[4], backup[4]; int halfrights,rights; int tmp,i; int tries = 3; int maxtries; int place,color; int x,y; char charbuffer[10]; char question[2]; int pplace[4]; pplace[0] = 13; pplace[1] = 15; pplace[2] = 17; pplace[3] = 19; halfrights=rights=0; srand(time(0)); printf("Can two places be the same color? (y/n) "); scanf("%s",charbuffer); strcpy(question,"n"); if (strcmp(charbuffer,question) == 0) { for (i=0;i<4;i++) { BACK: right[i] = (8.0*rand()/RAND_MAX+1.0); for (tmp=0;tmp<4;tmp++) { if (right[i] == right[tmp] && i != tmp) { goto BACK; } } guess[i] = 0; } } else { for (i=0;i<4;i++) { right[i] = (8.0*rand()/RAND_MAX+1.0); guess[i] = 0; } } for (i=0;i<4;i++) { backup[i] = right[i]; } printf("How many tries would you like? "); scanf("%i",&maxtries); printf("\n"); if (maxtries <= 0) { printf("Ok, fine.\n"); return 1; } printf("\nI have come up with a color combination. Press enter to start the game.\n"); getchar(); getchar(); initscr(); start_color(); getmaxyx(stdscr,y,x); if (y < 22) { endwin(); printf("Terminal too small\n"); return 1; } if (maxtries > (x/3-3)) { endwin(); printf("You have too many tries to be on the screen.\n"); return 1; } /* Color definations: */ init_pair(1, COLOR_WHITE, COLOR_RED); init_pair(2, COLOR_WHITE, COLOR_GREEN); init_pair(3, COLOR_WHITE, COLOR_BLUE); init_pair(4, COLOR_WHITE, COLOR_BLACK); init_pair(5, COLOR_WHITE, COLOR_MAGENTA); init_pair(6, COLOR_BLACK, COLOR_WHITE); init_pair(7, COLOR_WHITE, COLOR_CYAN); init_pair(8, COLOR_WHITE, COLOR_YELLOW); mvprintw(5,0,"Colors: 1: Red, 2: Green, 3: Blue, 4: Black"); mvprintw(6,0,"Colors: 5: Magenta, 6: White, 7: Cyan, 8: Yellow"); mvprintw(8,0,"Right colors on right places:"); mvprintw(10,0,"Right colors on wrong places:"); mvprintw(pplace[0],0,"1:"); mvprintw(pplace[1],0,"2:"); mvprintw(pplace[2],0,"3:"); mvprintw(pplace[3],0,"4:"); mvprintw(0,x/2-10,"Tries left: %i ",maxtries); GETPLACE: mvprintw(0,0,"Place:"); mvprintw(1,2," "); mvprintw(1,0,"? "); scanw("%i",&place); if (place < 1 || place > 4) { /* if the user types too many */ for (i=2;i<=x;i++) { /* cifers, we want to clean it up */ mvprintw(1,i," "); } goto GETPLACE; } GETCOLOR: mvprintw(0,0,"Color:"); mvprintw(1,2," "); move(1,2); scanw("%i",&color); if (color < 1 || color > 8) { /* same here */ for (i=2;i<=x;i++) { mvprintw(1,i," "); } goto GETCOLOR; } attrset(COLOR_PAIR(color)); mvprintw(pplace[place-1],tries,"%i",color); attrset(A_NORMAL); guess[place-1] = color; tmp = 1; for (i=0;i<4;i++) { if (guess[i] == 0) { tmp = 0; } } if (tmp) { /* All fields are filled */ mvprintw(pplace[3]+2,4,"Is that a guess? (y/n) "); refresh(); scanw("%s",charbuffer); strcpy(question,"y"); for (i=4;i<=x;i++) { mvprintw(pplace[3]+2,i," "); } if (strcmp(charbuffer,question) == 0) { for (i=0;i<4;i++) { if (right[i] == guess[i]) { /* Finds out how many right colors on right places */ rights++; /* the user has placed. */ right[i] = guess[i] = 0; /* This line makes sure this guess is not counted again */ } } for (i=0;i<4;i++) { for (tmp=0;tmp<4;tmp++) { if (guess[tmp] == right[i] && right[i] != 0) { halfrights++; guess[tmp] = right[i] = 0; /* This line makes sure this guess is not counted again */ } } } if (rights == 4) { endwin(); printf("CONGRATULATIONS!\n"); printf("You guessed the right combination!\n"); printf("You used %i tries\n", tries/3); return 0; } for (i=0;i<4;i++) { right[i] = backup[i]; /* We deleted the right[] array, we have to get it back for next check */ } mvprintw(9,tries,"%i",rights); mvprintw(11,tries,"%i",halfrights); halfrights=rights=0; for (i=0;i<4;i++) { guess[i] = 0; } tries = tries+3; maxtries--; mvprintw(0,x/2-10,"Tries left: %i ",maxtries); if (maxtries == 0) { for (i=0;i<4;i++) { attrset(COLOR_PAIR(right[i])); mvprintw(pplace[i],0,"%i",right[i]); attrset(A_NORMAL); } mvprintw(y-2,0,"Wrong, and you are out of tries..\n"); printw("Press enter to end program"); refresh(); getchar(); endwin(); return 1; } } } goto GETPLACE; endwin(); return 0; }
int optionsEditor(dialogMenuItem *self) { int i, optcol, optrow, key; static int currOpt = 0; dialog_clear_norefresh(); clear(); while (1) { /* Whap up the header */ attrset(A_REVERSE); mvaddstr(0, 0, "Options Editor"); attrset(A_NORMAL); for (i = 0; i < 2; i++) { mvaddstr(OPT_START_ROW - 2, OPT_NAME_COL + (i * GROUP_OFFSET), "Name"); mvaddstr(OPT_START_ROW - 1, OPT_NAME_COL + (i * GROUP_OFFSET), "----"); mvaddstr(OPT_START_ROW - 2, OPT_VALUE_COL + (i * GROUP_OFFSET), "Value"); mvaddstr(OPT_START_ROW - 1, OPT_VALUE_COL + (i * GROUP_OFFSET), "-----"); } /* And the footer */ mvprintw(OPT_END_ROW + 1, 0, "Use SPACE to select/toggle an option, arrow keys to move,"); mvprintw(OPT_END_ROW + 2, 0, "? or F1 for more help. When you're done, type Q to Quit."); optrow = OPT_START_ROW; optcol = OPT_NAME_COL; for (i = 0; Options[i].name; i++) { /* Names are painted somewhat gratuitously each time, but it's easier this way */ mvprintw(optrow, OPT_NAME_COL + optcol, Options[i].name); if (currOpt == i) attrset(ATTR_SELECTED); mvprintw(optrow++, OPT_VALUE_COL + optcol, value_of(Options[i])); if (currOpt == i) attrset(A_NORMAL); if (optrow == OPT_END_ROW) { optrow = OPT_START_ROW; optcol += GROUP_OFFSET; } clrtoeol(); } attrset(ATTR_TITLE); mvaddstr(OPT_END_ROW + 4, 0, Options[currOpt].desc); attrset(A_NORMAL); clrtoeol(); move(0, 14); refresh(); /* Start the edit loop */ key = toupper(getch()); switch (key) { case KEY_F(1): case '?': systemDisplayHelp("options"); clear(); break; case '\020': /* ^P */ case KEY_UP: if (currOpt) --currOpt; else for (currOpt = 0; Options[currOpt + 1].name; currOpt++); continue; case '\016': /* ^N */ case KEY_DOWN: if (Options[currOpt + 1].name) ++currOpt; else currOpt = 0; continue; case KEY_HOME: currOpt = 0; continue; case KEY_END: while (Options[currOpt + 1].name) ++currOpt; continue; case ' ': if (fire(Options[currOpt])) clear(); continue; case '\033': /* ESC */ case 'Q': clear(); dialog_clear(); return DITEM_SUCCESS | DITEM_RESTORE; default: beep(); } } /* NOTREACHED */ return DITEM_SUCCESS | DITEM_RESTORE; }
void col_set(int kolor) { switch(kolor) { case 0:attrset(COLOR_PAIR(1));break; case 1:attrset(COLOR_PAIR(5));break; case 2:attrset(COLOR_PAIR(3));break; case 3:attrset(COLOR_PAIR(7));break; case 4:attrset(COLOR_PAIR(2));break; case 5:attrset(COLOR_PAIR(6));break; case 6:attrset(COLOR_PAIR(4));break; case 7:attrset(COLOR_PAIR(8));break; case 8:attrset(A_BOLD|COLOR_PAIR(1));break; case 9:attrset(A_BOLD|COLOR_PAIR(5));break; case 10:attrset(A_BOLD|COLOR_PAIR(3));break; case 11:attrset(A_BOLD|COLOR_PAIR(7));break; case 12:attrset(A_BOLD|COLOR_PAIR(2));break; case 13:attrset(A_BOLD|COLOR_PAIR(6));break; case 14:attrset(A_BOLD|COLOR_PAIR(4));break; case 15:attrset(A_BOLD|COLOR_PAIR(8));break; case 16:attrset(COLOR_PAIR(9));break; case 17:attrset(COLOR_PAIR(13));break; case 18:attrset(COLOR_PAIR(11));break; case 19:attrset(COLOR_PAIR(15));break; case 20:attrset(COLOR_PAIR(10));break; case 21:attrset(COLOR_PAIR(14));break; case 22:attrset(COLOR_PAIR(12));break; case 23:attrset(COLOR_PAIR(16));break; case 24:attrset(A_BOLD|COLOR_PAIR(9));break; case 25:attrset(A_BOLD|COLOR_PAIR(13));break; case 26:attrset(A_BOLD|COLOR_PAIR(11));break; case 27:attrset(A_BOLD|COLOR_PAIR(15));break; case 28:attrset(A_BOLD|COLOR_PAIR(10));break; case 29:attrset(A_BOLD|COLOR_PAIR(14));break; case 30:attrset(A_BOLD|COLOR_PAIR(12));break; case 31:attrset(A_BOLD|COLOR_PAIR(16));break; case 32:attrset(COLOR_PAIR(17));break; case 33:attrset(COLOR_PAIR(21));break; case 34:attrset(COLOR_PAIR(19));break; case 35:attrset(COLOR_PAIR(23));break; case 36:attrset(COLOR_PAIR(18));break; case 37:attrset(COLOR_PAIR(22));break; case 38:attrset(COLOR_PAIR(20));break; case 39:attrset(COLOR_PAIR(24));break; case 40:attrset(A_BOLD|COLOR_PAIR(17));break; case 41:attrset(A_BOLD|COLOR_PAIR(21));break; case 42:attrset(A_BOLD|COLOR_PAIR(19));break; case 43:attrset(A_BOLD|COLOR_PAIR(23));break; case 44:attrset(A_BOLD|COLOR_PAIR(18));break; case 45:attrset(A_BOLD|COLOR_PAIR(22));break; case 46:attrset(A_BOLD|COLOR_PAIR(20));break; case 47:attrset(A_BOLD|COLOR_PAIR(24));break; case 48:attrset(COLOR_PAIR(25));break; case 49:attrset(COLOR_PAIR(29));break; case 50:attrset(COLOR_PAIR(27));break; case 51:attrset(COLOR_PAIR(30));break; case 52:attrset(COLOR_PAIR(26));break; case 53:attrset(COLOR_PAIR(30));break; case 54:attrset(COLOR_PAIR(28));break; case 55:attrset(COLOR_PAIR(32));break; case 56:attrset(A_BOLD|COLOR_PAIR(25));break; case 57:attrset(A_BOLD|COLOR_PAIR(29));break; case 58:attrset(A_BOLD|COLOR_PAIR(27));break; case 59:attrset(A_BOLD|COLOR_PAIR(30));break; case 60:attrset(A_BOLD|COLOR_PAIR(26));break; case 61:attrset(A_BOLD|COLOR_PAIR(30));break; case 62:attrset(A_BOLD|COLOR_PAIR(28));break; case 63:attrset(A_BOLD|COLOR_PAIR(32));break; case 64:attrset(COLOR_PAIR(33));break; case 65:attrset(COLOR_PAIR(37));break; case 66:attrset(COLOR_PAIR(35));break; case 67:attrset(COLOR_PAIR(39));break; case 68:attrset(COLOR_PAIR(34));break; case 69:attrset(COLOR_PAIR(38));break; case 70:attrset(COLOR_PAIR(36));break; case 71:attrset(COLOR_PAIR(40));break; case 72:attrset(A_BOLD|COLOR_PAIR(33));break; case 73:attrset(A_BOLD|COLOR_PAIR(37));break; case 74:attrset(A_BOLD|COLOR_PAIR(35));break; case 75:attrset(A_BOLD|COLOR_PAIR(39));break; case 76:attrset(A_BOLD|COLOR_PAIR(34));break; case 77:attrset(A_BOLD|COLOR_PAIR(38));break; case 78:attrset(A_BOLD|COLOR_PAIR(36));break; case 79:attrset(A_BOLD|COLOR_PAIR(40));break; case 80:attrset(COLOR_PAIR(41));break; case 81:attrset(COLOR_PAIR(45));break; case 82:attrset(COLOR_PAIR(43));break; case 83:attrset(COLOR_PAIR(47));break; case 84:attrset(COLOR_PAIR(42));break; case 85:attrset(COLOR_PAIR(46));break; case 86:attrset(COLOR_PAIR(44));break; case 87:attrset(COLOR_PAIR(48));break; case 88:attrset(A_BOLD|COLOR_PAIR(41));break; case 89:attrset(A_BOLD|COLOR_PAIR(45));break; case 90:attrset(A_BOLD|COLOR_PAIR(43));break; case 91:attrset(A_BOLD|COLOR_PAIR(47));break; case 92:attrset(A_BOLD|COLOR_PAIR(42));break; case 93:attrset(A_BOLD|COLOR_PAIR(46));break; case 94:attrset(A_BOLD|COLOR_PAIR(44));break; case 95:attrset(A_BOLD|COLOR_PAIR(48));break; case 96:attrset(COLOR_PAIR(49));break; case 97:attrset(COLOR_PAIR(53));break; case 98:attrset(COLOR_PAIR(51));break; case 99:attrset(COLOR_PAIR(55));break; case 100:attrset(COLOR_PAIR(50));break; case 101:attrset(COLOR_PAIR(54));break; case 102:attrset(COLOR_PAIR(52));break; case 103:attrset(COLOR_PAIR(56));break; case 104:attrset(A_BOLD|COLOR_PAIR(49));break; case 105:attrset(A_BOLD|COLOR_PAIR(53));break; case 106:attrset(A_BOLD|COLOR_PAIR(51));break; case 107:attrset(A_BOLD|COLOR_PAIR(55));break; case 108:attrset(A_BOLD|COLOR_PAIR(50));break; case 109:attrset(A_BOLD|COLOR_PAIR(54));break; case 110:attrset(A_BOLD|COLOR_PAIR(52));break; case 111:attrset(A_BOLD|COLOR_PAIR(56));break; case 112:attrset(COLOR_PAIR(57));break; case 113:attrset(COLOR_PAIR(61));break; case 114:attrset(COLOR_PAIR(59));break; case 115:attrset(COLOR_PAIR(63));break; case 116:attrset(COLOR_PAIR(58));break; case 117:attrset(COLOR_PAIR(62));break; case 118:attrset(COLOR_PAIR(60));break; case 119:attrset(COLOR_PAIR(64));break; case 120:attrset(A_BOLD|COLOR_PAIR(57));break; case 121:attrset(A_BOLD|COLOR_PAIR(61));break; case 122:attrset(A_BOLD|COLOR_PAIR(59));break; case 123:attrset(A_BOLD|COLOR_PAIR(63));break; case 124:attrset(A_BOLD|COLOR_PAIR(58));break; case 125:attrset(A_BOLD|COLOR_PAIR(62));break; case 126:attrset(A_BOLD|COLOR_PAIR(60));break; case 127:attrset(A_BOLD|COLOR_PAIR(64));break; default:attrset(COLOR_PAIR(8)); } }
void get_color(void) { chtype bold = (rand() % 2) ? A_BOLD : A_NORMAL; attrset(COLOR_PAIR(rand() % 8) | bold); }
void drawBoard() { int i, h; initscr(); start_color(); init_pair(1,COLOR_RED,COLOR_GREEN); int a = rand()%2; if(a == 1){ init_pair(2,COLOR_YELLOW,COLOR_BLACK); } else if (a == 0){ init_pair(2,COLOR_GREEN,COLOR_BLACK); } init_pair(3,COLOR_WHITE,COLOR_BLACK); for(i=0;i<=17;i++) { attrset(COLOR_PAIR(1)); mvaddch(i, 15, '|'); mvaddch(i,31,'|'); } attrset(COLOR_PAIR(2)); mvaddstr(0,0," (;;);;)"); mvaddstr(1,0," (;;);;;);;)"); mvaddstr(2,0," (;;(;;;)"); attrset(COLOR_PAIR(3)); mvaddstr(3,0," |i!|"); mvaddstr(4,0," |ii|"); attrset(COLOR_PAIR(2)); mvaddstr(6,0," (;;);;)"); mvaddstr(7,0," (;;);;;);;)"); mvaddstr(8,0," (;;(;;;)"); attrset(COLOR_PAIR(3)); mvaddstr(9,0," |i!|"); mvaddstr(10,0," |ii|"); attrset(COLOR_PAIR(2)); mvaddstr(12,0," (;;);;)"); mvaddstr(13,0," (;;);;;);;)"); mvaddstr(14,0," (;;(;;;)"); attrset(COLOR_PAIR(3)); mvaddstr(15,0," |i!|"); mvaddstr(16,0," |ii|"); attrset(COLOR_PAIR(2)); mvaddstr(0,32," (;;);;)"); mvaddstr(1,32," (;;);;;);;)"); mvaddstr(2,32," (;;(;;;)"); attrset(COLOR_PAIR(3)); mvaddstr(3,32," |i!|"); mvaddstr(4,32," |ii|"); attrset(COLOR_PAIR(2)); mvaddstr(6,32," (;;);;)"); mvaddstr(7,32," (;;);;;);;)"); mvaddstr(8,32," (;;(;;;)"); attrset(COLOR_PAIR(3)); mvaddstr(9,32," |i!|"); mvaddstr(10,32," |ii|"); attrset(COLOR_PAIR(2)); mvaddstr(12,32," (;;);;)"); mvaddstr(13,32," (;;);;;);;)"); mvaddstr(14,32," (;;(;;;)"); attrset(COLOR_PAIR(3)); mvaddstr(15,32," |i!|"); mvaddstr(16,32," |ii|"); init_pair(40,COLOR_WHITE,COLOR_BLACK); init_pair(41,COLOR_YELLOW,COLOR_BLACK); init_pair(42,COLOR_RED,COLOR_BLACK); init_pair(43,COLOR_GREEN,COLOR_BLACK); init_pair(44,COLOR_CYAN,COLOR_BLACK); attrset(COLOR_PAIR(44)); mvprintw(0,55," _ "); mvprintw(1,55,"|!| is treasure (Increase your point)."); mvprintw(2,55,"|_|"); attrset(COLOR_PAIR(42)); mvprintw(4,55," O "); mvprintw(5,55,"/_\\ is enemy car (If you crash it, game will be over)."); mvprintw(6,55,"\\O/"); attrset(COLOR_PAIR(41)); mvprintw(8,55,"|b|"); mvprintw(9,55,"|e| is beer (If you get it, you will be drunken state)."); mvprintw(10,55,"|r|"); attrset(COLOR_PAIR(40)); mvprintw(12,55," "); mvprintw(13,55,"O~* is bomb (Decrease your point)."); mvprintw(14,55," "); attrset(COLOR_PAIR(43)); mvprintw(15,55,"/\\ "); mvprintw(16,55,"/\\ is Nitrous (Increase jump point)."); mvprintw(17,55,"/\\ "); refresh(); }
static void curses_draw(void) { if (NULL == get_current_node()) { first_node(); first_intf(); } row = 0; move(0,0); getmaxyx(stdscr, rows, cols); if (cols < 80) { clear(); putl("Screen must be at least 80 columns wide"); refresh(); return; } if (c_use_colors) attrset(COLOR_PAIR(LAYOUT_STATUSBAR) | layout[LAYOUT_STATUSBAR].attr); else attrset(A_REVERSE); if (get_current_node() && get_current_intf()) { putl(" interface: %s at %s", get_current_intf()->i_name, get_current_node()->n_name); } move(row, COLS - strlen(PACKAGE_STRING) - 1); putl("%s", PACKAGE_STRING); move(row, 0); if (c_use_colors) attrset(COLOR_PAIR(LAYOUT_DEFAULT) | layout[LAYOUT_DEFAULT].attr); else attroff(A_REVERSE); print_content(); if (quit_mode) print_quit(); else if (print_help) draw_help(); for (; row < rows-2;) { move(++row, 0); putl(""); } row = rows-1; move(row, 0); if (c_use_colors) attrset(COLOR_PAIR(LAYOUT_STATUSBAR) | layout[LAYOUT_STATUSBAR].attr); else attrset(A_REVERSE); putl(" ^ prev interface, v next interface, <- prev node, -> next node, ? help"); attrset(0); refresh(); }
static void draw_node(node_t *node, void *arg) { int i, *cnt = (int *) arg; if (cnt) { if (*cnt) { int n; NEXT_ROW; for (n = 1; n < cols; n += 2) mvaddch(row, n, ACS_HLINE); move(row, 28); addch(ACS_VLINE); move(row, 54); addch(ACS_VLINE); } (*cnt)++; } attrset(A_BOLD); NEXT_ROW; if (c_nosource) putl("%s", node->n_name); else putl("%s (%s)", node->n_name, node->n_from ? node->n_from : "local"); move(row, 30); putl(" Rate # %% Rate # %%"); attroff(A_BOLD); move(row, 28); addch(ACS_VLINE); move(row, 54); addch(ACS_VLINE); if (c_use_colors) attrset(COLOR_PAIR(LAYOUT_LIST) | layout[LAYOUT_LIST].attr); for (i = 0; i < node->n_nitems; i++) draw_item(node, &node->n_items[i]); if (!c_nototal) { int rx_maj_prec, tx_maj_prec, rx_min_prec, tx_min_prec; double rx_maj, tx_maj, rx_min, tx_min; char *rx_maj_u, *tx_maj_u, *rx_min_u, *tx_min_u; rx_maj = cancel_down(node->n_rx_maj_total, U_BYTES, &rx_maj_u, &rx_maj_prec); tx_maj = cancel_down(node->n_tx_maj_total, U_BYTES, &tx_maj_u, &tx_maj_prec); rx_min = cancel_down(node->n_rx_min_total, U_NUMBER, &rx_min_u, &rx_min_prec); tx_min = cancel_down(node->n_tx_min_total, U_NUMBER, &tx_min_u, &tx_min_prec); NEXT_ROW; putl(" %-26s %8.*f%s %8.*f%s %8.*f%s %8.*f%s ", "Total", rx_maj_prec, rx_maj, rx_maj_u, rx_min_prec, rx_min, rx_min_u, tx_maj_prec, tx_maj, tx_maj_u, tx_min_prec, tx_min, tx_min_u); move(row, 28); addch(ACS_VLINE); move(row, 54); addch(ACS_VLINE); } if (c_use_colors) attrset(COLOR_PAIR(LAYOUT_DEFAULT) | layout[LAYOUT_DEFAULT].attr); }
int WDL_CursesEditor::onChar(int c) { if (m_state == -3 || m_state == -4) { switch (c) { case '\r': case '\n': m_state=0; runSearch(); break; case 27: m_state=0; draw(); draw_message("Find cancelled."); setCursor(); break; case KEY_BACKSPACE: if (s_search_string[0]) s_search_string[strlen(s_search_string)-1]=0; m_state=-4; break; default: if (VALIDATE_TEXT_CHAR(c)) { int l=m_state == -3 ? 0 : strlen(s_search_string); m_state = -4; if (l < (int)sizeof(s_search_string)-1) { s_search_string[l]=c; s_search_string[l+1]=0; } } break; } if (m_state) { attrset(m_color_message); bkgdset(m_color_message); mvaddstr(LINES-1,29,s_search_string); clrtoeol(); attrset(0); bkgdset(0); } return 0; } if (c==KEY_DOWN || c==KEY_UP || c==KEY_PPAGE||c==KEY_NPAGE || c==KEY_RIGHT||c==KEY_LEFT||c==KEY_HOME||c==KEY_END) { if (GetAsyncKeyState(VK_SHIFT)&0x8000) { if (!m_selecting) { m_select_x2=m_select_x1=m_curs_x; m_select_y2=m_select_y1=m_curs_y; m_selecting=1; } } else if (m_selecting) { m_selecting=0; draw(); } } switch(c) { case 407: case 'Z'-'A'+1: if (!(GetAsyncKeyState(VK_SHIFT)&0x8000)) { if (m_undoStack_pos > 0) { m_undoStack_pos--; loadUndoState(m_undoStack.Get(m_undoStack_pos)); draw(); char buf[512]; snprintf(buf,sizeof(buf),"Undid action -- %d items in undo buffer",m_undoStack_pos); draw_message(buf); setCursor(); } else draw_message("Can't Undo"); break; } // fall through case 'Y'-'A'+1: if (m_undoStack_pos < m_undoStack.GetSize()-1) { m_undoStack_pos++; loadUndoState(m_undoStack.Get(m_undoStack_pos)); draw(); char buf[512]; snprintf(buf,sizeof(buf),"Redid action -- %d items in redo buffer",m_undoStack.GetSize()-m_undoStack_pos-1); draw_message(buf); setCursor(); } else draw_message("Can't Redo"); break; case KEY_IC: if (!(GetAsyncKeyState(VK_SHIFT)&0x8000)) { s_overwrite=!s_overwrite; setCursor(); break; } // fqll through case 'V'-'A'+1: { // generate a m_clipboard using win32 clipboard data WDL_PtrList<const char> lines; WDL_String buf; #ifdef WDL_IS_FAKE_CURSES if (CURSES_INSTANCE) { OpenClipboard(CURSES_INSTANCE->m_hwnd); HANDLE h=GetClipboardData(CF_TEXT); if (h) { char *t=(char *)GlobalLock(h); int s=GlobalSize(h); buf.Set(t,s); GlobalUnlock(t); } CloseClipboard(); } else #endif { buf.Set(s_fake_clipboard.Get()); } if (buf.Get() && buf.Get()[0]) { char *src=buf.Get(); while (*src) { char *seek=src; while (*seek && *seek != '\r' && *seek != '\n') seek++; char hadclr=*seek; if (*seek) *seek++=0; lines.Add(src); if (hadclr == '\r' && *seek == '\n') seek++; if (hadclr && !*seek) { lines.Add(""); } src=seek; } } if (lines.GetSize()) { removeSelect(); // insert lines at m_curs_y,m_curs_x if (m_curs_y >= m_text.GetSize()) m_curs_y=m_text.GetSize()-1; if (m_curs_y < 0) m_curs_y=0; preSaveUndoState(); WDL_FastString poststr; int x; int indent_to_pos = -1; for (x = 0; x < lines.GetSize(); x ++) { WDL_FastString *str=m_text.Get(m_curs_y); const char *tstr=lines.Get(x); if (!tstr) tstr=""; if (!x) { if (str) { if (m_curs_x < 0) m_curs_x=0; int tmp=str->GetLength(); if (m_curs_x > tmp) m_curs_x=tmp; poststr.Set(str->Get()+m_curs_x); str->SetLen(m_curs_x); const char *p = str->Get(); while (*p == ' ' || *p == '\t') p++; if (!*p && p > str->Get()) { if (lines.GetSize()>1) { while (*tstr == ' ' || *tstr == '\t') tstr++; } indent_to_pos = m_curs_x; } str->Append(tstr); } else { m_text.Insert(m_curs_y,(str=new WDL_FastString(tstr))); } if (lines.GetSize() > 1) { m_curs_y++; } else { m_curs_x = str->GetLength(); str->Append(poststr.Get()); } } else if (x == lines.GetSize()-1) { WDL_FastString *s=newIndentedFastString(tstr,indent_to_pos); m_curs_x = s->GetLength(); s->Append(poststr.Get()); m_text.Insert(m_curs_y,s); } else { m_text.Insert(m_curs_y,newIndentedFastString(tstr,indent_to_pos)); m_curs_y++; } } draw(); draw_message("Pasted"); saveUndoState(); setCursor(); } else { draw_message("Clipboard empty"); setCursor(); } } break; case KEY_DC: if (!(GetAsyncKeyState(VK_SHIFT)&0x8000)) { WDL_FastString *s; if (m_selecting) { preSaveUndoState(); removeSelect(); draw(); saveUndoState(); setCursor(); } else if ((s=m_text.Get(m_curs_y))) { if (m_curs_x < s->GetLength()) { preSaveUndoState(); bool hadCom = LineCanAffectOtherLines(s->Get(),m_curs_x,1); s->DeleteSub(m_curs_x,1); if (!hadCom) hadCom = LineCanAffectOtherLines(s->Get(),-1,-1); draw(hadCom ? -1 : m_curs_y); saveUndoState(); setCursor(); } else // append next line to us { if (m_curs_y < m_text.GetSize()-1) { preSaveUndoState(); WDL_FastString *nl=m_text.Get(m_curs_y+1); if (nl) { s->Append(nl->Get()); } m_text.Delete(m_curs_y+1,true); draw(); saveUndoState(); setCursor(); } } } break; } case 'C'-'A'+1: case 'X'-'A'+1: if (m_selecting) { if (c!= 'C'-'A'+1) m_selecting=0; int miny,maxy,minx,maxx; int x; getselectregion(minx,miny,maxx,maxy); const char *status=""; char statusbuf[512]; if (minx != maxx|| miny != maxy) { int bytescopied=0; s_fake_clipboard.Set(""); int lht=0,fht=0; if (c != 'C'-'A'+1) preSaveUndoState(); for (x = miny; x <= maxy; x ++) { WDL_FastString *s=m_text.Get(x); if (s) { const char *str=s->Get(); int sx,ex; if (x == miny) sx=max(minx,0); else sx=0; int tmp=s->GetLength(); if (sx > tmp) sx=tmp; if (x == maxy) ex=min(maxx,tmp); else ex=tmp; bytescopied += ex-sx + (x!=maxy); if (s_fake_clipboard.Get() && s_fake_clipboard.Get()[0]) s_fake_clipboard.Append("\r\n"); s_fake_clipboard.Append(ex-sx?str+sx:"",ex-sx); if (c != 'C'-'A'+1) { if (sx == 0 && ex == tmp) // remove entire line { m_text.Delete(x,true); if (x==miny) miny--; x--; maxy--; } else { if (x==miny) fht=1; if (x == maxy) lht=1; s->DeleteSub(sx,ex-sx); } } } } if (fht && lht && miny+1 == maxy) { m_text.Get(miny)->Append(m_text.Get(maxy)->Get()); m_text.Delete(maxy,true); } if (c != 'C'-'A'+1) { m_curs_y=miny; if (m_curs_y < 0) m_curs_y=0; m_curs_x=minx; saveUndoState(); snprintf(statusbuf,sizeof(statusbuf),"Cut %d bytes",bytescopied); } else snprintf(statusbuf,sizeof(statusbuf),"Copied %d bytes",bytescopied); #ifdef WDL_IS_FAKE_CURSES if (CURSES_INSTANCE) { int l=s_fake_clipboard.GetLength()+1; HANDLE h=GlobalAlloc(GMEM_MOVEABLE,l); void *t=GlobalLock(h); memcpy(t,s_fake_clipboard.Get(),l); GlobalUnlock(h); OpenClipboard(CURSES_INSTANCE->m_hwnd); EmptyClipboard(); SetClipboardData(CF_TEXT,h); CloseClipboard(); } #endif status=statusbuf; } else status="No selection"; draw(); draw_message(status); setCursor(); } break; case 'A'-'A'+1: m_selecting=1; m_select_x1=0; m_select_y1=0; m_select_y2=m_text.GetSize()-1; m_select_x2=0; if (m_text.Get(m_select_y2)) m_select_x2=m_text.Get(m_select_y2)->GetLength(); draw(); setCursor(); break; case 27: if (m_selecting) { m_selecting=0; draw(); setCursor(); break; } return 0; case KEY_F3: case 'G'-'A'+1: if (s_search_string[0]) { runSearch(); return 0; } case 'F'-'A'+1: draw_message(""); attrset(m_color_message); bkgdset(m_color_message); mvaddstr(LINES-1,0,"Find string (ESC to cancel): "); addstr(s_search_string); clrtoeol(); attrset(0); bkgdset(0); m_state=-3; // find, initial (m_state=4 when we've typed something) return 0; case KEY_DOWN: { if (GetAsyncKeyState(VK_CONTROL)&0x8000) { if (m_offs_y < m_text.GetSize() - 4) { m_offs_y++; if (m_curs_y < m_offs_y) m_curs_y = m_offs_y; draw(); } } else { m_curs_y++; if(m_curs_y>=m_text.GetSize()) m_curs_y=m_text.GetSize()-1; if(m_curs_y < 0) m_curs_y=0; } if (m_selecting) { setCursor(1); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); } setCursor(1); } break; case KEY_UP: { if (GetAsyncKeyState(VK_CONTROL)&0x8000) { if (m_offs_y>0) { m_offs_y--; if (m_curs_y>m_offs_y + getVisibleLines() - 1) m_curs_y = m_offs_y + getVisibleLines() - 1; if (m_curs_y < 0) m_curs_y=0; draw(); } } else { if(m_curs_y>0) m_curs_y--; } if (m_selecting) { setCursor(1); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); } setCursor(1); } break; case KEY_PPAGE: { if (m_curs_y > m_offs_y) { m_curs_y=m_offs_y; if (m_curs_y < 0) m_curs_y=0; } else { m_curs_y -= getVisibleLines(); if (m_curs_y < 0) m_curs_y=0; m_offs_y=m_curs_y; } if (m_selecting) { setCursor(1); m_select_x2=m_curs_x; m_select_y2=m_curs_y; } draw(); setCursor(1); } break; case KEY_NPAGE: { if (m_curs_y >= m_offs_y+getVisibleLines() - 1) m_offs_y=m_curs_y+1; m_curs_y = m_offs_y+getVisibleLines() - 1; if (m_curs_y >= m_text.GetSize()) m_curs_y=m_text.GetSize()-1; if (m_curs_y < 0) m_curs_y=0; if (m_selecting) { setCursor(1); m_select_x2=m_curs_x; m_select_y2=m_curs_y; } draw(); setCursor(1); } break; case KEY_RIGHT: { if (1) // wrap across lines { WDL_FastString *s = m_text.Get(m_curs_y); if (s && m_curs_x >= s->GetLength() && m_curs_y < m_text.GetSize()) { m_curs_y++; m_curs_x = -1; } } if(m_curs_x<0) { m_curs_x=0; } else { if (GetAsyncKeyState(VK_CONTROL)&0x8000) { WDL_FastString *s = m_text.Get(m_curs_y); if (!s||m_curs_x >= s->GetLength()) break; int lastType = categorizeCharForWordNess(s->Get()[m_curs_x++]); while (m_curs_x < s->GetLength()) { int thisType = categorizeCharForWordNess(s->Get()[m_curs_x]); if (thisType != lastType && thisType != 0) break; lastType=thisType; m_curs_x++; } } else { m_curs_x++; } } if (m_selecting) { setCursor(); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); } setCursor(); } break; case KEY_LEFT: { bool doMove=true; if (1) // wrap across lines { WDL_FastString *s = m_text.Get(m_curs_y); if (s && m_curs_y>0 && m_curs_x == 0) { s = m_text.Get(--m_curs_y); if (s) { m_curs_x = s->GetLength(); doMove=false; } } } if(m_curs_x>0 && doMove) { if (GetAsyncKeyState(VK_CONTROL)&0x8000) { WDL_FastString *s = m_text.Get(m_curs_y); if (!s) break; if (m_curs_x > s->GetLength()) m_curs_x = s->GetLength(); m_curs_x--; int lastType = categorizeCharForWordNess(s->Get()[m_curs_x--]); while (m_curs_x >= 0) { int thisType = categorizeCharForWordNess(s->Get()[m_curs_x]); if (thisType != lastType && lastType != 0) break; lastType=thisType; m_curs_x--; } m_curs_x++; } else { m_curs_x--; } } if (m_selecting) { setCursor(); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); } setCursor(); } break; case KEY_HOME: { m_curs_x=0; if (m_selecting) { setCursor(); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); } setCursor(); } break; case KEY_END: { if (m_text.Get(m_curs_y)) m_curs_x=m_text.Get(m_curs_y)->GetLength(); if (m_selecting) { setCursor(); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); } setCursor(); } break; case KEY_BACKSPACE: // backspace, baby if (m_selecting) { preSaveUndoState(); removeSelect(); draw(); saveUndoState(); setCursor(); } else if (m_curs_x > 0) { WDL_FastString *tl=m_text.Get(m_curs_y); if (tl) { preSaveUndoState(); bool hadCom = LineCanAffectOtherLines(tl->Get(), m_curs_x-1,1); tl->DeleteSub(--m_curs_x,1); if (!hadCom) hadCom = LineCanAffectOtherLines(tl->Get(),-1,-1); draw(hadCom?-1:m_curs_y); saveUndoState(); setCursor(); } } else // append current line to previous line { WDL_FastString *fl=m_text.Get(m_curs_y-1), *tl=m_text.Get(m_curs_y); if (!tl) { m_curs_y--; if (fl) m_curs_x=fl->GetLength(); draw(); saveUndoState(); setCursor(); } else if (fl) { preSaveUndoState(); m_curs_x=fl->GetLength(); fl->Append(tl->Get()); m_text.Delete(m_curs_y--,true); draw(); saveUndoState(); setCursor(); } } break; case 'L'-'A'+1: draw(); setCursor(); break; case 13: //KEY_ENTER: //insert newline preSaveUndoState(); if (m_selecting) { removeSelect(); draw(); setCursor(); } if (m_curs_y >= m_text.GetSize()) { m_curs_y=m_text.GetSize(); m_text.Add(new WDL_FastString); } if (s_overwrite) { WDL_FastString *s = m_text.Get(m_curs_y); int plen=0; const char *pb=NULL; if (s) { pb = s->Get(); while (plen < m_curs_x && (pb[plen]== ' ' || pb[plen] == '\t')) plen++; } if (++m_curs_y >= m_text.GetSize()) { m_curs_y = m_text.GetSize(); WDL_FastString *ns=new WDL_FastString; if (plen>0) ns->Set(pb,plen); m_text.Insert(m_curs_y,ns); } s = m_text.Get(m_curs_y); if (s && plen > s->GetLength()) plen=s->GetLength(); m_curs_x=plen; } else { WDL_FastString *s = m_text.Get(m_curs_y); if (s) { if (m_curs_x > s->GetLength()) m_curs_x = s->GetLength(); WDL_FastString *nl = new WDL_FastString(); int plen=0; const char *pb = s->Get(); while (plen < m_curs_x && (pb[plen]== ' ' || pb[plen] == '\t')) plen++; if (plen>0) nl->Set(pb,plen); nl->Append(pb+m_curs_x); m_text.Insert(++m_curs_y,nl); s->SetLen(m_curs_x); m_curs_x=plen; } } m_offs_x=0; draw(); saveUndoState(); setCursor(); break; case '\t': if (m_selecting) { preSaveUndoState(); bool isRev = !!(GetAsyncKeyState(VK_SHIFT)&0x8000); indentSelect(isRev?-m_indent_size:m_indent_size); // indent selection: draw(); setCursor(); saveUndoState(); break; } default: //insert char if(VALIDATE_TEXT_CHAR(c)) { preSaveUndoState(); if (m_selecting) { removeSelect(); draw(); setCursor(); } if (!m_text.Get(m_curs_y)) m_text.Insert(m_curs_y,new WDL_FastString); WDL_FastString *ss; if ((ss=m_text.Get(m_curs_y))) { char str[64]; int slen ; if (c == '\t') { slen = min(m_indent_size,64); if (slen<1) slen=1; int x; for(x=0;x<slen;x++) str[x]=' '; } else { str[0]=c; slen = 1; } bool hadCom = LineCanAffectOtherLines(ss->Get(),-1,-1); if (s_overwrite) { if (!hadCom) hadCom = LineCanAffectOtherLines(ss->Get(),m_curs_x,slen); ss->DeleteSub(m_curs_x,slen); } ss->Insert(str,m_curs_x,slen); if (!hadCom) hadCom = LineCanAffectOtherLines(ss->Get(),m_curs_x,slen); m_curs_x += slen; draw(hadCom ? -1 : m_curs_y); } saveUndoState(); setCursor(); } break; } return 0; }
void setcolor (int n,int m) { if (m==1) attr_set (A_BOLD,0,0); else attr_set (A_NORMAL,0,0); color_set (n,0); if ((nocolor==1) && ((n==2) || (n==3) || (n==5) || (n==7) || (n==10) || (n==11) || (n==12) || (n==13))) attrset (A_REVERSE); }
static void draw_item_list_entry(item_t *intf, node_t *node) { int rxprec, txprec, rxpprec, txpprec; stat_attr_t *bytes, *packets; double rx, tx, rxp, txp; char *rx_u, *tx_u, *rxp_u, *txp_u; char pad[23]; bytes = lookup_attr(intf, intf->i_major_attr); packets = lookup_attr(intf, intf->i_minor_attr); if (bytes == NULL || packets == NULL) return; rx = cancel_down(attr_get_rx_rate(bytes), bytes->a_unit, &rx_u, &rxprec); tx = cancel_down(attr_get_tx_rate(bytes), bytes->a_unit, &tx_u, &txprec); rxp = cancel_down(attr_get_rx_rate(packets), packets->a_unit, &rxp_u, &rxpprec); txp = cancel_down(attr_get_tx_rate(packets), packets->a_unit, &txp_u, &txpprec); memset(pad, 0, sizeof(pad)); memset(pad, ' ', intf->i_level < 15 ? intf->i_level : 15); strncat(pad, intf->i_name, sizeof(pad) - strlen(pad) - 1); if (intf->i_desc) { strncat(pad, " (", sizeof(pad) - strlen(pad) - 1); strncat(pad, intf->i_desc, sizeof(pad) - strlen(pad) - 1); strncat(pad, ")", sizeof(pad) - strlen(pad) - 1); } NEXT_ROW; if (intf->i_index == node->n_selected && node == get_current_node()) { if (c_use_colors) attrset(COLOR_PAIR(LAYOUT_SELECTED) | layout[LAYOUT_SELECTED].attr); else attron(A_REVERSE); } printw(" %-3d%s", intf->i_index, (intf->i_flags & ITEM_FLAG_FOLDED) ? "+" : " "); if (intf->i_index == node->n_selected && node == get_current_node()) { if (c_use_colors) attrset(COLOR_PAIR(LAYOUT_LIST) | layout[LAYOUT_LIST].attr); else attroff(A_REVERSE); } putl("%-22s %8.*f%s %8.*f%s %2d%% %8.*f%s %8.*f%s %2d%%", pad, rxprec, rx, rx_u, rxpprec, rxp, rxp_u, intf->i_rx_usage, txprec, tx, tx_u, txpprec, txp, txp_u, intf->i_tx_usage); if (intf->i_rx_usage == -1) { move(row, 51); addstr(" "); } if (intf->i_tx_usage == -1) { move(row, 77); addstr(" "); } move(row, 28); addch(ACS_VLINE); move(row, 54); addch(ACS_VLINE); }
int main() { int a[200][200]; x1=0; y1=0; initscr(); start_color(); init_pair(2,COLOR_GREEN,COLOR_BLACK); init_pair(3,6,COLOR_BLACK); init_pair(4,COLOR_RED,COLOR_BLACK); attrset(A_BOLD); noecho(); c=0; x=0; y=0; clear(); refresh(); color_set(2,0); move(0,0); addstr("+"); refresh(); while(c!='*') { x1=0; y1=0; while(y1<COLS-1) { while(x1<LINES-1) { if(a[x1][y1]==1) { move(x1,y1); if((x1==x)&&(y1==y)) { color_set(4,0); addstr("+"); refresh(); } else { color_set(3,0); addstr("o"); refresh(); } } x1+=1; } x1=0; y1+=1; } c=getchar(); if(c=='c') { x1=0; y1=0; while(y1<COLS) { while(x1<LINES) { a[x1][y1]=0; x1+=1; } x1=0; y1+=1; } clear(); color_set(2,0); move(x,y); addstr("+"); refresh(); } if(c=='i') { x1=0; y1=0; while(y1<COLS-1) { while(x1<LINES-1) { if(a[x1][y1]==1) { a[x1][y1]=0; } else { a[x1][y1]=1; } x1+=1; } x1=0; y1+=1; } x1=0; y1=0; while(y1<COLS-1) { while(x1<LINES-1) { if(a[x1][y1]==1) { move(x1,y1); if((x1==x)&&(y1==y)) { color_set(4,0); addstr("+"); refresh(); } else { color_set(3,0); addstr("o"); refresh(); } } else { move(x1,y1); if((x1==x)&&(y1==y)) { color_set(2,0); addstr("+"); refresh(); } else { color_set(3,0); addstr(" "); refresh(); } } x1+=1; } y1+=1; x1=0; } } if(c=='o') { x1=0; y1=0; while(y1<COLS) { while(x1<LINES) { a[x1][y1]=1; x1+=1; } x1=0; y1+=1; } x1=0; y1=0; while(y1<COLS-1) { while(x1<LINES-1) { if(a[x1][y1]==1) { move(x1,y1); if((x1==x)&&(y1==y)) { color_set(4,0); addstr("+"); refresh(); } else { color_set(3,0); addstr("o"); refresh(); } } x1+=1; } x1=0; y1+=1; } } if(c==13) { if(a[x][y]==0) { a[x][y]=1; continue; } if(a[x][y]==1) { a[x][y]=0; color_set(2,0); move(x,y); addstr("+"); } } if(c==68) { if(y>0) { yy=(y-1); color_set(2,0); move(x,y); addstr(" "); move(x,yy); addstr("+"); refresh(); y=yy; } } if(c==67) { if(y<COLS-1) { yy=(y+1); color_set(2,0); move(x,y); addstr(" "); move(x,yy); addstr("+"); refresh(); y=yy; } } if(c==66) { if(x<LINES-1) { xx=(x+1); color_set(2,0); move(x,y); addstr(" "); move(xx,y); addstr("+"); refresh(); x=xx; } } if(c==65) { if(x>0) { xx=(x-1); color_set(2,0); move(x,y); addstr(" "); move(xx,y); addstr("+"); refresh(); x=xx; } } } endwin(); }
void tty_setcolor (int color) { attrset (COLOR_PAIR (color) | color_get_attr (color)); }
int main(int argc, char* argv[]){ /* Initialize pseudo random number generator */ srand(time(NULL)); /* Read command line arguments */ struct basic_options op; struct multi_options mop; if (get_options(argc, argv, &op, &mop) == 1) return 1; /* Setup signal handlers */ struct sigaction newhandler; /* new settings */ sigset_t blocked; /* set of blocked sigs */ newhandler.sa_flags = SA_RESTART; /* options */ sigemptyset(&blocked); /* clear all bits */ newhandler.sa_mask = blocked; /* store blockmask */ newhandler.sa_handler = on_timer; /* handler function */ if ( sigaction(SIGALRM, &newhandler, NULL) == -1 ) perror("sigaction"); /* prepare the terminal for the animation */ setlocale(LC_ALL, ""); initscr(); /* initialize the library and screen */ cbreak(); /* put terminal into non-blocking input mode */ noecho(); /* turn off echo */ start_color(); clear(); /* clear the screen */ curs_set(0); /* hide the cursor */ use_default_colors(); init_pair(0, COLOR_WHITE, COLOR_BLACK); init_pair(1, COLOR_WHITE, COLOR_BLACK); init_pair(2, COLOR_BLACK, COLOR_BLACK); init_pair(3, COLOR_RED, COLOR_BLACK); init_pair(4, COLOR_GREEN, COLOR_BLACK); init_pair(5, COLOR_BLUE, COLOR_BLACK); init_pair(6, COLOR_YELLOW, COLOR_BLACK); init_pair(7, COLOR_MAGENTA, COLOR_BLACK); init_pair(8, COLOR_CYAN, COLOR_BLACK); color_set(0, NULL); assume_default_colors(COLOR_WHITE, COLOR_BLACK); clear(); struct state st; struct ui ui; /* Initialize the parameters of the program */ attrset(A_BOLD | COLOR_PAIR(2)); mvaddstr(0,0,"Map is generated. Please wait."); refresh(); state_init(&st, &op, &mop); ui_init(&st, &ui); clear(); /* non-blocking input */ int fd_flags = fcntl(0, F_GETFL); fcntl(0, F_SETFL, (fd_flags|O_NONBLOCK)); /* Start the real time interval timer with delay interval size */ struct itimerval it; it.it_value.tv_sec = 0; it.it_value.tv_usec = 10000; it.it_interval.tv_sec = 0; it.it_interval.tv_usec = 10000; setitimer(ITIMER_REAL, &it, NULL); refresh(); input_ready = 0; time_to_redraw = 1; if (!mop.multiplayer_flag) { /* Run the game */ run(&st, &ui); } else { if (mop.server_flag) run_server(&st, mop.clients_num, mop.val_server_port); else run_client(&st, &ui, mop.val_server_addr, mop.val_server_port, mop.val_client_port); } /* Restore the teminal state */ echo(); curs_set(1); clear(); endwin(); if (!mop.multiplayer_flag || mop.server_flag) printf ("Random seed was %i\n", st.map_seed); free(mop.val_server_addr); free(mop.val_server_port); free(mop.val_client_port); return 0; }
int window_online_print() { int y,x; char buf[250]; curseson(); cbreak(); noecho(); nonl(); keypad(stdscr,TRUE); getmaxyx(stdscr,y,x); attrset(A_NORMAL); attrset(COLOR_PAIR(14)); snprintf(buf, x, "whoIam : %s %140.140s", cfg.identity, " "); mvaddnstr(y+gui_window_online.y0, 0, buf, x-1); if (josua_online_status==EXOSIP_NOTIFY_UNKNOWN) snprintf(buf, x, "IM status: %s %140.140s", "unknown", " "); else if (josua_online_status==EXOSIP_NOTIFY_PENDING) snprintf(buf, x, "IM status: %s %140.140s", "pending", " "); else if (josua_online_status==EXOSIP_NOTIFY_ONLINE) snprintf(buf, x, "IM status: %s %140.140s", "Online", " "); else if (josua_online_status==EXOSIP_NOTIFY_BUSY) snprintf(buf, x, "IM status: %s %140.140s", "Busy", " "); else if (josua_online_status==EXOSIP_NOTIFY_BERIGHTBACK) snprintf(buf, x, "IM status: %s %140.140s", "Be Right Back", " "); else if (josua_online_status==EXOSIP_NOTIFY_AWAY) snprintf(buf, x, "IM status: %s %140.140s", "Away", " "); else if (josua_online_status==EXOSIP_NOTIFY_ONTHEPHONE) snprintf(buf, x, "IM status: %s %140.140s", "On The Phone", " "); else if (josua_online_status==EXOSIP_NOTIFY_OUTTOLUNCH) snprintf(buf, x, "IM status: %s %140.140s", "Out To Lunch", " "); else if (josua_online_status==EXOSIP_NOTIFY_CLOSED) snprintf(buf, x, "IM status: %s %140.140s", "Closed", " "); else snprintf(buf, x, "IM status: ?? %140.140s" , " "); mvaddnstr(y+gui_window_online.y0+1, 0, buf, x-1); if (josua_registration_status==-1) { snprintf(buf, x, "registred: --Not registred-- %140.140s", " "); mvaddnstr(y+gui_window_online.y0+2, 0, buf, x-1); } else if (199<josua_registration_status && josua_registration_status<300) { snprintf(buf, x, "registred: [%i %s] %s %140.140s", josua_registration_status, josua_registration_reason_phrase, josua_registration_server, " "); mvaddnstr(y+gui_window_online.y0+2, 0, buf, x-1); } else if (josua_registration_status>299) { snprintf(buf, x, "registred: [%i %s] %s %140.140s", josua_registration_status, josua_registration_reason_phrase, josua_registration_server, " "); mvaddnstr(y+gui_window_online.y0+2, 0, buf, x-1); } else if (josua_registration_status==0) { snprintf(buf, x, "registred: [no answer] %s %140.140s", josua_registration_server, " "); mvaddnstr(y+gui_window_online.y0+2, 0, buf, x-1); } return 0; }
static void curses_draw(void) { if (NULL == get_current_node()) { first_node(); first_item(); } row = 0; move(0,0); getmaxyx(stdscr, rows, cols); if (cols < 80) { clear(); putl("Screen must be at least 80 columns wide"); refresh(); return; } if (c_use_colors) attrset(COLOR_PAIR(LAYOUT_STATUSBAR) | layout[LAYOUT_STATUSBAR].attr); else attrset(A_REVERSE); if (get_current_node() && get_current_item()) { putl(" %s on %s", get_current_item()->i_name, get_current_node()->n_name); } move(row, COLS - strlen(PACKAGE_STRING) - 1); putl("%s", PACKAGE_STRING); move(row, 0); if (c_use_colors) attrset(COLOR_PAIR(LAYOUT_DEFAULT) | layout[LAYOUT_DEFAULT].attr); else attroff(A_REVERSE); print_content(); if (quit_mode) print_quit(); else if (print_help) { if (help_page == 0) draw_help(); else draw_help_2(); } for (; row < rows-2;) { move(++row, 0); putl(""); } row = rows-1; move(row, 0); if (c_use_colors) attrset(COLOR_PAIR(LAYOUT_STATUSBAR) | layout[LAYOUT_STATUSBAR].attr); else attrset(A_REVERSE); if (1) { char s[27]; time_t t = time(0); double d; int h, m; asctime_r(localtime(&t), s); s[strlen(s) - 1] = '\0'; d = difftime(time(0), start_time); if (d / 3600) { h = (int) d / 3600; m = (int) d % 3600; m /= 60; } else { h = 0; m = (int) d / 60; } putl(" %s (%dh/%dm)", s, h, m); move(row, COLS - strlen("Press ? for help") - 1); putl("%s", "Press ? for help"); move(row, 0); } attrset(0); refresh(); }
static duc_dir *do_dir(duc_dir *dir, int depth) { int top = 0; int cur = 0; for(;;) { int attr_size, attr_name, attr_class, attr_graph, attr_bar, attr_cursor; if(opt_color) { attr_size = COLOR_PAIR(PAIR_SIZE); attr_name = COLOR_PAIR(PAIR_NAME); attr_bar = COLOR_PAIR(PAIR_BAR); attr_cursor = COLOR_PAIR(PAIR_CURSOR); attr_graph = COLOR_PAIR(PAIR_GRAPH); attr_class = COLOR_PAIR(PAIR_CLASS); } else { attr_size = 0; attr_name = A_BOLD; attr_class = 0; attr_graph = 0; attr_bar = A_REVERSE; attr_cursor = A_REVERSE; use_default_colors(); } duc_size_type st = opt_apparent ? DUC_SIZE_TYPE_APPARENT : DUC_SIZE_TYPE_ACTUAL; /* Iterate all dirents to find largest size */ duc_dir_seek(dir, 0); off_t size_max = 1; struct duc_dirent *e; while( (e = duc_dir_read(dir, st)) != NULL) { off_t size = opt_apparent ? e->size.apparent : e->size.actual; if(size > size_max) size_max = size; } int count = duc_dir_get_count(dir); int pgsize = rows - 2; /* Check boundaries */ if(cur < 0) cur = 0; if(cur > count - 1) cur = count - 1; if(cur < top) top = cur; if(cur > top + pgsize - 1) top = cur - pgsize + 1; if(top < 0) top = 0; /* Draw header */ char *path = duc_dir_get_path(dir); attrset(attr_bar); mvhline(0, 0, ' ', cols); mvprintw(0, 1, " %s ", path); attrset(0); free(path); /* Draw footer */ struct duc_size size; duc_dir_get_size(dir, &size); char siz[32], cnt[32]; duc_human_size(&size, st, opt_bytes, siz, sizeof siz); duc_human_number(count, opt_bytes, cnt, sizeof cnt); attrset(attr_bar); mvhline(rows-1, 0, ' ', cols); mvprintw(rows-1, 0, " Total %sB in %s files/directories", siz, cnt); attrset(0); /* Draw dirents */ duc_dir_seek(dir, top); int i; int y = 1; for(i=top; i<top + pgsize; i++) { struct duc_dirent *e = duc_dir_read(dir, st); attrset(cur == i ? attr_cursor : 0); mvhline(y, 0, ' ', cols); if(e) { off_t size = opt_apparent ? e->size.apparent : e->size.actual; size_t max_size_len = opt_bytes ? 12 : 7; char class = duc_file_type_char(e->type); char siz[32]; duc_human_size(&e->size, st, opt_bytes, siz, sizeof siz); if(cur != i) attrset(attr_size); printw("%*s", max_size_len, siz); printw(" "); char *p = e->name; if(cur != i) attrset(attr_name); while(*p) { if(*(uint8_t *)p >= 32) { printw("%c", *p); } else { printw("^%c", *p+64); } p++; } if(cur != i) attrset(attr_class); printw("%c", class); int w = cols - 30; if(w > cols / 2) w = cols / 2; if(opt_graph && w > 2) { int j; off_t g = w * size / size_max; if(cur != i) attrset(attr_graph); mvprintw(y, cols - w - 4, " ["); for(j=0; j<w; j++) printw("%s", j < g ? "=" : " "); printw("] "); } } else { attrset(A_DIM); mvprintw(y, 0, "~"); } y++; } duc_dir *dir2 = NULL; /* Handle key */ int c = getch(); switch(c) { case 'k': case KEY_UP: cur--; break; case 'j': case KEY_DOWN: cur++; break; case 21: cur -= pgsize/2; break; case KEY_PPAGE: cur -= pgsize; break; case 4: cur += pgsize/2; break; case KEY_NPAGE: cur += pgsize; break; case KEY_RESIZE: getmaxyx(stdscr, rows, cols); break; case 'a': opt_apparent ^= 1; break; case 'b': opt_bytes ^= 1; break; case 'c': opt_color ^= 1; break; case 'g': opt_graph ^= 1; break; case 'h': help(); break; case 27: case 'q': exit(0); break; case KEY_BACKSPACE: case KEY_LEFT: if(depth > 0) { return NULL; } else { dir2 = duc_dir_openat(dir, ".."); if(dir2) { do_dir(dir2, 0); duc_dir_close(dir2); } } break; case KEY_RIGHT: case '\r': case '\n': duc_dir_seek(dir, cur); struct duc_dirent *e = duc_dir_read(dir, st); if(e->type == DUC_FILE_TYPE_DIR) { dir2 = duc_dir_openent(dir, e); if(dir2) { do_dir(dir2, depth + 1); duc_dir_close(dir2); } } break; default: break; } }
static void cob_screen_attr (cob_field *fgc, cob_field *bgc, const int attr) { size_t i; int styles = 0; int line; int column; short fgcolor; short bgcolor; short fgdef; short bgdef; attrset (A_NORMAL); if (attr & COB_SCREEN_REVERSE) { styles |= A_REVERSE; } if (attr & COB_SCREEN_HIGHLIGHT) { styles |= A_BOLD; } if (attr & COB_SCREEN_BLINK) { styles |= A_BLINK; } if (attr & COB_SCREEN_UNDERLINE) { styles |= A_UNDERLINE; } if (styles) { attron (styles); } if (cob_has_color) { fgcolor = fore_color; bgcolor = back_color; if (fgc) { switch (cob_get_int (fgc)) { case COB_SCREEN_BLACK: fgcolor = COLOR_BLACK; break; case COB_SCREEN_BLUE: fgcolor = COLOR_BLUE; break; case COB_SCREEN_GREEN: fgcolor = COLOR_GREEN; break; case COB_SCREEN_CYAN: fgcolor = COLOR_CYAN; break; case COB_SCREEN_RED: fgcolor = COLOR_RED; break; case COB_SCREEN_MAGENTA: fgcolor = COLOR_MAGENTA; break; case COB_SCREEN_YELLOW: fgcolor = COLOR_YELLOW; break; case COB_SCREEN_WHITE: fgcolor = COLOR_WHITE; break; default: break; } } if (bgc) { switch (cob_get_int (bgc)) { case COB_SCREEN_BLACK: bgcolor = COLOR_BLACK; break; case COB_SCREEN_BLUE: bgcolor = COLOR_BLUE; break; case COB_SCREEN_GREEN: bgcolor = COLOR_GREEN; break; case COB_SCREEN_CYAN: bgcolor = COLOR_CYAN; break; case COB_SCREEN_RED: bgcolor = COLOR_RED; break; case COB_SCREEN_MAGENTA: bgcolor = COLOR_MAGENTA; break; case COB_SCREEN_YELLOW: bgcolor = COLOR_YELLOW; break; case COB_SCREEN_WHITE: bgcolor = COLOR_WHITE; break; default: break; } } for (i = 0; i < (size_t)COLOR_PAIRS; i++) { pair_content ((short)i, &fgdef, &bgdef); if (fgdef == fgcolor && bgdef == bgcolor) { break; } if (fgdef == 0 && bgdef == 0) { init_pair ((short)i, fgcolor, bgcolor); break; } } if (i != (size_t)COLOR_PAIRS) { #ifdef HAVE_COLOR_SET color_set (COLOR_PAIR((short)i), (void *)0); #else attrset (COLOR_PAIR(i)); #endif bkgdset (COLOR_PAIR(i)); } else { attrset (A_NORMAL); } } if (attr & COB_SCREEN_BLANK_SCREEN) { getyx (stdscr, line, column); clear (); move (line, column); } if (attr & COB_SCREEN_BLANK_LINE) { getyx (stdscr, line, column); move (line, 0); clrtoeol (); move (line, column); } if (attr & COB_SCREEN_ERASE_EOL) { clrtoeol (); } if (attr & COB_SCREEN_ERASE_EOS) { clrtobot (); } if (attr & COB_SCREEN_BELL) { beep (); } }
static void color_edit(void) /* display the color test pattern, without trying to edit colors */ { int i, c, value = 0, current = 0, field = 0, usebase = 0; refresh(); for (i = 0; i < COLORS; i++) init_pair(i, COLOR_WHITE, i); do { short red, green, blue; attron(A_BOLD); mvaddstr(0, 20, "Color RGB Value Editing"); attroff(A_BOLD); for (i = 0; i < COLORS; i++) { mvprintw(2 + i, 0, "%c %-8s:", (i == current ? '>' : ' '), (i < sizeof(colors)/sizeof(colors[0]) ? colors[i] : "")); attrset(COLOR_PAIR(i)); addstr(" "); attrset(A_NORMAL); /* * Note: this refresh should *not* be necessary! It works around * a bug in attribute handling that apparently causes the A_NORMAL * attribute sets to interfere with the actual emission of the * color setting somehow. This needs to be fixed. */ refresh(); color_content(i, &red, &green, &blue); addstr(" R = "); if (current == i && field == 0) attron(A_STANDOUT); printw("%04d", red); if (current == i && field == 0) attrset(A_NORMAL); addstr(", G = "); if (current == i && field == 1) attron(A_STANDOUT); printw("%04d", green); if (current == i && field == 1) attrset(A_NORMAL); addstr(", B = "); if (current == i && field == 2) attron(A_STANDOUT); printw("%04d", blue); if (current == i && field == 2) attrset(A_NORMAL); attrset(A_NORMAL); addstr(")"); } mvaddstr(COLORS + 3, 0, "Use up/down to select a color, left/right to change fields."); mvaddstr(COLORS + 4, 0, "Modify field by typing nnn=, nnn-, or nnn+. ? for help."); move(2 + current, 0); switch (c = getch()) { case KEY_UP: current = (current == 0 ? (COLORS - 1) : current - 1); value = 0; break; case KEY_DOWN: current = (current == (COLORS - 1) ? 0 : current + 1); value = 0; break; case KEY_RIGHT: field = (field == 2 ? 0 : field + 1); value = 0; break; case KEY_LEFT: field = (field == 0 ? 2 : field - 1); value = 0; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': do { value = value * 10 + (c - '0'); c = getch(); } while (isdigit(c)); if (c != '+' && c != '-' && c != '=') beep(); else ungetch(c); break; case '+': usebase = 1; goto changeit; case '-': value = -value; usebase = 1; goto changeit; case '=': usebase = 0; changeit: color_content(current, &red, &green, &blue); if (field == 0) red = red * usebase + value; else if (field == 1) green = green * usebase + value; else if (field == 2) blue = blue * usebase + value; init_color(current, red, green, blue); break; case '?': erase(); P(" RGB Value Editing Help"); P(""); P("You are in the RGB value editor. Use the arrow keys to select one of"); P("the fields in one of the RGB triples of the current colors; the one"); P("currently selected will be reverse-video highlighted."); P(""); P("To change a field, enter the digits of the new value; they won't be"); P("echoed. Finish by typing `='; the change will take effect instantly."); P("To increment or decrement a value, use the same procedure, but finish"); P("with a `+' or `-'."); P(""); P("To quit, do `x' or 'q'"); move(LINES - 1, 0); addstr("Press any key to continue... "); (void) getch(); erase(); break; case 'x': case 'q': break; default: beep(); break; } } while (c != 'x' && c != 'q'); erase(); endwin(); }
void Container::Print_Object_Name() { attrset(COLOR_PAIR(Blue_Green)); addstr(Name); }
static void print_content(void) { int required_lines = 0, disable_detailed = 0, disabled_graphical = 0; if (NULL == get_current_node()) return; if (c_list_in_list) { NEXT_ROW; putl(""); if (c_use_colors) attrset(COLOR_PAIR(LAYOUT_HEADER) | layout[LAYOUT_HEADER].attr); NEXT_ROW; putl(" # Tarjeta de Red ' Rawil' RX Tasa RX # " \ " TX Tasa TX #"); NEXT_ROW; hline(ACS_HLINE, cols); if (c_combined_node_list) foreach_node(draw_node, NULL); else draw_node(get_current_node(), NULL); } else { NEXT_ROW; hline(ACS_HLINE, cols); move(row, 24); addstr(" Press l to enable list view "); move(row, 0); } /* * calculate lines required for graphical and detailed stats unfolded */ if (c_graphical_in_list) required_lines += lines_required_for_graphical(); else required_lines++; if (c_detailed_in_list) required_lines += lines_required_for_detailed(); else required_lines++; if ((rows - row) <= (required_lines + 1)) { /* * not enough lines, start over with detailed stats disabled */ required_lines = 0; disable_detailed = 1; /* * 1 line for folded detailed stats display */ required_lines++; if (c_graphical_in_list) required_lines += lines_required_for_graphical(); else required_lines++; if ((rows - row) <= (required_lines + 1)) { /* * bad luck, not even enough space for graphical stats * reserve 2 lines for displaying folded detailed and * graphical stats */ required_lines = 2; disabled_graphical = 1; } } /* * Clear out spare space */ while (row < (rows - (required_lines + 2))) { NEXT_ROW; putl(""); } NEXT_ROW; hline(ACS_HLINE, cols); if (c_graphical_in_list) { if (disabled_graphical) { move(row, 15); addstr(" Increase screen size to see graphical statistics "); move(row, 0); } else draw_graphic(); } else { move(row, 20); addstr(" Press g to enable graphical statistics "); move(row, 0); } NEXT_ROW; hline(ACS_HLINE, cols); if (c_detailed_in_list) { if (disable_detailed) { move(row, 15); addstr(" Increase screen size to see detailed statistics "); move(row, 0); } else draw_detailed(); } else { move(row, 20); addstr(" Press d to enable detailed statistics "); move(row, 0); } }
/* visual mode */ void visualmode(void){ int c; currmode = PM_VISUAL; //attrset(A_REVERSE); if(currtab == 0){ }else if(currtab == 1){ highlight_firstx = trackx; highlight_lastx = trackx; highlight_firsty = tracky; highlight_lasty = tracky; }else if(currtab == 2){ }else{ highlight_firstx = -1; highlight_lastx = -1; highlight_firsty = -1; highlight_lasty = -1; } while(currmode == PM_VISUAL){ if((c = getch()) != ERR) switch(c){ case 'v': case KEY_ESCAPE: currmode = PM_NORMAL; break; case 'V': visuallinemode(); break; case 'h': act_mvleft(); if(currtab==0){ }else if(currtab==1){ highlight_lastx = trackx; }else if(currtab==2){ } break; case 'j': act_mvdown(); if(currtab==0){ }else if(currtab==1){ highlight_lasty = tracky; }else if(currtab==2){ } break; case 'k': act_mvup(); if(currtab==0){ }else if(currtab==1){ highlight_lasty = tracky; }else if(currtab==2){ } break; case 'l': act_mvright(); if(currtab==0){ }else if(currtab==1){ highlight_lastx = trackx; }else if(currtab==2){ } break; } drawgui(); } attrset(A_BOLD); return; }
/* Starts the program and prints the main menu */ int main(int qw) { static int mm = -1; mm++; initscr(); curs_set(0); noecho(); if(qw == 2) banner(4); else if(qw == 1) banner(3); ITEM **my_items; int c; MENU *my_menu; WINDOW *my_menu_win; int n_choices, i; ITEM *cur; /* Initialize curses */ initscr(); start_color(); init_pair(5, COLOR_RED, COLOR_BLACK); init_pair(6, COLOR_BLACK, COLOR_RED); init_pair(7, COLOR_CYAN, COLOR_BLACK); cbreak(); noecho(); keypad(stdscr, TRUE); init_pair(1, COLOR_RED, COLOR_BLACK); START: attrset(COLOR_PAIR(7)); n_choices = ARRAY_SIZE(choices_index); my_items = (ITEM **)calloc(n_choices, sizeof(ITEM *)); for(i = 0; i < n_choices; ++i) { my_items[i] = new_item(choices_index[i], NULL); if(i == 0) /* Set the user pointer */ set_item_userptr(my_items[i], mains); else if(i == 1) set_item_userptr(my_items[i], race_menu); else if(i == 2) set_item_userptr(my_items[i], exitit); } my_items[n_choices] = (ITEM *)NULL; /* Crate menu */ my_menu = new_menu((ITEM **)my_items); /* Create the window to be associated with the menu */ my_menu_win = newwin(8, 25, 15, 70); keypad(my_menu_win, TRUE); /* Set main window and sub window */ set_menu_win(my_menu, my_menu_win); set_menu_sub(my_menu, derwin(my_menu_win, 5, 19, 3, 1)); /* Set menu mark to the string " * " */ set_menu_mark(my_menu, "--> "); /* Print a border around the main window and print a title */ box(my_menu_win, 0, 0); print_in_middle1(my_menu_win, 1, 0, 25, "CHOOSE A GAME", COLOR_PAIR(7)); attrset(COLOR_PAIR(7)); mvwaddch(my_menu_win, 2, 0, ACS_LTEE); mvwhline(my_menu_win, 2, 1, ACS_HLINE, 24); mvwaddch(my_menu_win, 2, 24, ACS_RTEE); mvprintw(LINES - 2, 1, " Press F1 to exit"); /* Post the menu */ mvprintw(LINES - 3, 1, " Press <ENTER> to see the option selected"); mvprintw(LINES - 2, 1, " Up and Down arrow keys to navigate (F1 to Exit)"); post_menu(my_menu); if(!mm) moto(0); else moto(1); refresh(); /* Post the menu */ post_menu(my_menu); wrefresh(my_menu_win); while((c = wgetch(my_menu_win)) != KEY_F(1)) { switch(c) { case KEY_DOWN: menu_driver(my_menu, REQ_DOWN_ITEM); break; case KEY_UP: menu_driver(my_menu, REQ_UP_ITEM); break; case 10: cur = current_item(my_menu); endwin(); unpost_menu(my_menu); clear(); refresh(); void (*p)(char *); cur = current_item(my_menu); p = item_userptr(cur); p((char *)item_name(cur)); pos_menu_cursor(my_menu); initscr(); /* Post the menu */ attrset(COLOR_PAIR(7)); mvprintw(LINES - 3, 1, " Press <ENTER> to see the option selected"); mvprintw(LINES - 2, 1, " Up and Down arrow keys to naviage (F1 to Exit)"); goto START; refresh(); break; } wrefresh(my_menu_win); } /* Unpost and free all the memory taken up */ for(i = 0; i < n_choices; ++i) free_item(my_items[i]); free_menu(my_menu); endwin(); exit(1); }
void colorTest(WINDOW *win) { static const short colors[] = { COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_BLUE, COLOR_CYAN, COLOR_MAGENTA, COLOR_YELLOW, COLOR_WHITE }; static const char *colornames[] = { "COLOR_BLACK", "COLOR_RED", "COLOR_GREEN", "COLOR_BLUE", "COLOR_CYAN", "COLOR_MAGENTA", "COLOR_YELLOW", "COLOR_WHITE" }; chtype fill = ACS_BLOCK; int i, j, tmarg, col1, col2, col3, col4, ch; if (!has_colors()) return; do { tmarg = (LINES - 19) / 2; col1 = (COLS - 60) / 2; col2 = col1 + 15; col3 = col2 + 15; col4 = col3 + 15; attrset(A_BOLD); mvaddstr(tmarg, (COLS - 22) / 2, "Color Attribute Macros"); attrset(A_NORMAL); mvaddstr(tmarg + 3, col2 + 2, "A_NORMAL"); mvaddstr(tmarg + 3, col3 + 3, "A_BOLD"); mvaddstr(tmarg + 3, col4 + 3, "A_BLINK"); for (i = 0; i < 8; i++) { init_pair((short)(i + 4), colors[i], background_index); mvaddstr(tmarg + i + 5, col1, colornames[i]); for (j = 0; j < 12; j++) { mvaddch(tmarg + i + 5, col2 + j, fill | COLOR_PAIR(i + 4)); mvaddch(tmarg + i + 5, col3 + j, fill | COLOR_PAIR(i + 4) | A_BOLD); mvaddch(tmarg + i + 5, col4 + j, fill | COLOR_PAIR(i + 4) | A_BLINK); } attrset( COLOR_PAIR( i + 4) | A_BLINK); mvaddstr( tmarg + i + 5, col4 + 5, "Text"); attrset( COLOR_PAIR( i + 4) | A_BOLD); mvaddstr( tmarg + i + 5, col3 + 5, "Text"); attroff( A_BOLD); mvaddstr( tmarg + i + 5, col2 + 5, "Text"); attrset( A_NORMAL); } mvprintw(tmarg + 15, col1, "COLORS = %d", COLORS); mvprintw(tmarg + 16, col1, "COLOR_PAIRS = %d", COLOR_PAIRS); /* BJG additions: */ attrset(A_ITALIC); mvprintw( tmarg + 15, col3, "Italic"); attrset(A_BOLD); mvprintw( tmarg + 16, col3, "Bold"); attrset(A_BLINK); mvprintw( tmarg + 17, col3, "Blink"); attrset(A_ITALIC | A_BLINK); mvprintw( tmarg + 15, col4, "Italic Blink"); attrset(A_BLINK | A_BOLD); mvprintw( tmarg + 16, col4, "Blink Bold"); attrset(A_BOLD | A_ITALIC); mvprintw( tmarg + 17, col4, "Italic Bold"); attrset(A_BOLD | A_ITALIC | A_BLINK); mvprintw( tmarg + 18, col4, "Italic Blink Bold"); /* end BJG addenda */ attrset(A_NORMAL); mvaddstr(tmarg + 19, 3, "Press any key to continue"); ch = getch(); # ifdef PDCURSES if( ch == KEY_RESIZE) { erase(); resize_term(0, 0); } # endif } while( ch == KEY_RESIZE); if (can_change_color()) { struct { short red, green, blue; } orgcolors[16]; int MAXCOL = (COLORS >= 16) ? 16 : 8; if (MAXCOL < 8) return; for (i = 0; i < MAXCOL; i++) color_content((short)i, &(orgcolors[i].red), &(orgcolors[i].green), &(orgcolors[i].blue)); attrset(A_BOLD); mvaddstr(tmarg, (COLS - 22) / 2, " init_color() Example "); attrset(A_NORMAL); refresh(); for (i = 0; i < 8; i++) { init_color(colors[i], (short)(i * 125), 0, (short)(i * 125)); if (MAXCOL == 16) init_color((short)(colors[i] + 8), 0, (short)(i * 125), 0); } mvaddstr(tmarg + 19, 3, "Press any key to continue"); getch(); for (i = 0; i < MAXCOL; i++) init_color((short)i, orgcolors[i].red, orgcolors[i].green, orgcolors[i].blue); } /* BJG additions: */ if( COLORS == 256 && LINES >= 18) do /* show off all 256 colors */ { tmarg = LINES / 2 - 8; erase( ); for( i = 0; i < 256; i++) { char tbuff[4]; const int col = COLS / 2 - 24; if( i >= 16) init_pair((short)i, (short)i, COLOR_BLACK); attrset( COLOR_PAIR( i) | A_REVERSE); sprintf( tbuff, "%02x ", i); mvaddstr( tmarg + i / 16, col + (i % 16) * 3, tbuff); } attrset( A_LEFTLINE); mvaddstr( tmarg + 17, col1, "A_LEFTLINE"); attrset( A_UNDERLINE); mvaddstr( tmarg + 18, col1, "A_UNDERLINE"); attrset( A_RIGHTLINE); mvaddstr( tmarg + 19, col1, "A_RIGHTLINE"); # if(CHTYPE_LONG >= 2) /* following types don't exist otherwise: */ attrset( A_OVERLINE); mvaddstr( tmarg + 17, col2, "A_OVERLINE"); attrset( A_STRIKEOUT); mvaddstr( tmarg + 18, col2, "A_STRIKEOUT"); attrset( A_OVERLINE | A_UNDERLINE); mvaddstr( tmarg + 19, col2, "Over/underlined"); #endif attrset(A_NORMAL); refresh( ); ch = getch( ); # ifdef PDCURSES if( ch == KEY_RESIZE) resize_term(0, 0); # endif } while( ch == KEY_RESIZE); }
/* Among other things, 'newtest' demonstrates how to make a Win32a PDCurses app that is a for-real, "pure Windows" version (instead of a console application). Doing this is quite easy, and has certain advantages. If the app is invoked from a command prompt, the only difference you'll see is that the app runs separately (that is, you can continue to use the command prompt, switching between it, your PDCurses/Win32a app, and other processes). Which is the main reason I did it; it meant that I could invoke a PDCurses-based text editor, for example, and still have use of the command line. (NOTE that, for reasons I don't actually understand, this happens when the Visual C++ compiler is used. With MinGW or OpenWatcom, it's still "really" a console app.) To do it, we ensure that the usual main() function has an alternative dummy_main() form, taking the same arguments as main(). We add a WinMain() function, whose sole purpose is to reformulate lpszCmdLine into argc/argv form, and pass it on to dummy_main(). And, of course, we can switch back to a "normal" console app by removing the above #define PURE_WINDOWS_VERSION line. */ #ifdef PURE_WINDOWS_VERSION #undef MOUSE_MOVED #include <windows.h> int dummy_main( int argc, char **argv); int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow) { char *argv[30]; int i, argc = 1; argv[0] = "newtest"; for( i = 0; lpszCmdLine[i]; i++) if( lpszCmdLine[i] != ' ' && (!i || lpszCmdLine[i - 1] == ' ')) argv[argc++] = lpszCmdLine + i; for( i = 0; lpszCmdLine[i]; i++) if( lpszCmdLine[i] == ' ') lpszCmdLine[i] = '\0'; return dummy_main( argc, (char **)argv); } int dummy_main( int argc, char **argv) #else /* "usual", console-app version: */ int main( int argc, char **argv) #endif { int quit = 0, i, use_slk = 1; int fmt = 0xa; bool blink_state = FALSE; int cursor_state_1 = 2, cursor_state_2 = 3; int show_slk_index_line = 0; int redraw = 1; unsigned extra_character_to_show = 0; #ifdef PDC_WIDE unsigned unicode_offset = 0x80; #endif /* setlocale(LC_ALL, ".utf8"); */ ttytype[0] = 25; ttytype[1] = 90; /* Allow 25 to 90 lines... */ ttytype[2] = 80; ttytype[3] = (char)200; /* ...and 80 to 200 columns */ /* (This program gets weird artifacts when smaller than 25x80.) */ for( i = 1; i < argc; i++) if( argv[i][0] == '-') switch( argv[i][1]) { case 's': use_slk = 0; break; case 'l': setlocale( LC_ALL, argv[i] + 2); break; case 'e': sscanf( argv[i] + 2, "%x", &extra_character_to_show); break; case 'f': sscanf( argv[i] + 2, "%x", (unsigned *)&fmt); break; case 'i': show_slk_index_line = 1; break; case 'r': /* allow user-resizable windows */ { int min_lines, max_lines, min_cols, max_cols; if( sscanf( argv[i] + 2, "%d,%d,%d,%d", &min_lines, &max_lines, &min_cols, &max_cols) == 4) { ttytype[0] = min_lines; ttytype[1] = max_lines; ttytype[2] = min_cols; ttytype[3] = max_cols; } } break; case 'd': /* set window size before initscr */ { int n_lines, n_cols; if( sscanf( argv[i] + 2, "%d,%d", &n_lines, &n_cols) == 2) resize_term( n_lines, n_cols); } break; #ifdef PDC_WIDE case 'u': sscanf( argv[i] + 2, "%x", &unicode_offset); break; #endif default: printf( "Option '%s' unrecognized\n", argv[i]); break; } if( use_slk) slk_init( show_slk_index_line ? 3 : 0); Xinitscr(argc, argv); if( use_slk) slk_setup( show_slk_index_line ? -fmt : fmt); start_color(); # if defined(NCURSES_VERSION) || (defined(PDC_BUILD) && PDC_BUILD > 3000) use_default_colors(); # endif cbreak(); noecho(); clear(); refresh(); #ifdef __PDCURSES__ PDC_set_title( "NewTest: tests various PDCurses features"); #endif keypad( stdscr, TRUE); init_pair( 1, 15, COLOR_BLACK); init_pair( 2, COLOR_BLACK, COLOR_YELLOW); mousemask( ALL_MOUSE_EVENTS, NULL); attrset( COLOR_PAIR( 1)); while( !quit) { char buff[80]; const int xmax = getmaxx( stdscr); const int ymax = getmaxy( stdscr); int color_block_start = 54, c; int color_block_cols = (xmax - color_block_start) / 2; const int color_block_lines = 19; const char *cursor_state_text[N_CURSORS] = { "Invisible (click to change) ", "Underscore (click to change)", "Block (click to change) ", "Outline (click to change) ", "Caret (click to change) ", "Half-block (click to change)", "Central (click to change) ", "Cross (click to change) ", "Heavy box (click to change) " }; if( color_block_cols < 0) color_block_cols = 0; if( redraw) { mvaddstr( 1, COL1, "'Normal' white-on-black"); mvaddstr( 2, COL1, longname( )); #if(CHTYPE_LONG >= 2) /* "non-standard" 64-bit chtypes */ attron( A_DIM); mvaddstr( 15, 41, "Dimmed text"); attroff( A_DIM); #endif #ifdef PDC_WIDE mvaddwstr( 3, COL1, L"'Normal' text, but wide"); #endif attron( A_BLINK); mvaddstr( 6, 40, "Blinking"); attron( A_BOLD); mvaddstr( 8, 40, "BlinkBold"); attron( A_ITALIC); mvaddstr( 0, COL2, "BlinkBoldItalic"); attrset( COLOR_PAIR( 3)); attron( A_UNDERLINE); #ifdef PDC_WIDE mvaddstr( 1, COL2, "Underlined"); addwstr( L"WideUnder"); #endif attrset( COLOR_PAIR( 1)); attron( A_UNDERLINE | A_ITALIC); mvaddstr( 2, COL2, "UnderlinedItalic"); attrset( COLOR_PAIR( 2)); attron( A_BLINK); mvaddstr( 4, COL1, "Black-on-yellow blinking"); attrset( COLOR_PAIR( 1)); move( 4, COL2); text_in_a_box( "Text in a box"); #ifdef CHTYPE_LONG attrset( COLOR_PAIR( 6)); attron( A_STRIKEOUT); mvaddstr( 10, 40, "Strikeout"); attrset( COLOR_PAIR( 1)); #endif #ifdef PDC_WIDE move( 11, 40); text_in_a_box( "Next Ucode pg"); if( unicode_offset) { move( 12, 40); text_in_a_box( "Prev Ucode pg"); } mvprintw( 13, 40, "U+%04x ", unicode_offset); #endif for( i = 0; i < 128; i++) { /* Show extended characters: */ #ifdef PDC_WIDE wchar_t buff[20]; swprintf( buff, 20, L"%02x ", (unsigned)( i + unicode_offset) & 0xff); mvaddwstr( 5 + i % 16, (i / 16) * 5, buff); if( i + unicode_offset > ' ') addch( (chtype)( i + unicode_offset)); else addch( ' '); addch( ' '); #else char buff[6]; sprintf( buff, "%02x %c", i + 128, (char)(i + 128)); mvaddstr( 5 + i % 16, (i / 16) * 5, buff); #endif } #if(CHTYPE_LONG >= 2) /* "non-standard" 64-bit chtypes */ for( i = 0; i < 3 && i + 21 < ymax; i++) { /* Demonstrate full RGB color control: */ int j; const char *output_text[3] = { "Red on green to white on black | (you can get full RGB colors when desired,", "Blue on yellow to black on red | with palette coloring still being available)", "White on red to green on blue, underlined and italic" }; const int len = (int)strlen( output_text[i]); move( 21 + i, 1); for( j = 0; j < len && j + 1 < xmax; j++) { attr_t output_color; const int oval = j * 31 / len; const int reverse = 31 - oval; if( !i) output_color = A_RGB( 31, oval, oval, 0, reverse, 0); else if( i == 1) output_color = A_RGB( 0, 0, reverse, 31, reverse, 0); else { output_color = A_RGB( reverse, 31, reverse, reverse, 0, oval); output_color |= A_UNDERLINE | A_ITALIC; } attrset( output_color); addch( output_text[i][j]); } } #endif /* #if(CHTYPE_LONG >= 2) */ redraw = 0; attrset( COLOR_PAIR( 1)); if( extra_character_to_show && ymax > 23) mvaddch( 23, 63, (chtype)extra_character_to_show); #ifdef PDC_WIDE for( i = 0; i < 6; i++) { static const wchar_t spanish[] = L"Espa\xf1ol"; const int line = 24 + i / 3; const int col = 5 + 25 * (i % 3); static const wchar_t russian[] = {0x0420, 0x0443, 0x0441, 0x0441, 0x043a, 0x0438, 0x0439, L' ', 0x044f, 0x0437, 0x044b, 0x043a, 0}; static const wchar_t greek[] = {0x0395, 0x03bb, 0x03bb, 0x03b7, 0x03bd, 0x03b9, 0x03ba, 0x03ac, 0}; static const wchar_t georgian[] = {0x10e5, 0x10d0, 0x10e0, 0x10d7, 0x10e3, 0x10da, 0x10d8, L' ', 0x10d4, 0x10dc, 0x10d0, 0}; static const wchar_t fullwidth[] = { 0xff26, 0xff55, 0xff4c, 0xff4c, 0xff57, 0xff49, 0xff44, 0xff54, 0xff48, 0 }; /* "Fullwidth" */ static const wchar_t combining_marks[] = { L'C', L'o', 0x35c, L'm', L'b', 0x30a, L'i', L'n', L'i', 0x304, L'n', 0x30b, 0x329, L'g', 0x310, L' ', L'C', 0x338, L'h', 0x306, L'a', 0x361, L'r', L's', 0x30e, 0x348, 0 }; static const wchar_t *texts[6] = { spanish, russian, greek, georgian, fullwidth, combining_marks}; if( line < ymax && col < xmax) mvaddnwstr( line, 5 + 25 * (i % 3), texts[i], xmax - col); } #endif #ifdef MAYBE_TRY_THIS_SOMEWHERE_ELSE mvaddstr( 1, COL3, "Click on cursor descriptions to"); mvaddstr( 2, COL3, "cycle through possible cursors"); mvaddstr( 3, COL3, "Click on colors at left to change"); mvaddstr( 4, COL3, "colors used for under/over/outlining"); mvaddstr( 5, COL3, "Click 'Blink' at bottom to toggle"); mvaddstr( 6, COL3, "'real' blinking vs. 'highlit' blink"); #endif } mvaddnstr( 19, color_block_start, cursor_state_text[cursor_state_1], xmax - color_block_start); mvaddnstr( 20, color_block_start, cursor_state_text[cursor_state_2], xmax - color_block_start); curs_set( (cursor_state_1 << 8) | cursor_state_2); for( i = 0; i < color_block_cols * color_block_lines; i++) { const int n_color_blocks = (COLOR_PAIRS < 256 ? COLOR_PAIRS : 256); attrset( COLOR_PAIR( i >= n_color_blocks ? 2 : i)); if( i > 2 && i < n_color_blocks) init_pair((short)i, (short)i, COLOR_BLACK); if( !(i % color_block_cols)) move( i / color_block_cols, color_block_start); attron( A_REVERSE); addstr( " "); } move( 19, color_block_start - 3); refresh(); c = getch( ); attrset( COLOR_PAIR( 1)); if( c == KEY_RESIZE) { redraw = 1; resize_term( 0, 0); } else if( c == KEY_F(1) || c == 27) quit = 1; else if( c == KEY_F(2)) { blink_state ^= 1; PDC_set_blink( blink_state); } else if( c == KEY_F(3)) /* toggle SLKs */ { use_slk ^= 1; if( use_slk) slk_restore( ); else slk_clear( ); } else if( c >= KEY_F(4) && c < KEY_F(12)) { sscanf( labels[c - KEY_F(1)], "%x", (unsigned *)&fmt); if( use_slk) slk_setup( show_slk_index_line ? -fmt : fmt); } if( c != KEY_MOUSE) { sprintf( buff, "Key %s", keyname( c)); if( !memcmp( buff + 4, "UNKNOWN", 7)) sprintf( buff + 11, " (%x)", c); strcat( buff, " hit "); buff[COL2 - COL1] = '\0'; mvaddstr( 0, COL1, buff); } else { MEVENT mouse_event; #ifdef __PDCURSES__ nc_getmouse( &mouse_event); #else getmouse( &mouse_event); #endif sprintf( buff, "Mouse at %d x %d: %x ", mouse_event.x, mouse_event.y, (unsigned)mouse_event.bstate); mvaddstr( 0, COL1, buff); if( mouse_event.x >= color_block_start && mouse_event.y < color_block_lines) { int new_color = (mouse_event.x - color_block_start) / 2 + mouse_event.y * color_block_cols; if( new_color >= 256) new_color = -1; PDC_set_line_color( (short)new_color); } else if( mouse_event.x >= color_block_start) { int shift = ((mouse_event.bstate & BUTTON_MODIFIER_SHIFT) ? N_CURSORS - 1 : 1); if( mouse_event.y == 19) /* blink/non-blink toggle */ cursor_state_1 = (cursor_state_1 + shift) % N_CURSORS; else if( mouse_event.y == 20) /* cycle cursor state */ cursor_state_2 = (cursor_state_2 + shift) % N_CURSORS; } #ifdef PDC_WIDE else if( mouse_event.x >= 40 && mouse_event.x < 40 + 10) { if( mouse_event.y == 11) { redraw = 1; unicode_offset += 0x80; } else if( mouse_event.y == 12 && unicode_offset) { redraw = 1; unicode_offset -= 0x80; } } #endif } } endwin(); return 0; }
void acsTest(WINDOW *win) { #ifdef ACS_S3 # define ACSNUM 32 #else # define ACSNUM 25 #endif static const char *acs_names[] = { "ACS_ULCORNER", "ACS_URCORNER", "ACS_LLCORNER", "ACS_LRCORNER", "ACS_LTEE", "ACS_RTEE", "ACS_TTEE", "ACS_BTEE", "ACS_HLINE", "ACS_VLINE", "ACS_PLUS", "ACS_S1", "ACS_S9", "ACS_DIAMOND", "ACS_CKBOARD", "ACS_DEGREE", "ACS_PLMINUS", "ACS_BULLET", "ACS_LARROW", "ACS_RARROW", "ACS_UARROW", "ACS_DARROW", "ACS_BOARD", "ACS_LANTERN", "ACS_BLOCK" #ifdef ACS_S3 , "ACS_S3", "ACS_S7", "ACS_LEQUAL", "ACS_GEQUAL", "ACS_PI", "ACS_NEQUAL", "ACS_STERLING" #endif }; chtype acs_values[ACSNUM]; #if HAVE_WIDE cchar_t *wacs_values[] = { WACS_ULCORNER, WACS_URCORNER, WACS_LLCORNER, WACS_LRCORNER, WACS_LTEE, WACS_RTEE, WACS_TTEE, WACS_BTEE, WACS_HLINE, WACS_VLINE, WACS_PLUS, WACS_S1, WACS_S9, WACS_DIAMOND, WACS_CKBOARD, WACS_DEGREE, WACS_PLMINUS, WACS_BULLET, WACS_LARROW, WACS_RARROW, WACS_UARROW, WACS_DARROW, WACS_BOARD, WACS_LANTERN, WACS_BLOCK # ifdef WACS_S3 , WACS_S3, WACS_S7, WACS_LEQUAL, WACS_GEQUAL, WACS_PI, WACS_NEQUAL, WACS_STERLING # endif }; static const wchar_t russian[] = {0x0420, 0x0443, 0x0441, 0x0441, 0x043a, 0x0438, 0x0439, L' ', 0x044f, 0x0437, 0x044b, 0x043a, 0}; static const wchar_t greek[] = {0x0395, 0x03bb, 0x03bb, 0x03b7, 0x03bd, 0x03b9, 0x03ba, 0x03ac, 0}; static const wchar_t georgian[] = {0x10e5, 0x10d0, 0x10e0, 0x10d7, 0x10e3, 0x10da, 0x10d8, L' ', 0x10d4, 0x10dc, 0x10d0, 0}; #endif int i, tmarg = (LINES - 22) / 2; attrset(A_BOLD); mvaddstr(tmarg, (COLS - 23) / 2, "Alternate Character Set"); attrset(A_NORMAL); tmarg += 3; #define A(b,c) acs_values[b] = ACS_##c A(0,ULCORNER); A(1,URCORNER); A(2,LLCORNER); A(3,LRCORNER); A(4,LTEE); A(5,RTEE); A(6,TTEE); A(7,BTEE); A(8,HLINE); A(9,VLINE); A(10,PLUS); A(11,S1); A(12,S9); A(13,DIAMOND); A(14,CKBOARD); A(15,DEGREE); A(16,PLMINUS); A(17,BULLET); A(18,LARROW); A(19,RARROW); A(20,UARROW); A(21,DARROW); A(22,BOARD); A(23,LANTERN); A(24,BLOCK); #ifdef ACS_S3 A(25,S3); A(26,S7); A(27,LEQUAL); A(28,GEQUAL); A(29,PI); A(30,NEQUAL); A(31,STERLING); #endif #undef A for (i = 0; i < ACSNUM; i++) { move((i % 8) * 2 + tmarg, (i / 8) * (COLS / 4) + (COLS / 8 - 7)); addch(acs_values[i]); printw(" %s", acs_names[i]); } mvaddstr(tmarg + 18, 3, "Press any key to continue"); getch(); #if HAVE_WIDE clear(); attrset(A_BOLD); mvaddstr(tmarg - 3, (COLS - 28) / 2, "Wide Alternate Character Set"); attrset(A_NORMAL); for (i = 0; i < ACSNUM; i++) { move((i % 8) * 2 + tmarg, (i / 8) * (COLS / 4) + (COLS / 8 - 7)); add_wch(wacs_values[i]); printw(" W%s", acs_names[i]); } /* Spanish, Russian, Greek, Georgian */ mvaddwstr(tmarg + 16, COLS / 8 - 5, L"Espa\xf1ol"); mvaddwstr(tmarg + 16, 3 * (COLS / 8) - 5, russian); mvaddwstr(tmarg + 16, 5 * (COLS / 8) - 5, greek); mvaddwstr(tmarg + 16, 7 * (COLS / 8) - 5, georgian); mvaddstr(tmarg + 18, 3, "Press any key to continue"); getch(); #endif }
int main(int argc, char **argv) { int i, start, end, row, diff, flag, direction; const unsigned seed = (unsigned)time((time_t *)0); #ifdef XCURSES Xinitscr(argc, argv); #else initscr(); #endif nodelay(stdscr, TRUE); noecho(); if (has_colors()) start_color(); for (i = 0; i < 8; i++) init_pair((short)i, color_table[i], COLOR_BLACK); srand(seed); flag = 0; while (getch() == ERR) /* loop until a key is hit */ { do { start = rand() % (COLS - 3); end = rand() % (COLS - 3); start = (start < 2) ? 2 : start; end = (end < 2) ? 2 : end; direction = (start > end) ? -1 : 1; diff = abs(start - end); } while (diff < 2 || diff >= LINES - 2); attrset(A_NORMAL); for (row = 0; row < diff; row++) { mvaddstr(LINES - row, row * direction + start, (direction < 0) ? "\\" : "/"); if (flag++) { myrefresh(); erase(); flag = 0; } } if (flag++) { myrefresh(); flag = 0; } explode(LINES - row, diff * direction + start); erase(); myrefresh(); } endwin(); return 0; }
void main() { #define PALSIZE 8 char *palette=" -=*O@@@@_"; srand(time(NULL)); // Needed initscr(); cbreak(); noecho(); // Optional nonl(); intrflush(stdscr,FALSE); keypad(stdscr,FALSE); printf("%i x %i\n",COLS,LINES); if (has_colors()) { start_color(); init_pair(0,COLOR_BLACK,COLOR_BLACK); init_pair(1,COLOR_BLUE,COLOR_BLACK); init_pair(2,COLOR_RED,COLOR_BLACK); init_pair(3,COLOR_MAGENTA,COLOR_BLACK); init_pair(4,COLOR_GREEN,COLOR_BLACK); init_pair(5,COLOR_CYAN,COLOR_BLACK); init_pair(6,COLOR_YELLOW,COLOR_BLACK); init_pair(7,COLOR_WHITE,COLOR_BLACK); } frames=0; cls(); while (true) { // doSummat(&lonewriteToPoint); cenx = COLS / 2; ceny = LINES / 2; swirlang = (float)frames * M_PI / 800.0; // Zooming in and out over time spacePerSwirl = 0.08+0.03*cos(0.000638*(float)frames); move(0,0); attrset(COLOR_PAIR(2) | A_BOLD); for (int y = 0;y<LINES;y++) { for (int x = 0;x<COLS;x++) { float swirlHeight=getSwirlHeight(x,y); { int c= ( getSwirlHeight(x+1,y+1) > 0 ? 1 : 0 ) + ( getSwirlHeight(x,y+1) > 0 ? 1 : 0 ) + ( getSwirlHeight(x+1,y) > 0 ? 1 : 0 ) + ( getSwirlHeight(x,y) > 0 ? 1 : 0 ) + ( getSwirlHeight((float)x+0.5,(float)y+0.5) > 0 ? 1 : 0 ); char ch = palette[c]; // mvaddch(y,x,32); addch(ch); } } } // int x = frames%COLS; // int y = (frames/COLS)%LINES; // move(y,x); // attrset(COLOR_PAIR(7)); // char *str; // sprintf(str," (- %i -) ",frames); // addstr(str); // printf("%i ",frames); // move(1,0); // attrset(COLOR_PAIR(0)); // printf("%i ",frames); wrefresh(stdscr); frames += 10; } cls(); // Needed endwin(); }