Esempio n. 1
0
File: nmm.c Progetto: ryanakca/nmm
/*
 * The Big Cheese
 */
int
main(int argc, char *argv[])
{
  scrgame *sg;
  int c;
  char *bn = basename(argv[0]);
  if (!bn || errno) {
    /* basename can return a NULL pointer, causing a segfault on
       strncmp below */
    errx(errno, "Something went wrong in determining the %s",
	 "filename by which nmm was called.");
  }
  if (argc != 1) {
    errx(EINVAL, "%s doesn't take any arguments.", bn);
  }
  if ((sg = malloc(sizeof(*sg)))) {
    if ((sg->game = malloc(sizeof(*sg->game)))) {
      point *board;
      if ((board = calloc(ROWS * COLS, sizeof(*board)))) {
	int r;
	for (r = 0; r < ROWS; r++) {
	  for (c = 0; c < COLS; c++) {
	    sg->game->board[r][c] = board++;
	  }
	}
      } else {
	errx(errno, "Unable to allocate memory for the board");
      }
    } else {
      errx(errno, "Unable to allocate memory for the game");
    }
  } else {
    errx(errno, "Unable to allocate memory");
  }
  initscr();
  cbreak();
  keypad(stdscr, TRUE);
  clear();
  printw("Display instructions? (y/n) ");
  refresh();
  c = getch();
  c = tolower(c);
  if (c == 'y') {
    printinstrs(sg);
  }
  clear();
  noecho();
  refresh();
  if (strncmp("tmm", bn, 3) == 0) {
    c = TMM;
  } else if (strncmp("twmm", bn, 4) == 0) {
    c = TWMM;
  } else {
    c = NMM;
  }
  for (;;) {
    initall(sg, c);
    refresh();
    phaseone(sg);
    phasetwothree(sg);
    if (!gameend(sg)) {
      break;
    }
  }
  refresh();
  endwin();
  return 0;
}
Esempio n. 2
0
int cargaNivel(int n_nivel, Nivel *nivel)
{

    int error = 1;

    char ruta_nivel[255];
    FILE *f_niveles;

    sprintf(ruta_nivel, "nivel%d.txt", n_nivel);
    printw("Cargando nivel: %s\n", ruta_nivel);

    f_niveles = fopen(ruta_nivel, "r");

    if(f_niveles != NULL)
    {

        int i = 0;

        void *mas_piedras;

        nivel->numero_nivel = n_nivel;

        nivel->piedras.lista = NULL;
        nivel->piedras.elementos = 0;



        nivel->diamantes.lista = NULL;
        nivel->diamantes.elementos = 0;
        void *mas_diamantes;

        fscanf(f_niveles,"posInicial_x = %4d", &nivel->posicioInicial.fila);
        fgetc(f_niveles); //Obtenemos el final de linea
        fscanf(f_niveles,"posInicial_y = %4d", &nivel->posicioInicial.columna);
        fgetc(f_niveles); //Obtenemos el final de linea
        fscanf(f_niveles,"diamantes_necesarios = %4d", &nivel->diamantes.elementos_necesarios);
        fgetc(f_niveles); //Obtenemos el final de linea
        fscanf(f_niveles,"posSalida_x = %4d", &nivel->posicioSortida.fila);
        fgetc(f_niveles); //Obtenemos el final de linea
        fscanf(f_niveles,"posSalida_y = %4d", &nivel->posicioSortida.columna);
        fgetc(f_niveles); //Obtenemos el final de linea
        fscanf(f_niveles,"puntosPorGanar = %4d", &nivel->puntosPorGanar);
        fgetc(f_niveles); //Obtenemos el final de linea


        printw("Posicion Inicial: X:%d Y:%d\n", nivel->posicioInicial.fila, nivel->posicioInicial.columna);

        while( !feof(f_niveles) )
        {
            fgets(nivel->caracteres[i], NIVEL_COLUMNAS + 1, f_niveles);
            fgetc(f_niveles); //Obtenemos el final de linea

            printw("Leido %d: %s\n", i, nivel->caracteres[i]);

            int j = 0;
            while(j<=NIVEL_COLUMNAS+1)
            {

                if(nivel->caracteres[i][j] == 'O')  //Es una pedra.
                {
                    printw("Piedra leida en la posicion: X:%d, Y:%d\n", i, j);
                    nivel->piedras.elementos++;

                    mas_piedras = realloc(nivel->piedras.lista, sizeof(Lista_Piedras) * (nivel->piedras.elementos) );

                    if(mas_piedras != NULL)
                    {
                        nivel->piedras.lista = mas_piedras;
                        nivel->piedras.lista[nivel->piedras.elementos-1].posicion.fila = i;
                        nivel->piedras.lista[nivel->piedras.elementos-1].posicion.columna = j;
                        nivel->piedras.lista[nivel->piedras.elementos-1].segunda_oportunidad = 1;
                        nivel->piedras.lista[nivel->piedras.elementos-1].direccion = 0;
                    }
                    else
                    {
                        free(nivel->piedras.lista);
                        printw("Error rehahuecando memoria para las piedras.\n");
                        exit(1);
                    }
                }

                if(nivel->caracteres[i][j] == 'V')  //Es un diamant.
                {
                    printw("Diamante leido en la posicion: X:%d, Y:%d\n", i, j);
                    nivel->diamantes.elementos++; // A1 - Al detectar el diamante se incrementa la cantidad ahora para que el realloc funcione correctamente.

                    mas_diamantes = realloc(nivel->diamantes.lista, sizeof(Lista_Diamantes) * nivel->diamantes.elementos);

                    if(mas_diamantes != NULL)
                    {
                        nivel->diamantes.lista = mas_diamantes;
                        nivel->diamantes.lista[nivel->diamantes.elementos-1].posicion.fila = i; //Ver A1 + y aqui le restamos 1 para que empieze en la posicion 0 del array.
                        nivel->diamantes.lista[nivel->diamantes.elementos-1].posicion.columna = j;
                        nivel->diamantes.lista[nivel->diamantes.elementos-1].eliminado = 0;
                    }
                    else
                    {
                        free(nivel->piedras.lista);
                        printw("Error rehahuecando memoria para los diamantes.\n");
                        exit(1);
                    }
                }

                j++;
            }

            i++;
        }

        fclose(f_niveles);
        error = 0;
    }

    mostrarDiamantesAlmacenados(nivel);
    mostrarPiedrasAlmacenadas(nivel);


    return error;
}
Esempio n. 3
0
int main()
{
	char label_text[LMAX][20] = { "I", "AM", "SAM", "DO",
								 "NOT", "LIKE", "THAT", "SAY",
								 "WOULD", "COULD", "YOU",
								 "GREEN EGGS AND HAM" };
	int label,ch;
	
	slk_init(2);					/* 12 soft labels */
	initscr();
	noecho();						/* disable key echoing */
	keypad(stdscr,TRUE);			/* Turn on Fkey reading */
	
/* display the labels and instructions */
	for(label=0;label<LMAX;label++)
		slk_set(label+1,label_text[label],CENTER);
	slk_refresh();
	addstr("Use the Function Keys to type\n");
	addstr("Press '?' or '!' or '.' to end a line\n");
	addstr("Press Enter to quit\n\n");
	refresh();

/* Process input */
	while( (ch=getch()) != '\n')
	{
		switch(ch)
		{
				case '?':
				case '!':
				case '.':
					addch(ch);
					addch('\n');
					break;
				case KEY_F(1):
					printw("%s ",label_text[0]);
					break;
				case KEY_F(2):
					printw("%s ",label_text[1]);
					break;
				case KEY_F(3):
					printw("%s ",label_text[2]);
					break;
				case KEY_F(4):
					printw("%s ",label_text[3]);
					break;
				case KEY_F(5):
					printw("%s ",label_text[4]);
					break;
				case KEY_F(6):
					printw("%s ",label_text[5]);
					break;
				case KEY_F(7):
					printw("%s ",label_text[6]);
					break;
				case KEY_F(8):
					printw("%s ",label_text[7]);
					break;
				case KEY_F(9):
					printw("%s ",label_text[8]);
					break;
				case KEY_F(10):
					printw("%s ",label_text[9]);
					break;
				case KEY_F(11):
					printw("%s ",label_text[10]);
					break;
				case KEY_F(12):
					printw("%s ",label_text[11]);
					break;
				default:
					break;
		}
		refresh();
	}

	endwin();
	return 0;
}
Esempio n. 4
0
int
main (int argc, char **argv)
{
	int     i,l;		/* non-descript indices */
	char    c;		/* non-descript character storage */

	if (pledge("stdio rpath wpath cpath tty exec", NULL) == -1)
		err(1, "pledge");

	signal(SIGINT, getout);	/* trap interrupts */

	/* use whole screen for text */
	begscr = 0;

	getarg(argc, argv);

	initcurses();

	/* check if restored game and save flag for later */
	if ((rfl = rflag)) {
		if (pledge("stdio rpath wpath cpath tty", NULL) == -1)
			err(1, "pledge");

		wrboard();	/* print board */
		/* if new game, pretend to be a non-restored game */
		if (cturn == 0)
			rflag = 0;
	} else {
		rscore = wscore = 0;	/* zero score */

		if (aflag) {	/* print rules */
			addstr(rules);
			if (yorn(0)) {
				endwin();
				execl(TEACH, "teachgammon", (char *)NULL);

				err(1, "%s", noteach);
			} else {/* if not rules, then instructions */
				addstr(need);
				if (yorn(0)) {	/* print instructions */
					clear();
					text(instruct);
				}
			}
		}

		if (pledge("stdio rpath wpath cpath tty", NULL) == -1)
			err(1, "pledge");

		init();		/* initialize board */

		if (pnum == 2) {/* ask for color(s) */
			printw("\n%s", askcol);
			while (pnum == 2) {
				c = readc();
				switch (c) {

				case 'R':	/* red */
					pnum = -1;
					break;

				case 'W':	/* white */
					pnum = 1;
					break;

				case 'B':	/* both */
					pnum = 0;
					break;

				case 'P':	/* Control the dice */
					iroll = 1;
					addstr("\nDice controlled!\n");
					addstr(askcol);
					break;

				default:	/* error */
					beep();
				}
			}
		}

		wrboard();		/* print board */

		move(18, 0);
	}
	/* limit text to bottom of screen */
	begscr = 17;

	for (;;)  {			/* begin game! */
		/* initial roll if needed */
		if ((!rflag) || raflag)
			roll();

		/* perform ritual of first roll */
		if (!rflag) {
			move(17, 0);
			while (D0 == D1)	/* no doubles */
				roll();

			/* print rolls */
			printw("%s%d%s%d", rollr, D0, rollw, D1);

			/* winner goes first */
			if (D0 > D1) {
				addstr(rstart);
				cturn = 1;
			} else {
				addstr(wstart);
				cturn = -1;
			}
		}
		/* initialize variables according to whose turn it is */

		if (cturn == 1) {	/* red */
			home = 25;
			bar = 0;
			inptr = &in[1];
			inopp = &in[0];
			offptr = &off[1];
			offopp = &off[0];
			Colorptr = &color[1];
			colorptr = &color[3];
			colen = 3;
		} else {		/* white */
			home = 0;
			bar = 25;
			inptr = &in[0];
			inopp = &in[1];
			offptr = &off[0];
			offopp = &off[1];
			Colorptr = &color[0];
			colorptr = &color[2];
			colen = 5;
		}

		/* do first move (special case) */
		if (!(rflag && raflag)) {
			if (cturn == pnum)	/* computer's move */
				domove(0);
			else {	/* player's move */
				mvlim = movallow();
				/* reprint roll */
				move(cturn == -1 ? 18 : 19, 0);
				proll();
				getmove();	/* get player's move */
			}
		}
		move(17, 0);
		clrtoeol();
		begscr = 18;
		/* no longer any difference between normal and recovered game. */
		rflag = 0;

		/* move as long as it's someone's turn */
		while (cturn == 1 || cturn == -1) {

			/* board maintainence */
			moveplayers();	/* fix board */

			/* do computer's move */
			if (cturn == pnum) {
				domove(1);

				/* see if double refused */
				if (cturn == -2 || cturn == 2)
					break;

				/* check for winning move */
				if (*offopp == 15) {
					cturn *= -2;
					break;
				}
				continue;

			}
			/* (player's move) */

			/* clean screen if safe */
			if (hflag) {
				move(20, 0);
				clrtobot();
				hflag = 1;
			}
			/* if allowed, give him a chance to double */
			if (dflag && dlast != cturn && gvalue < 64) {
				move(cturn == -1 ? 18: 19, 0);
				addstr(*Colorptr);
				c = readc();

				/* character cases */
				switch (c) {

				case 'R':		/* reprint board */
					wrboard();
					break;

				case 'S':		/* save game */
					raflag = 1;
					save(1);
					break;

				case 'Q':		/* quit */
					quit();
					break;

				case 'D':		/* double */
					dble();
					break;

				case ' ':		/* roll */
				case '\n':
					roll();
					printw(" rolls %d %d.  ", D0, D1);

					/* see if he can move */
					if ((mvlim = movallow()) == 0) {

						/* can't move */
						printw("%s%s%s", toobad1, *colorptr, unable);
						if (pnum) {
							moveplayers();
							sleep(MVPAUSE);
						}
						nexturn();
						break;
					}

					getmove();

					/* okay to clean screen */
					hflag = 1;
					break;

				default:		/* invalid character */

					/* print help message */
					move(20, 0);
					text(helpm);
					move(cturn == -1 ? 18 : 19, 0);

					/* don't erase */
					hflag = 0;
				}
			} else {/* couldn't double */

				/* print roll */
				roll();
				move(cturn == -1 ? 18: 19, 0);
				proll();

				/* can he move? */
				if ((mvlim = movallow()) == 0) {

					/* he can't */
					printw("%s%s%s", toobad2, *colorptr, cantmv);
					moveplayers();
					sleep(MVPAUSE);
					nexturn();
					continue;
				}

				getmove();
			}
		}

		/* don't worry about who won if quit */
		if (cturn == 0)
			break;

		/* fix cturn = winner */
		cturn /= -2;

		/* final board pos. */
		moveplayers();

		/* backgammon? */
		mflag = 0;
		l = bar + 7 * cturn;
		for (i = bar; i != l; i += cturn)
			if (board[i] * cturn)
				mflag++;

		/* compute game value */
		move(20, 0);
		if (*offopp == 15) {
			if (mflag) {
				addstr(bgammon);
				gvalue *= 3;
			}
			else if (*offptr <= 0) {
				addstr(gammon);
				gvalue *= 2;
			}
		}
		/* report situation */
		if (cturn == -1) {
			addstr("Red wins ");
			rscore += gvalue;
		} else {
			addstr("White wins ");
			wscore += gvalue;
		}
		printw("%d point%s.\n", gvalue, (gvalue > 1) ? "s":"");

		/* write score */
		wrscore();

		/* see if he wants another game */
		addstr(again);
		if ((i = yorn('S')) == 0)
			break;

		init();
		if (i == 2) {
			addstr("  Save.\n");
			cturn = 0;
			save(0);
		}
		/* yes, reset game */
		wrboard();
	}

	/* give him a chance to save if game was recovered */
	if (rfl && cturn) {
		addstr(svpromt);
		if (yorn(0)) {
			/* re-initialize for recovery */
			init();
			cturn = 0;
			save(0);
		}
	}
	/* leave peacefully */
	getout(0);
	/* NOT REACHED */
}
Esempio n. 5
0
int
main(int argc, char *argv[])
{
    int ch;
    int which = 0;
    int last;
    bool replaying = FALSE;
    bool done = FALSE;
    char **files;

    while ((ch = getopt(argc, argv, "ir")) != -1) {
	switch (ch) {
	case 'i':
	    use_init = TRUE;
	    break;
	case 'r':
	    replaying = TRUE;
	    break;
	default:
	    usage();
	    break;
	}
    }

    initscr();
    cbreak();
    noecho();
    keypad(stdscr, TRUE);
    curs_set(0);
    if (has_colors()) {
	start_color();
	for (ch = 0; ch < COLOR_PAIRS; ++ch) {
	    short pair = ch % COLOR_PAIRS;
	    init_pair(pair, COLOR_WHITE, ch % COLORS);
	}
    }

    files = argv + optind;
    last = argc - optind - 1;
    if (replaying) {

	/*
	 * Use the last file as the initial/current screen.
	 */
	if (last < 0) {
	    endwin();
	    printf("No screen-dumps given\n");
	    ExitProgram(EXIT_FAILURE);
	}

	which = last;
	if (load_screen(files[which]) == ERR) {
	    endwin();
	    printf("Cannot load screen-dump %s\n", files[which]);
	    ExitProgram(EXIT_FAILURE);
	}
	after_load();

	while (!done && (ch = getch()) != ERR) {
	    switch (ch) {
	    case 'n':
		/*
		 * If we got a "next" here, skip to the final screen before
		 * moving to the next process.
		 */
		setup_next();
		which = last;
		done = TRUE;
		break;
	    case 'q':
		endwin();
		cleanup(files);
		done = TRUE;
		break;
	    case KEY_BACKSPACE:
	    case '\b':
		if (--which < 0)
		    which = last;
		break;
	    case ' ':
		if (++which > last)
		    which = 0;
		break;
	    default:
		beep();
		continue;
	    }

	    if (ch == 'q') {
		;
	    } else if (scr_restore(files[which]) == ERR) {
		endwin();
		printf("Cannot load screen-dump %s\n", files[which]);
		cleanup(files);
		ExitProgram(EXIT_FAILURE);
	    } else {
		wrefresh(curscr);
	    }
	}
    } else {
	int y;
	int x;

	move(2, 0);
	printw("Use h,j,k,l or arrows to move around the screen\n");
	printw("Press 'q' to quit, ' ' to dump a screen\n");
	printw("When the last screen has been dumped, press 'n' to run the\n");
	printw("screen-loader.  That allows only 'q', backspace and ' ' for\n");
	printw("stepping through the dumped/restored screens.\n");
	getyx(stdscr, y, x);

	while (!done) {
	    switch (ch = get_command(which, last)) {
	    case 'n':
		setup_next();
		done = TRUE;
		break;
	    case 'q':
		endwin();
		cleanup(files);
		done = TRUE;
		break;
	    case ' ':
		if (files[which] != 0) {
		    show_what(which + 1, last);
		    if (scr_dump(files[which]) == ERR) {
			endwin();
			printf("Cannot write screen-dump %s\n", files[which]);
			cleanup(files);
			done = TRUE;
			break;
		    }
		    ++which;
		    if (has_colors()) {
			short pair = which % COLOR_PAIRS;
			bkgd(COLOR_PAIR(pair));
		    }
		} else {
		    beep();
		}
		break;
	    case KEY_LEFT:
	    case 'h':
		if (--x < 0)
		    x = COLS - 1;
		break;
	    case KEY_DOWN:
	    case 'j':
		if (++y >= LINES)
		    y = 1;
		break;
	    case KEY_UP:
	    case 'k':
		if (--y < 1)
		    y = LINES - 1;
		break;
	    case KEY_RIGHT:
	    case 'l':
		if (++x >= COLS)
		    x = 0;
		break;
	    }
	    if (!done) {
		time_t now = time((time_t *) 0);

		move(0, 0);
		addstr(ctime(&now));
		move(y, x);
		addch('#' | A_REVERSE);
		move(y, x);
	    }
	}
    }
    ExitProgram(EXIT_SUCCESS);
}
Esempio n. 6
0
void game_loop( RubikCube & cube, std::string & args ) {
	int ch;
	bool doSolve = false;

	// Main loop
	while (42) {
		// Read Input (Also calls refresh)
		// refresh();
		ch = getch();
		// clear();

		// if (ch == KEY_LEFT) {
		if (ch == 'q' || ch == 'Q') {
			break;
		} else if (ch == 'w') { cube[0].rotate_c();  args.append(" U");  // UP C
		} else if (ch == 'e') { cube[0].rotate_cc(); args.append(" U'"); // UP CC
		} else if (ch == 'r') { cube[0].rotate_2();  args.append(" U2"); // UP 180
		} else if (ch == 'a') { cube[4].rotate_c();  args.append(" F");  // FRONT C
		} else if (ch == 's') { cube[4].rotate_cc(); args.append(" F'"); // FRONT CC
		} else if (ch == 'd') { cube[4].rotate_2();  args.append(" F2"); // FRONT 180
		} else if (ch == 'z') { cube[3].rotate_c();  args.append(" R");  // RIGHT C
		} else if (ch == 'x') { cube[3].rotate_cc(); args.append(" R'"); // RIGHT CC
		} else if (ch == 'c') { cube[3].rotate_2();  args.append(" R2"); // RIGHT 180
		} else if (ch == 't') { cube[5].rotate_c();  args.append(" B");  // BACK C
		} else if (ch == 'y') { cube[5].rotate_cc(); args.append(" B'"); // BACK CC
		} else if (ch == 'u') { cube[5].rotate_2();  args.append(" B2"); // BACK 180
		} else if (ch == 'g') { cube[2].rotate_c();  args.append(" L");  // LEFT C
		} else if (ch == 'h') { cube[2].rotate_cc(); args.append(" L'"); // LEFT CC
		} else if (ch == 'j') { cube[2].rotate_2();  args.append(" L2"); // LEFT 180
		} else if (ch == 'v') { cube[1].rotate_c();  args.append(" D");  // DOWN C
		} else if (ch == 'b') { cube[1].rotate_cc(); args.append(" D'"); // DOWN CC
		} else if (ch == 'n') { cube[1].rotate_2();  args.append(" D2"); // DOWN 180
		} else if (ch == ' ') {
			doSolve = true;
			break;
		}
		draw_screen(args, cube, "");
	}
	if (doSolve) {
		clock_t loop_time = 400000;
		clock_t loop_start_time = clockToUseconds(clock());
		std::string solution = solve(cube.getMikeFormat());
		std::string solution_buffer;
		std::string cmd;
		std::size_t pos;
		while (42) {
			ch = getch();
			if (ch == 'q' || ch == 'Q')
				break;
			// Timing
			if (clockToUseconds(clock()) - loop_start_time < loop_time)
				continue;
			loop_start_time = clockToUseconds(clock());
			// Solution
			pos = solution.find_first_of(" \n");
			cmd = solution.substr(0, pos);
			cube.apply(cmd);
			solution_buffer += ' ';
			solution_buffer += cmd;
			if (pos != std::string::npos) ++pos;
			solution.erase(0, pos);
			draw_screen(args, cube, solution_buffer);
			if (solution.size() == 0)
				break;
		}
		attron(COLOR_PAIR(1));
		attron(A_BOLD);
		printw("\nPress Q to Quit");
		attroff(A_BOLD);
		attroff(COLOR_PAIR(1));
		while (42) {
			nodelay(stdscr, FALSE);
			ch = getch();
			if (ch == 'q' || ch == 'Q')
				break;
		}
	}
}
Esempio n. 7
0
File: wan.c Progetto: Skuzzzy/wan
int main (int argc, char *argv[])
{
    setup();

    printw("%d row\n%d col\n", row, col);

    char ch = ' ';
    int x = 0, y = 0;
    while(ch != CTRLD)
    {
        move(y, x);
        ch = getch();
        switch(ch){
            case 27:
                ch = getch();
                ch = getch();
                switch(ch){
                    case 68: // Left
                        x -= 1;
                        break;
                    case 65: // Up
                        y -= 1;
                        break;
                    case 67: // Right
                        x += 1;
                        break;
                    case 66: // Down
                        y += 1;
                        break;
                }
                /*printw("TEST", ch);*/
                break;
            case 10: // Newline
                x = 0;
                y += 1;
                break;
            case 127: // Backspace

                if (y == 0 && x == 0)
                {
                    break;
                }

                x -= 1;
                if(x < 0)
                {
                    x = col - 1;
                    y -= 1;
                }
                mvaddch(y, x, ' ');
                break;
            default:
                /*move(0,0);*/
                /*printw("%d", ch);*/
                /*mvaddch(y, x, ch);*/
                mvaddch(y, x, ch);
                refresh();
                x += 1;
                if( x >= col )
                {
                    x = 0;
                    y += 1;
                }
                break;
        }

    }

    teardown();
}
Esempio n. 8
0
static void
display_data(int colors) {
	char cur_time[20];
	struct tm *tm_time;
	time_t epoc_time;
	size_t counter, line;
	long long r,w;
	unsigned long long rt, wt;
	sg_disk_io_stats *disk_io_stat_ptr;
	sg_network_io_stats *network_stat_ptr;
	sg_fs_stats *disk_stat_ptr;
	/* Size before it will start overwriting "uptime" */
	char hostname[15];
	char *ptr;

	if (stats.host_info != NULL) {
		move(0,12);
		strncpy(hostname, stats.host_info->hostname, (sizeof(hostname) - 1));
		/* strncpy does not NULL terminate.. If only strlcpy was on all platforms :) */
		hostname[14] = '\0';
		ptr=strchr(hostname, '.');
		/* Some hosts give back a FQDN for hostname. To avoid this, we'll
		 * just blank out everything after the first "."
		 */
		if (ptr != NULL){
			*ptr = '\0';
		}
		if (colors) {
			attron(COLOR_PAIR(1));
		}
		printw("%s", hostname);
		move(0,36);
		printw("%s", hr_uptime(stats.host_info->uptime));
		epoc_time=time(NULL);
		tm_time = localtime(&epoc_time);
		strftime(cur_time, 20, "%Y-%m-%d %T", tm_time);
		move(0,61);
		printw("%s", cur_time);
		if (colors) {
			attroff(COLOR_PAIR(1));
		}
	}

	if (stats.load_stats != NULL) {
		/* Load */
		if (colors) {
			attron(COLOR_PAIR(6));
		}
		move(2,12);
		if (colors && fabs(stats.load_stats->min1 - stats.load_stats->min5) > THRESHOLD_LOAD) {
			attron(A_BOLD);
		}
		printw("%6.2f", stats.load_stats->min1);
		if (colors) {
			attroff(A_BOLD);
		}
		move(3,12);
		if (colors && fabs(stats.load_stats->min5 - stats.load_stats->min15) > THRESHOLD_LOAD) {
			attron(A_BOLD);
		}
		printw("%6.2f", stats.load_stats->min5);
		if (colors) {
			attroff(A_BOLD);
		}
		move(4,12);
		if (colors && fabs(stats.load_stats->min1 - stats.load_stats->min15) > THRESHOLD_LOAD) {
			attron(A_BOLD);
		}
		printw("%6.2f", stats.load_stats->min15);
		if (colors) {
			attroff(A_BOLD);
		}
	}

	if (stats.cpu_percents != NULL) {
		/* CPU */
		move(2,33);
		printw("%6.2f%%", stats.cpu_percents->idle);
		move(3,33);
		printw("%6.2f%%", (stats.cpu_percents->kernel + stats.cpu_percents->iowait + stats.cpu_percents->swap));
		move(4,33);
		if (colors && stats.cpu_percents->user + stats.cpu_percents->nice > THRESHOLD_ALERT_CPU) {
			attron(A_STANDOUT);
			attron(A_BOLD);
		}
		else if (colors && stats.cpu_percents->user + stats.cpu_percents->nice > THRESHOLD_WARN_CPU) {
			attron(A_BOLD);
		}
		printw("%6.2f%%", (stats.cpu_percents->user + stats.cpu_percents->nice));
		if(colors) {
			attroff(A_BOLD);
			attroff(A_STANDOUT);
			attron(COLOR_PAIR(6));
		}
	}

	if (stats.process_count != NULL) {
		/* Process */
		move(2, 54);
		printw("%5llu", stats.process_count->running);
		move(2,74);
		if (colors && stats.process_count->zombie > THRESHOLD_WARN_ZMB) {
			attron(A_STANDOUT);
			attron(A_BOLD);
		}
		printw("%5llu", stats.process_count->zombie);
		if(colors) {
			attroff(A_STANDOUT);
			attroff(A_BOLD);
		}
		move(3, 54);
		printw("%5llu", stats.process_count->sleeping);
		move(3, 74);
		printw("%5llu", stats.process_count->total);
		move(4, 54);
		printw("%5llu", stats.process_count->stopped);
	}
	if (stats.user_stats != NULL) {
		move(4,74);
		printw("%5lu", stats.user_entries);
	}

	if(colors) {
		attroff(COLOR_PAIR(6));
		attron(COLOR_PAIR(5));
	}
	if (stats.mem_stats != NULL) {
		/* Mem */
		move(6, 12);
		printw("%7s", size_conv(stats.mem_stats->total));
		move(7, 12);
		printw("%7s", size_conv(stats.mem_stats->used));
		move(8, 12);
		printw("%7s", size_conv(stats.mem_stats->free));
	}

	if (stats.swap_stats != NULL) {
		/* Swap */
		move(6, 32);
		printw("%8s", size_conv(stats.swap_stats->total));
		move(7, 32);
		printw("%8s", size_conv(stats.swap_stats->used));
		move(8, 32);
		printw("%8s", size_conv(stats.swap_stats->free));
	}

	/* VM */
	if (stats.mem_stats != NULL && stats.mem_stats->total != 0) {
		float f = 100.00 * (float)(stats.mem_stats->used)/stats.mem_stats->total;
		if (colors && f > THRESHOLD_ALERT_MEM) {
			attron(A_STANDOUT);
			attron(A_BOLD);
		}
		else if (colors && f > THRESHOLD_WARN_MEM) {
			attron(A_BOLD);
		}
		move(6, 54);
		printw("%5.2f%%", f);
		if (colors) {
			attroff(A_STANDOUT);
			attroff(A_BOLD);
			attron(COLOR_PAIR(5));
		}
	}
	if (stats.swap_stats != NULL && stats.swap_stats->total != 0) {
		float f = 100.00 * (float)(stats.swap_stats->used)/stats.swap_stats->total;
		if (colors && f > THRESHOLD_ALERT_SWAP) {
			attron(A_STANDOUT);
			attron(A_BOLD);
		}
		else if (colors && f > THRESHOLD_WARN_SWAP) {
			attron(A_BOLD);
		}
		move(7, 54);
		printw("%5.2f%%", f);
		if (colors) {
			attroff(A_STANDOUT);
			attroff(A_BOLD);
			attron(COLOR_PAIR(5));
		}
	}
	if (stats.mem_stats != NULL && stats.swap_stats != NULL &&
	    stats.mem_stats->total != 0 && stats.swap_stats->total != 0) {
		move(8, 54);
		printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used+stats.swap_stats->used)/(stats.mem_stats->total+stats.swap_stats->total)));
	}

	if (stats.page_stats != NULL) {
		/* Paging */
		move(6, 74);
		printw("%5llu", (stats.page_stats->systime)? (stats.page_stats->pages_pagein / stats.page_stats->systime): stats.page_stats->pages_pagein);
		move(7, 74);
		printw("%5llu", (stats.page_stats->systime)? (stats.page_stats->pages_pageout / stats.page_stats->systime) : stats.page_stats->pages_pageout);
	}
	if (colors) {
		attroff(COLOR_PAIR(5));
	}

	line = 11;
	if (stats.disk_io_stats != NULL) {
		/* Disk IO */
		disk_io_stat_ptr = stats.disk_io_stats;
		r=0;
		w=0;
		for(counter=0;counter<stats.disk_io_entries;counter++){
			char name[12];
			strncpy(name, disk_io_stat_ptr->disk_name, sizeof(name));
			name[sizeof(name)-1] = '\0'; /* strncpy doesn't terminate longer strings */
			move(line, 0);
			printw("%s", name);
			move(line, 12);
			rt = (disk_io_stat_ptr->systime)? (disk_io_stat_ptr->read_bytes/disk_io_stat_ptr->systime): disk_io_stat_ptr->read_bytes;
			if(colors) {
				attron(COLOR_PAIR(4));
			}
			printw("%7s", size_conv(rt));
			r+=rt;
			move(line, 26);
			wt = (disk_io_stat_ptr->systime)? (disk_io_stat_ptr->write_bytes/disk_io_stat_ptr->systime): disk_io_stat_ptr->write_bytes;
			printw("%7s", size_conv(wt));
			w+=wt;
			disk_io_stat_ptr++;
			line++;
			if(colors) {
				attroff(COLOR_PAIR(4));
			}
		}
		line++;
		move(line, 0);
		printw("Total");
		move(line, 12);
		if(colors) {
			attron(COLOR_PAIR(4));
		}
		printw("%7s", size_conv(r));
		move(line, 26);
		printw("%7s", size_conv(w));
		if(colors) {
			attroff(COLOR_PAIR(4));
		}
	}

	line = 11;
	if (stats.network_io_stats != NULL) {
		/* Network */
		network_stat_ptr = stats.network_io_stats;
		for(counter=0;counter<stats.network_io_entries;counter++){
			char name[20];
			strncpy(name, network_stat_ptr->interface_name, sizeof(name));
			name[sizeof(name)-1] = '\0'; /* strncpy doesn't terminate longer strings */
			move(line, 42);
			printw("%s", name);
			move(line, 62);
			rt = (network_stat_ptr->systime)? (network_stat_ptr->rx / network_stat_ptr->systime): network_stat_ptr->rx;
			if(colors) {
				attron(COLOR_PAIR(4));
			}
			printw("%7s", size_conv(rt));
			move(line, 72);
			wt = (network_stat_ptr->systime)? (network_stat_ptr->tx / network_stat_ptr->systime): network_stat_ptr->tx;
			printw("%7s", size_conv(wt));
			network_stat_ptr++;
			line++;
			if(colors) {
				attroff(COLOR_PAIR(4));
			}
		}
		line += 2;
	}

	if (stats.fs_stats != NULL) {
		/* Disk */
		disk_stat_ptr = stats.fs_stats;
		for(counter=0;counter<stats.fs_entries;counter++){
			char name[20];
			strncpy(name, disk_stat_ptr->mnt_point, sizeof(name));
			name[sizeof(name)-1] = '\0'; /* strncpy doesn't terminate longer strings */
			move(line, 42);
			printw("%s", name);
			move(line, 62);
			if(colors) {
				attron(COLOR_PAIR(2));
			}
			printw("%7s", size_conv(disk_stat_ptr->avail));
			move(line, 73);
			if(colors && 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)) > THRESHOLD_ALERT_DISK) {
				attron(A_STANDOUT);
				attron(A_BOLD);
			} else if (colors && 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)) > THRESHOLD_WARN_DISK) {
				attron(A_BOLD);
			}
			printw("%6.2f%%", 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)));
			disk_stat_ptr++;
			line++;
			if(colors) {
				attroff(COLOR_PAIR(2));
				attroff(A_STANDOUT);
				attroff(A_BOLD);
			}
		}
	}

	refresh();
}
Esempio n. 9
0
File: mode4.c Progetto: DaElf/aldl
void m4_draw_cmd(int xpos, int ypos) {
  move(ypos,xpos); 
  int x;
  for(x=0;x<16;x++) printw("%X ",(unsigned int)mfb[x]);
}
Esempio n. 10
0
				viewkill()
/*              Просмотр списка процессов и посылка сигналов
/****************************************************************************/
{
extern  int     use_keycap;     /* признак использования своей настройки на клавиатуру */
extern  int     use_colors;     /* признак использования цветов */
extern  WINDOW  *save_scr;      /* окно для сохранения экрана */
extern  int     nosave_ask;     /* признак "несохранения" экрана для ask */
extern  chtype  atr[];          /* раскраска */
extern unsigned char *fnd_str;  /* строка для временных данных */
extern  size_t  fnd_len;        /* место, выделенное для fnd_str*/
static  char    *dmenu="1+      - 2+      - 3+Next  - 4+      - 5+      - 6+User  - 7+Search- 8+Kill  - 9+SigNum- 10+Quit ";
static  char    *name="/tmp/ps_text_XXXXXX";
extern  struct  win     win71;  /* окно с запросом */
extern  struct  win     win72;  /* окно с ошибкой */
extern  struct  win     win73;  /* запрос номера посылаемого сигнала */
extern  struct  win     win75;  /* запрос имени пользователя */
extern  char    user_name[LOGNM_MAX]; /* имя пользователя */
extern  uid_t   user_eid;       /* эффективный UserID или 0, если getuid()==0*/
	FILE    *file=NULL;
	int     stop=0;         /*признак окончания просмотра */
	int     ch;
	long    nextseek;       /* смещение на следующий экран*/
	int     x;
	int     y;
	int     x_beg=0;        /* сдвиг выводимой части текста */
	int     lines=LINES-3;    /* количество строк для вывода */
	long    firstline=0;    /* номер первой выводимой строки файла*/
	int     find;           /* признак поиска */
	long    srchlnseek;     /* смещение до начала строки при поиске*/
	long    srchseek;       /* смещение до символа после первого совпадения*/
	long    srchseeklast=(-1);/* смещение предыдущего поиска */
	int     srchln;         /* номер строки при поиске */
	int     old_nosave;     /* станое значение nosave_ask */
	int     i;
	int     fd;             /* дескриптор файла со списком процессов */
	int     len;            /* максимальная длина выводимой части имени*/
	int     need_refr=1;    /* признак необходимости перевывода списка*/
	char    *ptr;           /* имя файла для вывода ошибки и для прохода по шаблону */
 struct inp_lst inp_lst[2];     /* список ввода для inp_menu()*/
 struct inp_lst usr_inp_lst[2]; /* список ввода для inp_menu()*/
extern  long    linesback();    /* поиск смещения в файле на несколько строк назад */
	long    *seeks=NULL;    /* массив смещений в списке процессов*/
	long    seeks_len=0;    /* количество элементов в seeks */
	char    *stats=NULL;    /* признаки отметки */
	int     nlines=1;       /* количество строк в файле списка процессов*/
	int     curline=0;      /* номер текущей строки */
	long    nproc;          /* номер процесса */
static  int     sig=15;         /* номер сигнала */
static  char    usr_str[30]={'\0'};/* строка с именем пользователя для ps(1)*/
	char    *tmp_first;     /* для запоминания первой строки*/
	int     pos;            /* для работы с tmp_first */
	int     next_srch=0;    /* признак продолжения поиска без запроса */
/*==========================================================================*/
tmp_first=malloc(COLS);
tst_err_malloc(tmp_first,27); /* выполняет exit, если NULL*/

/* обычным пользователям по умолчанию показывать только свои */
if(user_eid && !usr_str[0]){
  strncpy(usr_str, user_name, sizeof(usr_str));
  usr_str[sizeof(usr_str)-1]='\0';
}

usr_inp_lst[0].str=usr_str;
/* usr_inp_lst[0].fld_len=...;  выставит inp_menu()*/
usr_inp_lst[0].str_len=sizeof(usr_str);
usr_inp_lst[0].npunkt=1;
usr_inp_lst[1].str=NULL; /* признак конца списка для inp_menu()*/

inp_lst[0].str=(char *)fnd_str;
/* inp_lst[0].fld_len=...;  выставит inp_menu()*/
inp_lst[0].str_len=fnd_len;
inp_lst[0].npunkt=1;
inp_lst[1].str=NULL; /* признак конца списка для inp_menu()*/

mktemp(name);

old_nosave=nosave_ask;
nosave_ask=1;
if(old_nosave==0){
  delsoob();
  overwrite(curscr, save_scr);
}

attrset(MAIN_PANEL_ATTR);
mywbkgd(stdscr, MAIN_PANEL_ATTR);
move(0,0);
addch(' ');
refresh();
clear();

#ifdef NCURSES
mywbkgd(stdscr, MAIN_PANEL_ATTR);
#endif

move(0,0);
addch(' ');

attrset(MAIN_PANEL_ATTR);
mywbkgd(stdscr, MAIN_PANEL_ATTR);
refresh();

len=strlen(name);
stop=0;
while(!stop){
  if(need_refr){
    need_refr=0;
    if(file) fclose(file);
    switch(fork())
      {
	case -1:
	  endwin();
	  fprintf(stderr, "Can't fork\n");
	  exit(-1);
	break;
	case 0: /* порожденный процесс*/
	  fd=creat(name, 0777);
	  if(fd<=0){
	    endwin();
	    fprintf(stderr, "Can't create file %s\n", name);
	    exit(-1);
	  }
	  dup2(fd, 1);
	  dup2(fd, 2);
#ifdef FREEBSD
	      execlp("ps", "ps", "-awwxo", "user pid ppid stat start tty command", NULL);
#else
	  if(usr_str[0])
	    { /* задано имя пользователя для которого смотрятся процессы */
	      execlp("ps", "ps", "-f", "-u", usr_str, NULL);
	    }else{
	      execlp("ps", "ps", "-ef", NULL);
	    }
#endif
	  fprintf(stderr, "Can't exec to ps\n");
	  exit(-1);
	break;

	default:
	  wait(NULL);
	break;
      }


    if(!(file=fopen(name, "r"))) { /* не открывается файл */
	endwin();
	fprintf(stderr, "Can't open file %s\n", name);
	exit(-1);
    }

    i=1;
    pos=0;
    /* первую строку читаем в tmp_first */
    do{
      if( (tmp_first[pos] = getc(file)) == '\n')
	{
	  i++;
	}else{
	  if(pos<COLS-1 && !feof(file)) pos++;
	}
    }while(i==1 && !feof(file));
    tmp_first[pos] = '\0';

    while(!feof(file)){
      if(getc(file)=='\n') i++;
    }
    nlines=i-2;

    if(i>seeks_len){
      if(seeks_len){
	free(seeks);
	free(stats);
      }
      seeks_len=i-1;
      seeks=malloc((i-1)*sizeof(long));
      tst_err_malloc(seeks,25); /* выполняет exit, если NULL*/
      stats=malloc((i-1)*sizeof(char));
      tst_err_malloc(stats,26); /* выполняет exit, если NULL*/
    }
    rewind(file);
    i=0;
    while(!feof(file)){
      if(getc(file)=='\n'){
	seeks[i]=ftell(file);
	stats[i]='\0';
	i++;
      }
    }
    /* проверить корректность текущей строки и первой строки */
    if(curline>nlines-1){
      curline=nlines-1;
      if(curline<firstline) firstline=curline;
    }

  }

  mywbkgd(stdscr, MAIN_PANEL_ATTR);
  /* Заголовок просмотра */
  attrset(MAIN_PANEL_TOP_ATTR);
  move(0,0);
  if(x_beg){
    printw("  Shift: %d", x_beg);
  }
  if(firstline>=0)
    { /* известен номер первой строки*/
      printw(" Line: %d", curline+1);
    }else{
      printw(" Line: ?");
    }
  if(usr_str[0])
    { /* показываются процессы выбранного пользователя*/
      addstr("  User: "******"  All users");
    }
  getyx(stdscr, y, x);
  while(x++<COLS) addch(' ');

  attrset(MAIN_PANEL_ATTR);


  /* вывод первой строки */
  move(FIRST-1, 0);
  addstr(tmp_first);

  fseek(file, seeks[firstline], 0);

  y=FIRST;

  while(feof(file)==0 && ferror(file)==0 && y<FIRST+lines){
    x=0;
    if(y-FIRST==curline-firstline) attrset(MAIN_PANEL_PTR_ATTR);
    do{
      ch=getc(file);
      if(feof(file)==0 && ferror(file)==0){
	if((x-x_beg)==COLS)
	  {
	    attrset(MAIN_PANEL_PTR_ATTR);
	    move(y, COLS-1);
	    addch('>');
	    attrset(MAIN_PANEL_ATTR);
	  }else{
	    if(ch=='\t'){
	      x=((x+8)/8)*8-1;
	      ch=' ';
	    }
	    if((x-x_beg)<COLS && ch!='\n'){
	      if(x>=x_beg){
		move(y, (x-x_beg));
		if(ch<' ' || ch==0177)
		  {
		    attrset(MAIN_PANEL_PTR_ATTR);
		    ch=CTRL(ch) +'@';
		    addch(ch);
		    attrset(MAIN_PANEL_ATTR);
		  }else{
		    addch(ch);
		  }
	      }
	    }
	  }
	x++;
      }
    }while(ch!='\n' && feof(file)==0 && ferror(file)==0);
    if(y-FIRST==curline-firstline){ /*дописать конец текущей строки*/
      if(x) x--; /* при выводе в конце цикла x++ */
      if(x<x_beg) { /* эта строка при таком смещении совсем не выводилась*/
	x=x_beg;
      }
      x-=x_beg; /* теперь это координата в окне */
      move(y, x);
      while(x<COLS){
	addch(' ');
	x++;
      }
      attrset(MAIN_PANEL_ATTR);
    }
    y++;
  }

  /* нарисовать строку с клавишами */
  move(LINES-1, 0);
  attrset(BOTT_LINE_KEYS_ATTR);
  for(ptr=dmenu;*ptr;ptr++){
    switch(*ptr)
      {
	case '+':
	  attrset(BOTT_LINE_TEXT_ATTR);
	break;
	case '-':
	  attrset(BOTT_LINE_KEYS_ATTR);
	break;
	default:
	  addch(*ptr);
	break;
      }
  }

  refresh();

  if(ferror(file))
    { /* такое бывает с Symlink на каталог */
      ch=ESC;
    }else{
      if(use_keycap)
	{ /*использовать свою настройку на клавиатуру */
	  ch=getkey_();
	}else{ /* использовать стандартные средства curses */
	  ch=getch();
	}
    }
  switch(ch)
    {
      case K_SD:  /*стрелка вниз*/
      case KEY_DOWN:  /*стрелка вниз*/
	srchseeklast=(-1);
	if(curline<nlines-1){
	  curline++;
	  if(curline>firstline+lines-1) firstline++;
	}
      break;


      case K_SU:    /*стрелка вверх*/
      case KEY_UP:    /*стрелка вверх*/
	srchseeklast=(-1);
	if(curline>0) curline--;
	if(curline<firstline) firstline--;
      break;

      case K_PAGE_UP:
      case KEY_PPAGE:
	srchseeklast=(-1);
	if(curline>0){
	  curline-=lines-2;
	  if(curline<0) curline=0;

	  firstline-=lines-2;
	  if(firstline<0) firstline=0;
	}
      break;

      case K_PAGE_DN:
      case KEY_NPAGE:
	srchseeklast=(-1);
	if(curline<nlines-1){
	  curline+=lines-2;
	  if(curline>nlines-1) curline=nlines-1;

	  firstline+=lines-2;
	  if(firstline>nlines-(lines-2)) firstline=nlines-(lines-2);
	  if(firstline<0) firstline=0;
	}
      break;

      case K_HOME:
      case KEY_HOME:
	srchseeklast=(-1);
	curline=0;
	firstline=0;
      break;

      case K_END:
      case KEY_END:
	  srchseeklast=(-1);
	  curline=nlines-1;
	  firstline=nlines-(lines-2);
	  if(firstline<0) firstline=0;
      break;

      case K_SR:      /* Стрелка вправо */
      case KEY_RIGHT: /* Стрелка вправо */
	srchseeklast=(-1);
	x_beg++;
      break;

      case K_SL:      /* Стрелка влево */
      case KEY_LEFT:  /* Стрелка влево */
	srchseeklast=(-1);
	if(x_beg) x_beg--;
      break;

      case K_F6:      /* User */
      case KEY_F(6):
	if(inp_menu(usr_inp_lst, &win75, 1, 0)==1 && usr_str[0])
	  {
	    /* нужно только usr_str[0] */
	  }else{
	    usr_str[0] = '\0';
	  }
	srchseeklast=(-1);
	curline=0;
	firstline=0;
	need_refr++;
      break;


      case K_F3:      /* продолжение поиска */
      case KEY_F(3):
	next_srch=1;
      case K_F7:      /* поиск */
      case KEY_F(7):
	if( (next_srch && fnd_str[0]) ||
	    (inp_menu(inp_lst, &win71, 1, 0)==1 && fnd_str[0])){

	  srchlnseek=seeks[curline];
	  srchln=curline+1;
	  find=0;
	  fseek(file, srchlnseek, 0);
	  while(feof(file)==0 && ferror(file)==0 && find==0){
	    ch=getc(file);
	    if(!feof(file)){

	      if(ch=='\n'){
		srchln++;
		srchlnseek=ftell(file);
	      }
	      if( cmp_chrs(ch, fnd_str[0], 0)==0 ){
		srchseek=ftell(file);
		ptr=(char*)fnd_str;
		if(srchseeklast<srchseek){  /* -1 или предыдущий */
		  while(feof(file)==0 && *ptr && cmp_chrs(ch, *ptr, 0)==0 ){
		    ch=getc(file);
		    ptr++;
		  }
		}
		if(*ptr=='\0')
		  { /* полное соответствие */
		    find=1;
		    if(srchseek-srchlnseek>=COLS-2)
		      { /* образец не виден на экране */
			x_beg=srchseek-srchlnseek-(COLS/2);
		      }else{
			x_beg=0;
		      }
		    srchseeklast=srchseek;
		    curline=srchln-1;
		    if(curline>firstline+lines-1 || curline<firstline) firstline=curline;

		  }else{ /* несоответствие в каком-то (не первом) символе*/
		    fseek(file, srchseek, 0); /* продолжить поиск с места, где найден совпад.символ*/
		  }
	      }
	    }
	  }
	  if(!find){
	    ask(&win72, 2, 0);
	  }
	}
	next_srch=0;
      break;

      case K_F8:      /* посылка сигнала */
      case KEY_F(8):
	need_refr++;

	fseek(file, seeks[curline], 0);

	do{ /* пропустить ведущие пробелы*/
	  ch=getc(file);
	}while(isspace(ch) && feof(file)==0 && ch!='\n');

	/* пропустить имя пользователя */
	while(isspace(ch)==0 && feof(file)==0 && ch!='\n'){
	  ch=getc(file);
	}

	/* пропустить пробелы после имени */
	while(isspace(ch) && feof(file)==0 && ch!='\n'){
	  ch=getc(file);
	}

	if(isdigit(ch) && feof(file)==0 && ch!='\n')
	  { /* действительно какой-то номер */
	    fseek(file, -1L, 1); /* вернуться на символ назад */
	    nproc=(-1);
	    fscanf(file,"%ld", &nproc);
	    if(nproc>=0 && nproc!=getpid())
	      {
		if(kill((pid_t)nproc, sig)) beep();
	      }else{
		beep();
		beep();
		beep();
	      }
	  }else{
	    beep();
	    beep();
	    beep();
	  }
      break;

      case K_F9:      /* посылка сигнала */
      case KEY_F(9):
	if((i=ask(&win73, sig, VERT))>0) sig=i;
      break;

      case K_ESC:       /*конец работы*/
      case ESC:         /*конец работы*/
      case K_F0:
      case KEY_F(0):
	stop++;
      break;

      case K_REFRESH: /* клавиша перевывода экрана */
      case REFRESH:   /* клавиша перевывода экрана */
	clearok(stdscr, TRUE);
      case REREAD:    /* клавиша пересчитывания каталога */
      case K_REREAD:
	need_refr++;
      break;

      default:
	beep();
      break;
    }

} /* while !stop */

fclose(file);
unlink(name);

mywbkgd(stdscr, A_NORMAL);
wattrset(stdscr, A_NORMAL);
/* #ifdef sun */
/* из-зи ошибок в curses или в описании терминала очистка вып-ся не тем цветом*/
move(0,0);
addch(' ');
refresh();
/* #endif */
clear();

#ifdef NCURSES
mywbkgd(stdscr, MAIN_PANEL_ATTR);
#endif

refresh();
overwrite(save_scr, stdscr);
#ifdef FREEBSD
touchwin(stdscr);
#endif
clearok(stdscr, TRUE);
refresh();
if(old_nosave==0) nosave_ask=0;

if(seeks_len){
  free(seeks);
  free(stats);
}
free(tmp_first);
}
Esempio n. 11
0
static void
display_headings(void) {
	int line;

	move(0,0);
	printw("Hostname  :");
	move(0,27);
	printw("Uptime : ");
	move(0,54);
	printw("Date : ");

	/* Load */
	move(2,0);
	printw("Load 1    :");
	move(3,0);
	printw("Load 5    :");
	move(4,0);
	printw("Load 15   :");

	/* CPU */
	move(2,21);
	printw("CPU Idle  :");
	move(3,21);
	printw("CPU System:");
	move(4,21);
	printw("CPU User  :"******"Running   :");
	move(3, 42);
	printw("Sleeping  :");
	move(4, 42);
	printw("Stopped   :");
	move(2, 62);
	printw("Zombie    :");
	move(3, 62);
	printw("Total     :");
	move(4, 62);
	printw("No. Users :");

	/* Mem */
	move(6, 0);
	printw("Mem Total :");
	move(7, 0);
	printw("Mem Used  :");
	move(8, 0);
	printw("Mem Free  :");

	/* Swap */
	move(6, 21);
	printw("Swap Total:");
	move(7, 21);
	printw("Swap Used :");
	move(8, 21);
	printw("Swap Free :");

	/* VM */
	move(6, 42);
	printw("Mem Used  :");
	move(7, 42);
	printw("Swap Used :");
	move(8, 42);
	printw("Total Used:");

	/* Paging */
	move(6, 62);
	printw("Paging in :");
	move(7, 62);
	printw("Paging out:");

	/* Disk IO */
	move(10,0);
	printw("Disk Name");
	move(10,15);
	printw("Read");
	move(10,28);
	printw("Write");

	line = 10;
	if (stats.network_io_stats != NULL) {
		/* Network IO */
		move(line, 42);
		printw("Network Interface");
		move(line, 67);
		printw("rx");
		move(line, 77);
		printw("tx");
		line += 2 + stats.network_io_entries;
	}

	move(line, 42);
	printw("Mount Point");
	move(line, 65);
	printw("Free");
	move(line, 75);
	printw("Used");

	refresh();
}
int control_orientation_update(desCntrl_T & desCntrl, motInfo & mot, const double & curTime)
{

  
  //static gazebo::math::Quaternion quarDes; 
  //const gazebo::msgs::IMU & IMU_data_ptr
  static pidInfo motRoll; 	// X
  static pidInfo motYaw;	// Z
  static pidInfo motPitch;	// Y
  static double prevTime = 0;
  double dt;
  double tMult;
  double errYawLim = 0.1;
  
  dt = curTime - prevTime;
  //update_orientation();
  
  //quarDes.SetFromEuler(0,0,0);
  
  tMult = std::sqrt( std::pow(desCntrl.thrust,2) + std::pow(body_orientation.x,2) + std::pow(body_orientation.y,2));
  
  desCntrl.errRoll  = desCntrl.roll  - body_orientation.GetRoll();
  desCntrl.errPitch = desCntrl.pitch - body_orientation.GetPitch();
  desCntrl.errYaw   = desCntrl.yaw   - body_orientation.GetYaw();

//#warning "Yaw Hack In Place!"
//  desCntrl.errYaw = 0; // Yaw Hack
  
  if (desCntrl.errYaw > errYawLim)
  {
    desCntrl.errYaw = errYawLim;
  }
  else if (desCntrl.errYaw < -1*errYawLim)
  {
    desCntrl.errYaw = -1*errYawLim;
  }
  
  //clear();
  mvprintw(0,0,"Yaw: %f\n",body_orientation.GetYaw());
  printw("errYaw: %f\n",desCntrl.errYaw);
  refresh();
  //vecDes.
  
//  motRoll.curVal = -1*motRoll.kp*IMU_data_ptr->angular_velocity().x() + 
//		   -1*motRoll.ki*(IMU_data_ptr->angular_velocity().x()*dt + motRoll.preVal) +
//		   -1*motRoll.kd*(IMU_data_ptr->angular_velocity().x() - motRoll.preVal)/dt;
  
//   motRoll.curVal = 100*motRoll.kp*(desCntrl->errRoll);// + 
		   //motRoll.ki*(IMU_data_ptr->angular_velocity().x()*dt + motRoll.preVal) +
		   //motRoll.kd*(IMU_data_ptr->angular_velocity().x() - motRoll.preVal)/dt;
  
//  motPitch.curVal = -1*motPitch.kp*IMU_data_ptr->angular_velocity().y() + 
//		   -1*motPitch.ki*(IMU_data_ptr->angular_velocity().y()*dt + motPitch.preVal) +
//		   -1*motPitch.kd*(IMU_data_ptr->angular_velocity().y() - motPitch.preVal)/dt; 
//		   
//  motYaw.curVal = -1*motYaw.kp*IMU_data_ptr->angular_velocity().z() + 
//		   -1*motYaw.ki*(IMU_data_ptr->angular_velocity().z()*dt + motYaw.preVal) +
//		   -1*motYaw.kd*(IMU_data_ptr->angular_velocity().z() - motYaw.preVal)/dt;
//		   
 
  // Calc integral
  motRoll.intSum  = motRoll.intSum  + desCntrl.errRoll*dt;
  motPitch.intSum = motPitch.intSum + desCntrl.errPitch*dt;
  motYaw.intSum   = motYaw.intSum   + desCntrl.errYaw*dt;

  // Calc Derivative
  motRoll.derDiff  = (desCntrl.errRoll  - motRoll.preVal)/dt;
  motPitch.derDiff = (desCntrl.errPitch - motPitch.preVal)/dt;
  motYaw.derDiff   = (desCntrl.errYaw   - motYaw.preVal)/dt;
  
  motRoll.curVal  = 1*0.1*4*(50*motRoll.kp*(desCntrl.errRoll)   + 0*10*motRoll.ki*motRoll.intSum   + 0*3*10*motRoll.kd*motRoll.derDiff);
  motPitch.curVal = 1*0.1*4*(50*motPitch.kp*(desCntrl.errPitch) + 0*10*motPitch.ki*motPitch.intSum + 0*3*10*motPitch.kd*motPitch.derDiff);
  motYaw.curVal   = 2*0.1*.05*(50*motYaw.kp*(desCntrl.errYaw)   + 0*10*motYaw.ki*motYaw.intSum     + 0*10*motYaw.kd*motYaw.derDiff);
  
  // Save err values
  motRoll.preVal  = desCntrl.errRoll;
  motPitch.preVal = desCntrl.errPitch;
  motYaw.preVal   = desCntrl.errYaw;
  
  
//     ^x
//     |	
// y <-oz
//
//     2
//     |
// 4---+---3
//     |
//     1
//
// + Roll -> -y -> -M3, +M4
// + Pitch -> +x -> -M2, +M1
// + Yaw -> CC
  
  mot.mot1 = 1 * tMult +  0 * motRoll.curVal + 	1 * motYaw.curVal +  1 * motPitch.curVal;
  mot.mot3 = 1 * tMult + -1 * motRoll.curVal + -1 * motYaw.curVal +  0 * motPitch.curVal;
  mot.mot2 = 1 * tMult +  0 * motRoll.curVal +  1 * motYaw.curVal + -1 * motPitch.curVal;
  mot.mot4 = 1 * tMult +  1 * motRoll.curVal + -1 * motYaw.curVal +  0 * motPitch.curVal;
  
  if(mot.mot1 < 0)
  {
    mot.mot1 = 0;
  }
  
  if(mot.mot2 < 0)
  {
    mot.mot2 = 0;
  }
  
  if(mot.mot3 < 0)
  {
    mot.mot3 = 0;
  }
  
  if(mot.mot4 < 0)
  {
    mot.mot4 = 0;
  }
    
  return 0;  

}
Esempio n. 13
0
void start(std::string filename, bool saveprog, bool savestats,bool usetree)
{
	if(!progrunning)
		return;

	clear();

	Textstream ts;
	ts.open_file(filename);
	if(saveprog)
		ts.loadposition();

	Wordtree errortree;
	std::string treefilename="wordstat.stat";
	
	if(usetree)
		errortree.restorefromFile(treefilename);

	//Variables
	bool timerunning = false;

	int keystrokes = 0;
	int wrongstrokes = 0;
	std::chrono::high_resolution_clock::time_point starttime;
	std::chrono::high_resolution_clock::time_point curtime;
	int elapsedseconds = 0;
	float keysperminute = 0.0;
	float errorpercent = 0.0;

	Intstring line;
	int clength = 0;
	int tprog = 0;
	bool * correctness = new bool;
	bool lastwordwrong = false;
	std::string typedword;

	int yval = 0;

	std::mutex printingmutex;

	//Lambdas
	auto add_widech = [&](int c){
		char bytes[5];
		for(unsigned char a = 0; a < 5 ; ++a)
			bytes[a] = 0;

		felocale::to_utf8(c,bytes);
		printw(bytes);
	};

	auto updatestates = [&](){
		if(timerunning)
		{
			curtime = std::chrono::high_resolution_clock::now();
			elapsedseconds = std::chrono::duration_cast <std::chrono::seconds> (curtime - starttime) .count();
		}
		if(elapsedseconds > 0)
			keysperminute = (((double)keystrokes) * 60 / ((double)elapsedseconds));
		errorpercent = (float)(wrongstrokes * 100) / (float)keystrokes;
	};

	auto printstatus = [&](){
		printingmutex.lock();
		if(timerunning)
		{
			updatestates();
			move(0,0);
			clrtoeol();
			std::string s = "Seconds elapsed: "+std::to_string(elapsedseconds)+" Error Ratio:"+std::to_string(errorpercent)+'%'
			+" Keystrokes per Minutes:"+std::to_string(keysperminute);
			mvprintw(0,0,s.c_str());
		}
		else
		{
			mvprintw(0,0,"Begin Typing to start the time measurement....");
		}
		refresh();
		printingmutex.unlock();
	};

	auto nextline = [&](){
		clear();
		std::string tstring = ts.nextline();
		line = tstring;
		if(line.empty()){
			clear();
			mvprintw(1,0,"You reached The End of the line...");
			printstatus();
			timerunning = false;
			progrunning = false;
		}
		else
		{
			if(clength < line.length())
			{
				delete[] correctness;
				correctness = new bool [line.length()];
				clength = line.length();
			}
			tprog = 0;
			yval = 2;
		}
	};

	auto printline = [&](){
		if( !progrunning )
			return;
		
		printingmutex.lock();
		move(yval,0);
		int x;
		for(x = 0; x < tprog; ++x)
		{
			color_set(1,0);
			if(!correctness[x])
				color_set(3,0);
			add_widech(line.at(x));
		}
		if(x < line.length())
		{
			color_set(2,0);
			add_widech(line.at(x));
			++x;
		}
		color_set(1,0);
		for(; x < line.length();++x)
			add_widech(line.at(x));

		//Add a pilcrow at the end
		if(tprog == line.length())
			color_set(2,0);

		add_widech(0xb6);

		color_set(1,0);
		printingmutex.unlock();
	};

	auto doscreen = [&](){
		printstatus();
		printline();
		refresh();
	};

	auto feedtree = [&](int c){
		//Do the wordtree magic
		if(usetree)
		{
			if(line.at(tprog) == ' ' || tprog == line.length())
			{
				Intstring* word = line.getWordBefore(tprog);
				std::string uword = felocale::convertstring(*word);
				if(lastwordwrong)
					errortree.insertError(uword,typedword);
				else
					errortree.insert(uword);
				typedword.clear();
				lastwordwrong=false;
				delete word;
			}
			else if(c != 0){
				char bytes[5];
				for(unsigned char d = 0; d < 5; ++d)
					bytes[d] = 0;
				char count = felocale::to_utf8(c,bytes);
				for(unsigned char a = 0; a < count; ++a)
					typedword.append(bytes);
			}
		}
	};

	auto comparechar = [&](int c){
		feedtree(c);
		++keystrokes;
		if(tprog == line.length())
			return;

		if(c == line.at(tprog))
			correctness[tprog] = true;
		else{
			lastwordwrong = true;
			correctness[tprog] = false;
			++wrongstrokes;
		}

		++tprog;
	};

	auto get_widech = [&]() {

		int a = getch();

		//UNICODE char!
		if( (a & 0x80) == 0x80)
		{
			int c = 0;

			char bytecount = 0;
			char marker = 0x40;
			while ((a & marker) == marker)
			{
				marker >>= 1;
				++bytecount;
			}

			//move the bits from the first byte over
			char cm = 1;
			char mask = 0;
			while(cm != marker)
			{
				mask |= cm;
				cm <<= 1; 
			}
			c |= (a & mask);

			//move the remaining bytes in.
			//the length is cut appropiately
			for(int a = 0; a<bytecount; ++a)
			{
				c <<= 6;
				c |= (getch() & 0x3f);
			}
			a = c;
		}
		return a;
	};
Esempio n. 14
0
void playerDie(player* pl, player* w){
    printw("You are dead\n");
    endGame(pl, w);
}
Esempio n. 15
0
static cb_ret_t
layout_callback (struct Dlg_head *h, dlg_msg_t msg, int parm)
{
    switch (msg) {
    case DLG_DRAW:
    	/*When repainting the whole dialog (e.g. with C-l) we have to
    	  update everything*/
	common_dialog_repaint (h);

   	old_first_panel_size = -1;
    	old_horizontal_split = -1;
    	old_output_lines     = -1;

	attrset (COLOR_HOT_NORMAL);
	update_split ();
	dlg_move (h, 6, 13);
	addch ('=');
	if (console_flag){
	    if (old_output_lines != _output_lines){
		old_output_lines = _output_lines;
		attrset (COLOR_NORMAL);
		dlg_move (h, 9, 16 + first_width);
		addstr (output_lines_label);
		dlg_move (h, 9, 10 + first_width);
		printw ("%02d", _output_lines);
	    }
	}
	return MSG_HANDLED;

    case DLG_POST_KEY:
	_filetype_mode = check_options [8].widget->state & C_BOOL;
	_permission_mode = check_options [7].widget->state & C_BOOL;
	_equal_split = check_options [6].widget->state & C_BOOL;
/* 	_menubar_visible = check_options [5].widget->state & C_BOOL; */
/* 	_command_prompt = check_options [4].widget->state & C_BOOL; */
/* 	_keybar_visible = check_options [2].widget->state & C_BOOL; */
	_message_visible = check_options [1].widget->state & C_BOOL;
/* 	_xterm_title = check_options [0].widget->state & C_BOOL; */
	if (console_flag){
	    int minimum;
	    if (_output_lines < 0)
		_output_lines = 0;
	    height = LINES - _keybar_visible - _command_prompt -
		     _menubar_visible - _output_lines - _message_visible;
	    minimum = MINHEIGHT * (1 + _horizontal_split);
	    if (height < minimum){
		_output_lines -= minimum - height;
		height = minimum;
	    }
	} else {
	    height = LINES - _keybar_visible - _command_prompt -
		_menubar_visible - _output_lines - _message_visible;
	}
	if (_horizontal_split != radio_widget->sel){
	    _horizontal_split = radio_widget->sel;
	    if (_horizontal_split)
		_first_panel_size = height / 2;
	    else
		_first_panel_size = COLS / 2;
	}
	update_split ();
	if (console_flag){
	    if (old_output_lines != _output_lines){
		old_output_lines = _output_lines;
		attrset (COLOR_NORMAL);
		dlg_move (h, 9, 10 + first_width);
		printw ("%02d", _output_lines);
	    }
	}
	return MSG_HANDLED;

    default:
	return default_dlg_callback (h, msg, parm);
    }
}
Esempio n. 16
0
void FileBrowser::FileBrowserWindow::showWelcomeScreen()
{
    move(y / 2, x / 2);
    printw("WELCOME");
    refresh();
}
Esempio n. 17
0
File: main.c Progetto: SGOrava/Miny
int main (void) {
	/*
	 * Defimovanie lokálnych premenných funkcie
	 */

	WINDOW *my_win, *info_win, *smyle_win;
	int startx, starty, w_width, w_height;
	int width, height;
	int poloha_x, poloha_y;
	int old_x, old_y;
	int oznacil;
	short zacal;
	int min;
	int ch;
	char *dopln;
	int i, j, u, z;
	//long start_time, end_time;

	/* Inicializovanie/zapnutie curses módu */
	initscr();

	/* inicializácie konfigurácie */
	config_init();


	/* Kontrola či terminál podporuje farby */
	if (has_colors() == FALSE) {
		endwin();

		printf("Vas terminal nepodporuje farby!\n");

		exit(1);
	}


	/*
	 * Aktivácia pomocných funkcií pre curses mód
	 *
	 * raw - vypnutie bufferovania riadkov (disable line buffering)
	 *
	 * noecho 		- po stlačení kláves sa nebudú vypisovať
	 * curs_set 	- vypnutie kurzoru (schovanie)
	 * start_color 	- zapnutie podpory farieb
	 * keypad 		- aktivácia F kláves (F1, F2...)
	 */

	raw();
	cbreak();
	noecho();
	//nodelay(stdscr, true);
	curs_set(0);
	use_default_colors();
	start_color();
	keypad(stdscr, TRUE);

	/* Inicializovanie generátoru náhodných čísel */
	srand(time(0));


	/*
	 * Inicializovanie párov farieb
	 *
	 * 0	- základný systémový/všeobecný
	 * 1	- zvýraznenie vybraného políčka
	 * 2	- farba neuhádnutej míny
	 * 3	- farba uhádnutej míny
	 * 4	- farba zle označenej míny
	 *
	 * 5	- farba čísla 1
	 * 6	- farba čísla 2
	 * 7	- farba čísla 3
	 * 8	- farba čísla 4
	 * 9	- farba čísla 5
	 * 10	- farba čísla 6
	 * 11	- farba čísla 7
	 * 12	- farba čísla 8
	 */
	init_pair(1, COLOR_WHITE, COLOR_RED);
	init_pair(2, COLOR_YELLOW, COLOR_DEFAULT);
	init_pair(3, COLOR_GREEN, COLOR_DEFAULT);
	init_pair(4, COLOR_RED, COLOR_DEFAULT);

	init_pair(5, COLOR_BLUE, COLOR_DEFAULT);
	init_pair(6, COLOR_GREEN, COLOR_DEFAULT);
	init_pair(7, COLOR_RED, COLOR_DEFAULT);
	init_pair(8, COLOR_CYAN, COLOR_DEFAULT);
	init_pair(9, COLOR_MAGENTA, COLOR_DEFAULT);
	init_pair(10, COLOR_YELLOW, COLOR_DEFAULT);
	init_pair(11, COLOR_BLACK, COLOR_DEFAULT);
	init_pair(12, COLOR_WHITE, COLOR_DEFAULT);


	/* definícia menovky restart, sem sa presunieme pomocou goto pre reštart hry */
	restart:


	/* Zistí rozmery terminálu */
	getmaxyx(stdscr, row, col);


	/* Priradenie hodnôt premenným */
	min = miny_config.miny;
	width = 30;
	height = 16;
	w_height = height + 2;
	w_width = width + 2;
	oznacil = 0;
	poloha_x = 1;
	poloha_y = 1;
	zacal = 0;
	//start_time = time(NULL);
	//end_time = 0;


	/* Pridelenie pamate podľa konfigurácie */
	pridel_pamet(width, height);


	/* Vynulovanie hodnôt v poliach... */
	for (i = 0; i < width; i++) {
		for (j = 0; j < height; j++) {
			min_pole[i][j] = 0;
			uhadol[i][j] = 0;
			pole_hodnot[i][j] = 0;
		}
	}

	/* vycentruje hru na obrazovke */
	if (miny_config.vycentruj == 1) {
		starty = (row - w_height) / 2;
		startx = (col - (w_width * 2 + 2)) / 2;
	} else {
	/* položí na ľavú stranu a mierne odsadí od okrajov */
		starty = 1;
		startx = 2;
	}


	/* Vypísať na reálnu obrazovku (Print to real screen) */
	refresh();


	printw("Copyright © 2013 Juraj Oravec\n");

	/* Vytvorenie curses "okien" */
	my_win = create_newwin(w_height, w_width, starty, startx);
	info_win = create_newwin(w_height, w_width, starty, startx + 34);
	smyle_win = create_newwin(6, 10, starty + 11, startx + 34 + 12);

	/* "odstránenie" rámiku okolo okna so smajlíkom */
	wborder(smyle_win, ' ', ' ', ' ',' ',' ',' ',' ',' ');
	wrefresh(smyle_win);


	/* Výpis do informačného okna */
	mvwprintw(info_win, 1, (w_width - strlen(NAZOV)) / 2, NAZOV);
	mvwprintw(info_win, 3, 2, "Pocet min: %d", min);
		wattron(info_win, A_BOLD);
			mvwprintw(info_win, 3, 25, " 0/%d", min);
		wattroff(info_win, A_BOLD);
	mvwprintw(info_win, 4, 2, "Minove pole: %d x %d", width, height);

	/* vypísať polohu kurzoru len ak je to povolené v konfigurácii */
	if (miny_config.info_poloha == 1)
		mvwprintw(info_win, 5, 2, "Poloha kurzoru: X: %d, Y: %d", poloha_x, poloha_y);



	/* Refresh/Obnova informačného okna, aby sa zobrazilo čo sme vypoísali */
	wrefresh(info_win);

	/* Zobrazenie smajlíka */
	smajlik_init(smyle_win);

	/*
	 * vyber_min -> Základná poloha kurzoru v ľavom hornom rohu
	 * mini_rozhadz -> Náhodne rozmiestni míny po hracom poli
	 */
	vyber_min(my_win, width, height, poloha_x, poloha_y, 0, 0);

	mini_rozhadz(0, width, height, min);


	/*
	 * Nekonečný cyklus pre zisťovanie stlačenia kláves
	 * Program sa ukonćí funkciou exit() po stlačení 'q'
	 */

	while ( ( ch = getch() ) ) {
		/* Uloženie starej polohy kurzoru pre ďalśie spracovanie */
		old_x = poloha_x;
		old_y = poloha_y;


		/*
		 * switch/prepínač pre "kontrolu" stlačených kláves
		 * a podľa toho vykoná nejakú akciu...
		 */

		switch (ch) {
			/*
			 * Stlačenie šípky vľavo,
			 * nasleduje posun kurzoru vľavo, ak je to možné
			 */
			case KEY_LEFT:
				if (hra == 1) {
					if (poloha_x > 1)
						poloha_x--;
				}
			break;

			/*
			 * Stlačenie šípky vpravo,
			 * nasleduje posun kurzoru vpravo, ak je to možné
			 */
			case KEY_RIGHT:
				if (hra == 1) {
					if (poloha_x < width)
						poloha_x++;
				}
			break;

			/*
			 * Stlačenie šípky hore,
			 * nasleduje posun kurzoru hore, ak je to možné
			 */
			case KEY_UP:
				if (hra == 1) {
					if (poloha_y > 1)
						poloha_y--;
				}
			break;

			/*
			 * Stlačenie šípky dole,
			 * nasleduje posun kurzoru dole, ak je to možné
			 */
			case KEY_DOWN:
				if (hra == 1) {
					if (poloha_y < height)
						poloha_y++;
				}
			break;

			case 'a':
				/*
				 * Nástroj pre programátora, testera...
				 * označí všetky prázdne polia v hre
				 */
				if (miny_config.vyvojar == 1) {
					for (u = 0; u < width; u++)
						for (z = 0; z < height; z++) {
							if (min_pole[u][z] == 0)
								vyber_dopln((u + 1), (z + 1), width, height, my_win);
						}

					wrefresh(my_win);
				}
			break;

			/* Označenie míny */
			case 'm':
				if (hra == 1) {
					/* Kontrola neoznaćeného políčka */
					if (uhadol[(poloha_x - 1)][(poloha_y - 1)] != 1  &&  uhadol[(poloha_x - 1)][(poloha_y - 1)] != 2) {
						/* Vypísanie označenia míny, refresh hracieho poľa, uloženie označenia */

						mvwprintw(my_win, poloha_y, poloha_x, "*");
						wrefresh(my_win);

						uhadol[(poloha_x - 1)][(poloha_y - 1)] = 2;


						oznacil++;

						vypis_oznacene(info_win, oznacil, min);
					} else if (uhadol[(poloha_x - 1)][(poloha_y - 1)] == 2) {
						/* Ak je mína už označená tak bude označenie zrušené */

						mvwprintw(my_win, poloha_y, poloha_x, " ");
						wrefresh(my_win);

						uhadol[(poloha_x - 1)][(poloha_y - 1)] = 0;


						oznacil--;

						vypis_oznacene(info_win, oznacil, min);
					}
				}
			break;

			/* Ukončenie programu s kódom 0 - správne ukončenie */
			case 'q':
				endwin();

				exit(0);
			break;

			/* reštartovanie hry */
			case 'r':
				if (miny_config.vyvojar == 1) {
					/* príprava na reštart... */
					restart_prepare (my_win, info_win, smyle_win, width, height);

					/* prestavenie identifikátoru stavu hry na play/hrať/1/OK... */
					hra = 1;

					/* preskočenie na menovku restart */
					goto restart;
				}
			break;

			/* Medzera - Výber políčka na hracom poli */
			case ' ':
				if (hra == 1) {
					/*
					 * Pokiaľ je aktívna voľba cisty_start tak sa bude mínové pole generovař pokiaľ
					 * na daných súradniciach bude mína, keď nebude, tak prestane.
					 */
					if (miny_config.cisty_start == 1  &&  zacal == 0) {
						if (miny_config.nulovy_start == 1) {
							while (TRUE) {
								for (u = 0; u < width; u++) {
									for (z = 0; z < height; z++) {
										/* Vymazanie mín z hracieho poľa */
										min_pole[u][z] = 0;
									}
								}

								mini_rozhadz(0, width, height, min);

								if (min_okolo(poloha_x, poloha_y, width, height) == 0  &&  min_pole[(poloha_x - 1)][(poloha_y - 1)] == 0)
									break;
							}
						} else if (min_pole[(poloha_x - 1)][(poloha_y - 1)] == 1) {
							while (TRUE) {
								for (u = 0; u < width; u++) {
									for (z = 0; z < height; z++) {
										/* Vymazanie mín z hracieho poľa */
										min_pole[u][z] = 0;
									}
								}

								mini_rozhadz(0, width, height, min);

								if (min_pole[(poloha_x - 1)][(poloha_y - 1)] == 0)
									break;
							}
						}

						zacal = 1;
					}


					/* Ak trafil na mínu */
					if (min_pole[(poloha_x - 1)][(poloha_y - 1)] == 1) {
						if (uhadol[(poloha_x - 1)][(poloha_y - 1)] == 0) {
							/* zobrazí všetky míny, vypíše zásah */
							mini_zobraz(my_win, width, height);

							/* Zobrazí smutného smajlíka */
							smajlik (smyle_win, 2);

							/* zastaví hru, teda zmení stav na koniec/stop/KO/... */
							hra = 0;
						}
					} else {
						/*
						 * Ak trafil na prázdne pole
						 * vypíše koľko mín sa nachádza v okolí toho poľa
						 */
						vyber_dopln(poloha_x, poloha_y, width, height, my_win);

						/* Refresh okien */
						/*wrefresh(info_win);*/
						wrefresh(my_win);

						/* kontrola dokončenia hry */
						if (dokoncil(width, height) == 1) {
							/* ak boli označené všetky "prázdne polia" vypíše všetky míny na zeleno, správne vyplnenie.. */
							mini_zobraz(my_win, width, height);

							oznacil = min;

							vypis_oznacene(info_win, oznacil, min);

							//end_time = time(NULL);

							hra = 0;
						}
					}
				} else if (hra == 0) {
					/* príprava na reštart... */
					restart_prepare (my_win, info_win, smyle_win, width, height);

					/* prestavenie identifikátoru stavu hry na play/hrať/1/OK... */
					hra = 1;
					zacal = 0;

					/* preskočenie na menovku restart */
					goto restart;
				}
			break;
		}

		/* Posunutie kurzora, ak sa zmenila jeho poloha */
		if (poloha_x != old_x || poloha_y != old_y)
			vyber_min(my_win, width, height, poloha_x, poloha_y, old_x, old_y);


		/* pokiaľ je aktívne vypisovanie polohy... */
		if (miny_config.info_poloha == 1) {
			/* Doplnenie prázdneho miesta za súradnice kurzoru */
			if (poloha_x < 10  &&  poloha_y < 10)
				dopln = "  ";
			else if (poloha_x < 10  ||  poloha_y < 10)
				dopln = " ";

			/* Výpis polohy kurzoru */
			mvwprintw(info_win, 5, 2, "Poloha kurzoru: X: %d, Y: %d%s", poloha_x, poloha_y, dopln);
		}

		/* refreš info okna */
		wrefresh(info_win);
	}

	/* Ukončenie curses modu */
	endwin();

	/* Ukončenie programu */
	return 0;
}
Esempio n. 18
0
void resize_handler(int sig)
{
	printw("window resized\n");
	refresh();
}
Esempio n. 19
0
/**
 * Process events, with optional wait
 */
static errr Term_xtra_gcu_event(int v) {
	int i, j, k, mods=0;

	if (v) {
		/* Wait for a keypress; use halfdelay(1) so if the user takes more */
		/* than 0.2 seconds we get a chance to do updates. */
		halfdelay(2);
		i = getch();
		while (i == ERR) {
			i = getch();
			idle_update();
		}
		cbreak();
	} else {
		/* Do not wait for it */
		nodelay(stdscr, true);

		/* Check for keypresses */
		i = getch();

		/* Wait for it next time */
		nodelay(stdscr, false);

		/* None ready */
		if (i == ERR) return (1);
		if (i == EOF) return (1);
	}

	/* Not sure if this is portable to non-ncurses platforms */
	#ifdef USE_NCURSES
	if (i == KEY_RESIZE) {
		/* wait until we go one second (10 deci-seconds) before actually
		 * doing the resizing. users often end up triggering multiple
		 * KEY_RESIZE events while changing window size. */
		halfdelay(10);
		do {
			i = getch();
		} while (i == KEY_RESIZE);
		cbreak();
		do_gcu_resize();
		if (i == ERR) return (1);
	}
	#endif

	/* uncomment to debug keycode issues */
	#if 0
	printw("key %d", i);
	wrefresh(stdscr);
	#endif

	/* This might be a bad idea, but...
	 *
	 * Here we try to second-guess ncurses. In some cases, keypad() mode will
	 * fail to translate multi-byte escape sequences into things like number-
	 * pad actions, function keys, etc. So we can hardcode a small list of some
	 * of the most common sequences here, just in case.
	 *
	 * Notice that we turn nodelay() on. This means, that we won't accidentally
	 * interpret sequences as valid unless all the bytes are immediately
	 * available; this seems like an acceptable risk to fix problems associated
	 * with various terminal emulators (I'm looking at you PuTTY).
	 */
	if (i == 27) { /* ESC */
		nodelay(stdscr, true);
		j = getch();
		switch (j) {
			case 'O': {
				k = getch();
				switch (k) {
					/* PuTTY number pad */
					case 'q': i = '1'; break;
					case 'r': i = '2'; break;
					case 's': i = '3'; break;
					case 't': i = '4'; break;
					case 'u': i = '5'; break;
					case 'v': i = '6'; break;
					case 'w': i = '7'; break;
					case 'x': i = '8'; break;
					case 'y': i = '9'; break;

					/* no match */
					case ERR: break;
					default: ungetch(k); ungetch(j);
				}
				break;
			}

			/* no match */
			case ERR: break;
			default: ungetch(j);
		}
		nodelay(stdscr, false);
	}

#ifdef KEY_DOWN
	/* Handle arrow keys */
	switch (i) {
		case KEY_DOWN:  i = ARROW_DOWN;  break;
		case KEY_UP:    i = ARROW_UP;    break;
		case KEY_LEFT:  i = ARROW_LEFT;  break;
		case KEY_RIGHT: i = ARROW_RIGHT; break;
		case KEY_DC:    i = KC_DELETE; break;
		case KEY_BACKSPACE: i = KC_BACKSPACE; break;
		case KEY_ENTER: i = KC_ENTER; mods |= KC_MOD_KEYPAD; break;
		case 9:         i = KC_TAB; break;
		case 13:        i = KC_ENTER; break;
		case 27:        i = ESCAPE; break;

		/* keypad keys */
		case 0xFC: i = '0'; break;
		case 0xFD: i = '.'; break;
		case 0xC0: i = '\b'; break;
		case 0xDF: i = '1'; break;
		case 0xF5: i = '3'; break;
		case 0xE9: i = '5'; break;
		case 0xC1: i = '7'; break;
		case 0xF4: i = '9'; break;

		default: {
			if (i < KEY_MIN) break;

			/* Mega-Hack -- Fold, spindle, and mutilate
			 * the keys to fit in 7 bits.
			 */

			if (i >= 252) i = KEY_F(63) - (i - 252);
			if (i >= ARROW_DOWN) i += 4;

			i = 128 + (i & 127);
			break;
		}
	}
#endif

	/* Enqueue the keypress */
	Term_keypress(i, mods);

	/* Success */
	return (0);
}
Esempio n. 20
0
void execution(Commande *commande, Niveau *niveau){
	fixDirectory(commande, niveau);
	insertionString(niveau->history, commande->commande);
	int nbArgument = nbArg(commande);
	int ok = 1;
	int redirect = 1;
	// printw("nb arg : %d\n", nbArgument);
	exceptionProcessing(niveau, commande);
	// Vérifie que la commande ne soit pas vide
	if (strlen(commande->commande) == 0){}
	else
	{
		// Vérifie si la commande est autorisée dans ce niveau
		if (!appartient(premierArg(commande->commande), niveau->charAutorise))
		{
			printw("Commande \"%s\" interdite !!\n", premierArg(commande->commande));
			printw("Liste des commandes autorisées :\n");
			String *temp = niveau->charAutorise->premier;
			printw("\t %s\n", temp->string);
			
			while((temp = temp->suivant) != NULL){
				printw("\t %s\n", temp->string);
			}
		}
		else
		{
			ListeString *listeArg = malloc(sizeof(ListeString));
			buildArgsChain(listeArg, commande);

			// Gestion particulière du cd
			if (!strcmp(substr(commande->commande,0,2), "cd"))
			{
				// Vérifie qu'il n'y a qu'un seul argument après le cd
				if (nbArgument == 1)
				{
					// Vérifie que le dossier visé existe et qu'il n'est pas un fichier et qu'il n'est pas au-dessus de la racine
					if (dirExists(listeArg->premier->string) && accessible(commande))
					{
						// Vérifie que ce n'est pas un fichier 
						if(fileExists(listeArg->premier->string))
							printw("\"%s\" est un fichier !!\n", listeArg->premier->string);
						else{
							chdir(listeArg->premier->string);
							fixDirectory(commande, niveau);
							commande->niveau = commande->niveau + incrementNiveau(commande);
						}
					}else
						printw("Le répertoire \"%s\" n'existe pas !!\n", listeArg->premier->string);
				}else{
					goBackRoot(commande);
				}
			}
			// gestion du pwd
			else if (!strcmp(substr(commande->commande,0,3), "pwd"))
				pwd(commande);
			// Gestion de >>
			else if((redirect = isRedirector(commande)) > 0)
				redirection(niveau, commande, redirect);
			// commandes autres
			else
			{
				printw("%s", exec(listeArg, commande, &(*niveau)));
			}
		}
	}
}
Esempio n. 21
0
void screen(char *source,double *lst_disp,double *utc_disp,double *tjd_disp,
	double *ra_disp,double *dec_disp, 
	double *ra_cat_disp, double *dec_cat_disp,
	double *az_disp,
	double *el_disp,int *icount,double *azoff,double *eloff,int *icflag,
	double *az_actual_corrected,double *el_actual_disp,double *tiltx, double *tilty,int *initflag,int *pvt,float *pressure, float *temperature, float *humidity,
	double *az_error, double *el_error,double *scan_unit, char *messg,
	unsigned short *track_flag, unsigned short *slew_flag,double *focus_counts, double *subx_counts, double *suby_counts,double *subtilt_counts,
double *subtilt_arcseconds,
	double *total_power_disp,double *syncdet_disp, int *integration,
		float *magnitude, char *sptype, float *windspeed, 
	float *winddirection,float *refraction, float *pmdaz, float *pmdel,
	double *smoothed_tracking_error, double *tsys, short *errorflag, short *waitflag, unsigned short *pmac_command_flag, int *antennaNumber, int
*radio_flag,int *padid,double *planetdistance,double *Az_cmd,
double *El_cmd, double *Az_cmd_rate,double *El_cmd_rate,int *milliseconds,
int *servomilliseconds,char *m3StateString)
{

int i,j,l;
short az_act_sign,az_sign,el_sign,dec_dum_sign,dec_app_sign,dec_cat_sign;
char k;
char str[2];
int lsth,lstm,ra_cat_h,ra_cat_m,dec_cat_d,dec_cat_m;
int dec_app_d,dec_app_m;
int ra_app_h,ra_app_m;
int utch,utcm;
int epochint;
int az_cmd_d,az_cmd_m,el_cmd_d,el_cmd_m;
int az_act_d,az_act_m,el_act_d,el_act_m;
double ra_cat_s,dec_cat_s,ra_app_s,dec_app_s,lsts,utcs;
double az_cmd_s,el_cmd_s,az_act_s,el_act_s;
int lstsi,utcsi,az_cmd_si,az_act_si,el_cmd_si,el_act_si;
double ha;


	ha=*lst_disp-*ra_disp;

if((*icount%30)==0) initialize();

	if(*icount==1) initialize();
/*
	if((*icount%2)!=0) return;
*/

	*az_disp=*az_disp/0.017453293;
	*el_disp=*el_disp/0.017453293;


	hms(ra_disp,&ra_app_h,&ra_app_m,&ra_app_s,&dec_dum_sign);
	hms(dec_disp,&dec_app_d,&dec_app_m,&dec_app_s,&dec_app_sign);
	hms(ra_cat_disp,&ra_cat_h,&ra_cat_m,&ra_cat_s,&dec_dum_sign);
	hms(dec_cat_disp,&dec_cat_d,&dec_cat_m,&dec_cat_s,&dec_cat_sign);
	hms(lst_disp,&lsth,&lstm,&lsts,&dec_dum_sign);
	hms(utc_disp,&utch,&utcm,&utcs,&dec_dum_sign);
	hms(az_disp,&az_cmd_d,&az_cmd_m,&az_cmd_s,&az_sign);
	hms(el_disp,&el_cmd_d,&el_cmd_m,&el_cmd_s,&el_sign);
	hms(az_actual_corrected,&az_act_d,&az_act_m,&az_act_s,&az_act_sign);
	hms(el_actual_disp,&el_act_d,&el_act_m,&el_act_s,&dec_dum_sign);



	lstsi=(int)lsts;
	utcsi=(int)utcs;
	az_cmd_si=(int)az_cmd_s;
	el_cmd_si=(int)el_cmd_s;
	az_act_si=(int)az_act_s;
	el_act_si=(int)el_act_s;
	
box(stdscr, '|','-');

move(1,59);
printw("M3:%7s",m3StateString);

/*
move(1,2);
printw("%f %f %f %f %d %d %f",*Az_cmd/3600000.,*El_cmd/3600000.,*Az_cmd_rate/3600000.,*El_cmd_rate/3600000.,*milliseconds,*servomilliseconds,*utc_disp);

move(2,2);
printw("%f %f %f",*az_disp,*el_disp,*utc_disp);
*/
move(2,2);
if(*antennaNumber==1) addstr("SMA Antenna-1    tracking   ");
if(*antennaNumber==2) addstr("SMA Antenna-2    tracking   ");
if(*antennaNumber==3) addstr("SMA Antenna-3    tracking   ");
if(*antennaNumber==4) addstr("SMA Antenna-4    tracking   ");
if(*antennaNumber==5) addstr("SMA Antenna-5    tracking   ");
if(*antennaNumber==6) addstr("SMA Antenna-6    tracking   ");
if(*antennaNumber==7) addstr("SMA Antenna-7    tracking   ");
if(*antennaNumber==8) addstr("SMA Antenna-8    tracking   ");
move(3,2);
printw("on pad: %d",*padid);
move(4,5);
addstr("LST");
move (4,15);
addstr("UTC");
move(4,25);
addstr("TJD");
/*
move(2,25);
addstr("SOURCE=");
*/
move(2,32);
addstr(source);
move(3,32);
addstr(sptype);
move(4,32);
printw("%3.1f",*magnitude);
move (5,3);
af(&lsth,str);
addch(str[0]);
addch(str[1]);
move(5,6);
af(&lstm,str);
addch(str[0]);
addch(str[1]);
move(5,9);
af(&lstsi,str);
addch(str[0]);
addch(str[1]);
move(5,13);
af(&utch,str);
addch(str[0]);
addch(str[1]);
move(5,16);
af(&utcm,str);
addch(str[0]);
addch(str[1]);
move(5,19);
af(&utcsi,str);
addch(str[0]);
addch(str[1]);
move(5,23);
printw("%lf",*tjd_disp);
move(6,3);
printw("%.4f",ha);
move(7,14);
addstr("RA");
move(7,30);
addstr("DEC");
move(9,2);
addstr("CATALOG");
move(9,12);
af(&ra_cat_h,str);
addch(str[0]);
addch(str[1]);
move(9,15);
af(&ra_cat_m,str);
addch(str[0]);
addch(str[1]);
move(9,18);
printw("%.3f",ra_cat_s);
move(9,27);
if (dec_cat_sign>0) addch('+');
if (dec_cat_sign<0) addch('-');
if (dec_cat_sign==0) addch(' ');
af(&dec_cat_d,str);
addch(str[0]);
addch(str[1]);
move(9,31);
af(&dec_cat_m,str);
addch(str[0]);
addch(str[1]);
move(9,34);
printw("%.2f",dec_cat_s);

move(11,2);
printw("APPARENT");
move(11,12);
af(&ra_app_h,str);
addch(str[0]);
addch(str[1]);
move(11,15);
af(&ra_app_m,str);
addch(str[0]);
addch(str[1]);
move(11,18);
printw("%.3f",ra_app_s);
move(11,27);
if(dec_app_sign>0)addch('+');
if(dec_app_sign<0)addch('-');
if(dec_app_sign==0)addch(' ');
af(&dec_app_d,str);
addch(str[0]);
addch(str[1]);
move(11,31);
af(&dec_app_m,str);
addch(str[0]);
addch(str[1]);
move(11,34);
printw("%.2f",dec_app_s);

move(13,14);
addstr("AZ");
move(13,30);
addstr("EL");

move(15,2);
addstr("CMD");
move(15,9);
if((az_sign<0)&&(az_cmd_d==0))addch('-');
move(15,10);
printw("%03d",az_cmd_d);
move(15,15);
af(&az_cmd_m,str);
addch(str[0]);
addch(str[1]);
move(15,18);
af(&az_cmd_si,str);
addch(str[0]);
addch(str[1]);
move(15,27);
if(el_sign>=0)addch(' ');
if(el_sign<0)addch('-');
move(15,28);
af(&el_cmd_d,str);
addch(str[0]);
addch(str[1]);
move(15,31);
af(&el_cmd_m,str);
addch(str[0]);
addch(str[1]);
move(15,34);
af(&el_cmd_si,str);
addch(str[0]);
addch(str[1]);
move(17,2);
addstr("ACTUAL");
move(17,9);
if((az_act_sign<0)&&(az_act_d==0))addch('-');
move(17,10);
printw("%03d",az_act_d);
move(17,15);
af(&az_act_m,str);
addch(str[0]);
addch(str[1]);
move(17,18);
af(&az_act_si,str);
addch(str[0]);
addch(str[1]);
move(17,28);
af(&el_act_d,str);
addch(str[0]);
addch(str[1]);
move(17,31);
af(&el_act_m,str);
addch(str[0]);
addch(str[1]);
move(17,34);
af(&el_act_si,str);
addch(str[0]);
addch(str[1]);
move(19,2);
addstr("ERROR");
move(19,11);
printw("%7.1f\"",(*az_error*3600.));
move(19,28);
printw("%7.1f\"",(*el_error*3600.));
/*move(18,23);
printw("(%.1f\")",*smoothed_tracking_error);
*/

move(20,12);
printw("(%6.0f)",*pmdaz);
move(20,32);
printw("(%6.0f)",*pmdel);
move(21,2);
addstr("OFFSETS(\")");
move(21,12);
printw("%6.0f",*azoff);
move(21,32);
printw("%6.0f",*eloff);
move(22,2);
printw("%6.0f",*scan_unit);
move(21,42);
addstr("TILTS");
move(21,50);
printw("%.1f",*tiltx);
move(21,63);
printw("%.1f",*tilty);
move(21,73);
printw("%5d",*integration);

/*

move(22,42);
printw("%3d",*errorflag);
move(22,50);
printw("%3d",*waitflag);
move(22,55);
printw("%3d",*pmac_command_flag);
*/
move(22,42);
printw("Planet dist.=%.6f AU",*planetdistance);

/*
move(22,42);
addstr("PVT");
move(22,46);
printw("%4d",*pvt);
move(22,52);
addstr("TF=");
printw("%1d",*track_flag);
move(22,57);
addstr("SF=");
printw("%1d",*slew_flag);
*/
move(18,42);
addstr("REFRACTION:");
move(18,53);
if(*radio_flag==1) printw("%5.1f \" (radio)   ",*refraction);
if(*radio_flag==0) printw("%5.1f \" (optical) ",*refraction);
move(19,42);
addstr("WEATHER:");
move(19,51);
printw("%4.1f C",*temperature);
move(19,59);
printw("%5.1f%%",*humidity);
move(19,67);
printw("%6.1f mbar",*pressure);
move(20,51);
printw("wind: %4.1f m/s,  %5.1f  deg",*windspeed,*winddirection);
move(2,42);
addstr(messg);
move(17,42);
addstr("SUB_Z:");
move(17,49);
printw("%8.0f cts, %4.2f mm ",*focus_counts, (*focus_counts)/2000.);

move(13,42);
addstr("SUB_X:");
move(13,49);
printw("%8.0f cts, %4.2f mm ",*subx_counts, (*subx_counts)/1000.);

move(15,42);
addstr("SUB_Y:");
move(15,49);
printw("%8.0f cts, %4.2f mm ",*suby_counts, (*suby_counts)/500.);

move(11,42);
addstr("SUB_TILT:");
move(11,52);
printw("%8.0f cts, %4.2f \" ",*subtilt_counts, *subtilt_arcseconds);

move(9,42);
addstr("CONT. DET. O/P:");
move(9,58);
printw("%8.2f mV", (*total_power_disp)*1000.);

move(7,42);
addstr("SYNC. DET. O/P:");
move(7,58);
printw("%8.2f mV", (*syncdet_disp)*1000.);

move(5,42);
addstr("TSYS:");
move(5,48);
printw("%05.0f", *tsys);
move(5,55);
addstr("K");


/*
for(l=1;l<23;l++)
{
move(l,40);
addstr("|");
}
*/
refresh();
}
Esempio n. 22
0
int main(int argc, char *argv[])
{
	int continuer = 1;

	Commande *commande = malloc(sizeof(commande));
	initialiseCommande(commande);
	// signal(SIGINT, interrupt);

	Niveau *niveau = malloc(sizeof(niveau));
	decompression(choixNiveau(argc, argv), commande, niveau);


	/***
	*/


	struct sigaction act;
 
	memset (&act, '\0', sizeof(act));
 
	/* Use the sa_sigaction field because the handles has two additional parameters */
	act.sa_sigaction = &hdl;
 
	/* The SA_SIGINFO flag tells sigaction() to use the sa_sigaction field, not sa_handler. */
	act.sa_flags = SA_SIGINFO;
 
	if (sigaction(SIGINT, &act, NULL) < 0) {
		perror ("sigaction");
		return 1;
	}
	/****
	*/

	int ch;
	int finCommande = 0;
	initscr();
	idlok(stdscr, TRUE);
	scrollok(stdscr, TRUE);
	cbreak();
    	noecho();
    	keypad(stdscr, TRUE);
    	intrflush(stdscr, FALSE);
    printw("nom : %s\n", niveau->nom);
	int x, y;
	int nbAppuiUp = 0;
	char *saisie;
	while(continuer){      
		finCommande = 0;
		saisie = malloc(TAILLE_MAX_COMMANDE*sizeof(char));
		debutLigne(commande, niveau);

		while(finCommande == 0){
			ch = wgetch(stdscr);
			if(ch != KEY_UP && ch !=KEY_DOWN)
				nbAppuiUp = 0;
			if (ch == KEY_BACKSPACE)
			{
				getyx(stdscr, y, x);
				if(x > strlen(commande->directory)+3){
					move(y, x-1);
					delch();
					strcpy(saisie, substr(saisie, 0, strlen(saisie)-1));
				}
			}
			else if(ch == KEY_LEFT){
				getyx(stdscr, y, x);
				move(y, x-1);
			}
			else if(ch == KEY_RIGHT){
				getyx(stdscr, y, x);
				move(y, x+1);
			}
			else if (ch == KEY_UP)
			{
				nbAppuiUp++;
				String *temp = malloc(sizeof(String));
				temp = niveau->history->premier;
				if (temp->suivant != NULL)
				{
					int i = 0;
					while(i < nbAppuiUp && temp->suivant != NULL){
						temp = temp->suivant;
						i++;
					}
					free(saisie);
					saisie = malloc(sizeof(char)*TAILLE_MAX_COMMANDE);
					strcpy(saisie, temp->string);
					effaceCommande(commande);
					printw("%s", saisie);
				}
			}
			else if (ch == KEY_DOWN)
			{
				nbAppuiUp--;
				String *temp = malloc(sizeof(String));
				temp = niveau->history->premier;
				if (temp->suivant != NULL)
				{
					int i = 0;
					while(i < nbAppuiUp && temp->suivant != NULL){
						temp = temp->suivant;
						i++;
					}
					free(saisie);
					saisie = malloc(sizeof(char)*TAILLE_MAX_COMMANDE);
					strcpy(saisie, temp->string);
					effaceCommande(commande);
					printw("%s", saisie);
				}
			}
			else if(ch == KEY_DC){
				delch();
				strcpy(saisie, substr(saisie, 0, strlen(saisie)-1));
			}
			else if(ch == '\t'){
				effaceCommande(commande);
				
				char *essai = malloc(sizeof(char)*TAILLE_MAX_COMMANDE);
				if(strlen(autoComplete(saisie, niveau)) == 0)
					finCommande = 1;
				else{
					strcpy(saisie, strcat(saisie, autoComplete(saisie, niveau)));
					printw("%s", saisie);
				}
			}
    		else if(ch == '\n'){
    			finCommande = 1;
    			printw("\n");
    		}
    		else{
    			printw("%c", ch);
    			sprintf(saisie, "%s%c", saisie, ch);
    		}
		}
		strcpy(commande->commande, saisie);
		execution(commande, niveau);
		// free(saisie);
	}
	endwin();
	return 0;
}
Esempio n. 23
0
	int DisplayUsage( const char **pNULL, ProgramCommands *p_pSelf )
	{
		printw( "USAGE\n" );
		return 0;
	}
Esempio n. 24
0
int print_it ( ppstat *stats_array, int count )
{
	int input;
	int i, j;
	time_t uptime;
	time_t t;
	struct tm *now;
	char timestring[9];
	extern pmstat memory;
	double	total_ticks;
	MEVENT event;

	output = &printw;

	mousemask(ALL_MOUSE_EVENTS, NULL);
	total_ticks = parametres.ticks_passed * sysconf ( _SC_NPROCESSORS_ONLN );
	keypad ( win, TRUE );
	erase();

	t = time ( NULL );
	now = localtime ( &t );
	strftime ( timestring, 9, "%H:%M:%S", now );
	
	uptime = time ( NULL ) - parametres.btime;

	attroff ( A_BOLD );

	mvprintw ( 0, 0, "%-6s - %s  up %ld days %02ld:%02ld",
		parametres.progname,
		timestring,
		uptime / 86400,
		( uptime % 86400 ) / 3600,
		( uptime % 3600 ) / 60
		);
	mvprintw ( 0, 41, "load average: %7.2f %7.2f %7.2f",
		parametres.loadavg[0],
		parametres.loadavg[1],
		parametres.loadavg[2]
		);

	if ( parametres.cpu_stats[1].user != 0 )
	{
		mvprintw ( 2, 0, "Cpu(s):%5.1f us,%5.1f sy,%5.1f ni,%5.1f id,%5.1f wa,%5.1f hi,%5.1f si,%5.1f st",
		((parametres.cpu_stats[0].user - parametres.cpu_stats[1].user)/total_ticks) * 100,
	 	((parametres.cpu_stats[0].system - parametres.cpu_stats[1].system)/total_ticks) * 100,
		((parametres.cpu_stats[0].nice - parametres.cpu_stats[1].nice)/total_ticks) * 100 ,
		((parametres.cpu_stats[0].idle - parametres.cpu_stats[1].idle)/total_ticks) * 100 ,
		((parametres.cpu_stats[0].iowait - parametres.cpu_stats[1].iowait)/total_ticks) * 100,
		((parametres.cpu_stats[0].irq - parametres.cpu_stats[1].irq)/total_ticks) * 100,
		((parametres.cpu_stats[0].softirq - parametres.cpu_stats[1].softirq)/total_ticks) * 100,
		((parametres.cpu_stats[0].steal - parametres.cpu_stats[1].steal)/total_ticks) * 100 );
	}
	else
	{
		mvprintw ( 2, 0, "Cpu(s):%5.1f us,%5.1f sy,%5.1f ni,%5.1f id,%5.1f wa,%5.1f hi,%5.1f si,%5.1f st", 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 );
	}
	if ( memory->memtotal > 1000000000 )
	{
		mvprintw ( 3, 0, "MiB Mem:%10lu total, %10lu used, %10lu free, %10lu buffers",
			memory->memtotal / 1024,
			( memory->memtotal - memory->memfree ) / 1024,
			memory->memfree / 1024,
			memory->buffers / 1024
		);
		mvprintw ( 4, 0, "MiB Swap:%9lu total, %10lu used, %10lu free, %10lu cached",
			memory->swaptotal / 1024,
			( memory->swaptotal - memory->swapfree ) / 1024,
			memory->swapfree / 1024,
			memory->cached / 1024
		);
	}
	else
	{
		mvprintw ( 3, 0, "KiB Mem:%10lu total, %10lu used, %10lu free, %10lu buffers",
			memory->memtotal,
			memory->memtotal - memory->memfree,
			memory->memfree,
			memory->buffers
		);
		mvprintw ( 4, 0, "KiB Swap:%9lu total, %10lu used, %10lu free, %10lu cached",
			memory->swaptotal,
			memory->swaptotal - memory->swapfree,
			memory->swapfree,
			memory->cached
		);
	}
	mvprintw ( 5, 0, "JKUtop - horrovac invenit et fecit" );
	attron ( A_REVERSE );
	/*
	print the header
	*/
	move ( 6, 0 );
	for ( j = 0; j < FIELDS_AVAILABLE; j++ )
	{
		attroff ( A_BOLD );
		if ( display_fields[j] == NULL )
		{
			break;
		}
		if ( display_fields[j]->identifier == parametres.sortby )
		{
			attron ( A_BOLD );
		}
		printw ( display_fields[j]->header_format, display_fields[j]->fieldname );
	}
	for ( i = 67; i < col; i++ )
	{
		printw ( " " );
	}
	printw ( "\n" );
	attroff ( A_REVERSE );

	/*
	print the data fields
	*/
	for ( i = 0; i < count; i++ )
	{
		move ( i + 7, 0 );
		{
			if ( stats_array[i]->state == 'R' )
			{
			attron ( A_BOLD );
			}
			else
			{
				attroff ( A_BOLD );
			}
			for ( j = 0; j < FIELDS_AVAILABLE; j++ )
			{
				if ( display_fields[j] == NULL )
				{
					break;
				}
				display_fields[j]->printout( stats_array[i], display_fields[j]->identifier );
			}
			printw ( "\n" );

		}
		/* limit output to visible rows */
		if ( i + 8 >= row )
		{
			break;
		}
	}
	refresh();
	if ( ( input = getch () ) != ERR )
	{
		switch ( input )
		{
			case 'w':		/* save current configuration */
				save_config();
				break;
			case 'q':
				endwin();
				exit ( 0 );
				break;
			case 'o':
			case 'O':
			case 's':
			case 'S':
			case 'f':
			case 'F':
				modify_display();
				break;
			case KEY_MOUSE:
				if(getmouse(&event) == OK)
				{
					if ( event.bstate & BUTTON1_DOUBLE_CLICKED )
					{
						if ( event.y > 6 )
						{
							show_process_detail ( stats_array, event.y - 7 );
						}
						else if ( event.y == 6 )
						{
							mouse_select_sortfield ( event.x );
						}
					}
				}
				break;
			case 'h':
				show_help ();
				break;
			default:
				break;
		}
	}
	return ( i + 1 );
}
Esempio n. 25
0
void TerminalChatConsole::step(int ch)
{
	bool complete_redraw_needed = false;

	// empty queues
	while (!m_chat_interface->outgoing_queue.empty()) {
		ChatEvent *evt = m_chat_interface->outgoing_queue.pop_frontNoEx();
		switch (evt->type) {
			case CET_NICK_REMOVE:
				m_nicks.remove(((ChatEventNick *)evt)->nick);
				break;
			case CET_NICK_ADD:
				m_nicks.push_back(((ChatEventNick *)evt)->nick);
				break;
			case CET_CHAT:
				complete_redraw_needed = true;
				// This is only used for direct replies from commands
				// or for lua's print() functionality
				m_chat_backend.addMessage(L"", ((ChatEventChat *)evt)->evt_msg);
				break;
			case CET_TIME_INFO:
				ChatEventTimeInfo *tevt = (ChatEventTimeInfo *)evt;
				m_game_time = tevt->game_time;
				m_time_of_day = tevt->time;
		};
		delete evt;
	}
	while (!m_log_output.queue.empty()) {
		complete_redraw_needed = true;
		std::pair<LogLevel, std::string> p = m_log_output.queue.pop_frontNoEx();
		if (p.first > m_log_level)
			continue;

		m_chat_backend.addMessage(
			utf8_to_wide(Logger::getLevelLabel(p.first)),
			utf8_to_wide(p.second));
	}

	// handle input
	if (!m_esc_mode) {
		handleInput(ch, complete_redraw_needed);
	} else {
		switch (ch) {
			case ERR: // no input
				break;
			case 27: // ESC
				// Toggle ESC mode
				m_esc_mode = !m_esc_mode;
				break;
			case 'L':
				m_log_level--;
				m_log_level = MYMAX(m_log_level, LL_NONE + 1); // LL_NONE isn't accessible
				break;
			case 'l':
				m_log_level++;
				m_log_level = MYMIN(m_log_level, LL_MAX - 1);
				break;
		}
	}

	// was there a resize?
	int xn, yn;
	getmaxyx(stdscr, yn, xn);
	if (xn != m_cols || yn != m_rows) {
		m_cols = xn;
		m_rows = yn;
		m_can_draw_text = reformat_backend(&m_chat_backend, m_rows, m_cols);
		complete_redraw_needed = true;
	}

	// draw title
	move(0, 0);
	clrtoeol();
	addstr(PROJECT_NAME_C);
	addstr(" ");
	addstr(g_version_hash);

	u32 minutes = m_time_of_day % 1000;
	u32 hours = m_time_of_day / 1000;
	minutes = (float)minutes / 1000 * 60;

	if (m_game_time)
		printw(" | Game %d Time of day %02d:%02d ",
			m_game_time, hours, minutes);

	// draw text
	if (complete_redraw_needed && m_can_draw_text)
		draw_text();

	// draw prompt
	if (!m_esc_mode) {
		// normal prompt
		ChatPrompt& prompt = m_chat_backend.getPrompt();
		std::string prompt_text = wide_to_utf8(prompt.getVisiblePortion());
		move(m_rows - 1, 0);
		clrtoeol();
		addstr(prompt_text.c_str());
		// Draw cursor
		s32 cursor_pos = prompt.getVisibleCursorPosition();
		if (cursor_pos >= 0) {
			move(m_rows - 1, cursor_pos);
		}
	} else {
		// esc prompt
		move(m_rows - 1, 0);
		clrtoeol();
		printw("[ESC] Toggle ESC mode |"
			" [CTRL+C] Shut down |"
			" (L) in-, (l) decrease loglevel %s",
			Logger::getLevelLabel((LogLevel) m_log_level).c_str());
	}

	refresh();
}
Esempio n. 26
0
int main()
{
    int p1[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
    int win = 0;
    int pole, remis, tryb;
    int ch, x = 2, y = 2, exit = 0;	//do operacji na kursorze

    initscr();
    cbreak();
    noecho();// ja jeeeeeeeeeeeeeeeeeeeeebie, działa! ;d
    keypad(stdscr, true);	//do zabawy kursorem
    start_color();
    beep();

    tryb = menu();


    while (remis < 9) {
	rysuj(p1);

	exit = 0;
	// todo: przeniesc to do funkcji wczytaj i zrobic sprawdzanie czy nie jest juz zajete pole
	while (exit<1) {
		move(y,x);
		refresh();
		ch = getch();
	    switch (ch) {
	    case KEY_LEFT:
		x--;
		move(y, x);
		refresh();
		break;
	    case KEY_RIGHT:
		x++;
		move(y, x);
		refresh();
		break;
	    case KEY_UP:
		y--;
		move(y, x);
		refresh();
		break;
	    case KEY_DOWN:
		y++;
		move(y, x);
		refresh();
		break;
	    case 0xa:
		getyx(stdscr, y, x);	// y = wiersz kursora y = kolumna kursora
		if (x == 0 && y == 0) {
			pole = 1;
			exit = 1;
		}
		else if ((x == 2) && (y == 0)) {
			pole = 2;
			exit = 1;
		}
		else if (x == 4 && y == 0) {
			pole = 3;
			exit = 1;
		}
		else if (x == 0 && y == 2) {
			pole = 4;
			exit = 1;
		}
		else if (x == 2 && y == 2) {
			pole = 5;
			exit = 1;
		}
		else if (x == 4 && y == 2) {
			pole = 6;
			exit = 1;
		}
		else if (x == 0 && y == 4) {
			pole = 7;
			exit = 1;
		}
		else if (x == 2 && y == 4) {
			pole = 8;
			exit = 1;
		}
		else if (x == 4 && y == 4) {
			pole = 9;
			exit = 1;
		}
				break;
			  }

	}
	

	wczytaj(1, pole, p1);
	remis++;
	if (remis == 9) {

	    printw("Remis\n");
	    break;
	}

	win = test(1, p1);
	if (win > 0) {
	    break;
	}
	/* wybór trybu single/multi */

	if (tryb == 2) {
	    rysuj(p1);		//rysuje planszę po ruchu pierwszego gracza tylko jak jest multiplayer
	    printw("Gracz 2, podaj pole [1-9]:");
	    scanw("%d", &pole);
	    wczytaj(2, pole, p1);
	}
	if (tryb == 1) {
	    pc1(p1);
	}
	win = test(2, p1);
	remis++;
	if (remis == 9) {
	    printw("Remis\n");
	    break;
	}
	if (win > 0) {
	    rysuj(p1);
	    break;
	}
	refresh();
    }
    if (win == 1) {
	mvprintw(5,0,"Gratulacje! Gracz 1, wygrałeś.\n");
    }
    if (win == 2) {
	mvprintw(5,0,"Gratulacje! Gracz 2 wygrywa!\n");
    }
    getch();
    endwin();
    return 0;
}
Esempio n. 27
0
int main() {
    std::vector <double> result;
    double A;
    double B;
    double C;
    initscr();
    noecho();
    clear();
    printw("input A \n");
    refresh();
    do {
        clear();
        refresh();
        printw("input A \n");
        refresh();
        A = input_double();
        printw("input B \n");    
        refresh();
        B = input_double();
        printw("input C \n");    
        refresh();
        C = input_double();
    
        if (A == 0) { //handling A = 0
            printw("A = 0");
            refresh();
            continue;
        }

        result = hard_solve(A, B, C);
        if (result[0] == 0) {
            printw("no solutions");
            refresh();
        }

        if (result[0] == 1) {
            printw("%f", result[1]);
            refresh();
        }

        if (result[0] == 2) {
            printw("%f", result[1]);
            printw(", ");
            printw("%f", result[2]);
            refresh();
        } 

        printw("\n");
        printw("press any key to continue");
        printw("\n");
        printw("press ESC key to quit");
        refresh();
    } while (getchar() != 27);
    endwin();
}
Esempio n. 28
0
void nperror(const char *s) {
if (flag_monitor || flag_monitor_continous)
    printw("%s:%s", s, strerror(errno));
else
    perror(s);
}
Esempio n. 29
0
int
main(int ac, char *av[])
{
	bool		show_only;
	extern char	*Scorefile;
	int		score_wfd;     /* high score writable file descriptor */
	int		score_err = 0; /* hold errno from score file open */
	int		ch;
	extern int	optind;
	gid_t		gid;
#ifdef FANCY
	char		*sp;
#endif

	if ((score_wfd = open(Scorefile, O_RDWR)) < 0)
		score_err = errno;

	/* revoke privs */
	gid = getgid();
	setresgid(gid, gid, gid);

	show_only = FALSE;
	while ((ch = getopt(ac, av, "srajt")) != -1)
		switch (ch) {
		case 's':
			show_only = TRUE;
			break;
		case 'r':
			Real_time = TRUE;
			/* Could be a command-line option */
			tv.tv_sec = 3;
			tv.tv_usec = 0;
			FD_ZERO(&rset);
			break;
		case 'a':
			Start_level = 4;
			break;
		case 'j':
			Jump = TRUE;
			break;
		case 't':
			Teleport = TRUE;
			break;
		case '?':
		default:
			usage();
		}
	ac -= optind;
	av += optind;

	if (ac > 1)
		usage();
	if (ac == 1) {
		Scorefile = av[0];
		if (score_wfd >= 0)
			close(score_wfd);
		/* This file requires no special privileges. */
		if ((score_wfd = open(Scorefile, O_RDWR)) < 0)
			score_err = errno;
#ifdef	FANCY
		sp = strrchr(Scorefile, '/');
		if (sp == NULL)
			sp = Scorefile;
		if (strcmp(sp, "pattern_roll") == 0)
			Pattern_roll = TRUE;
		else if (strcmp(sp, "stand_still") == 0)
			Stand_still = TRUE;
		if (Pattern_roll || Stand_still)
			Teleport = TRUE;
#endif
	}

	if (show_only) {
		show_score();
		exit(0);
	}

	if (score_wfd < 0) {
		warnx("%s: %s; no scores will be saved", Scorefile,
			strerror(score_err));
		sleep(1);
	}

	initscr();
	signal(SIGINT, quit);
	cbreak();
	noecho();
	nonl();
	if (LINES != Y_SIZE || COLS != X_SIZE) {
		if (LINES < Y_SIZE || COLS < X_SIZE) {
			endwin();
			errx(1, "Need at least a %dx%d screen", Y_SIZE, X_SIZE);
		}
		delwin(stdscr);
		stdscr = newwin(Y_SIZE, X_SIZE, 0, 0);
	}

	srandomdev();
	do {
		init_field();
		for (Level = Start_level; !Dead; Level++) {
			make_level();
			play_level();
		}
		move(My_pos.y, My_pos.x);
		printw("AARRrrgghhhh....");
		refresh();
		score(score_wfd);
	} while (another());
	quit(0);
	/* NOT REACHED */
}
Esempio n. 30
0
void show_stats(void) {
   unsigned val;
   unsigned lo_addr[8], hi_addr[8];
   unsigned i;

   while (1) {

      move(5,0);

      readReg(&nf2, MAC_GRP_0_CONTROL_REG, &val);
      printw("MAC 0 Control: 0x%08x ", val);
      if(val&(1<<MAC_GRP_TX_QUEUE_DISABLE_BIT_NUM)) {
         printw("TX disabled, ");
      }
      else {
         printw("TX enabled,  ");
      }
      if(val&(1<<MAC_GRP_RX_QUEUE_DISABLE_BIT_NUM)) {
         printw("RX disabled, ");
      }
      else {
         printw("RX enabled,  ");
      }
      if(val&(1<<MAC_GRP_RESET_MAC_BIT_NUM)) {
         printw("reset on,    ");
      }
      else {
         printw("reset off,   ");
      }
      printw("mac config 0x%02x\n", val>>MAC_GRP_MAC_DISABLE_TX_BIT_NUM);

      readReg(&nf2, MAC_GRP_1_CONTROL_REG, &val);
      printw("MAC 1 Control: 0x%08x ", val);
      if(val&(1<<MAC_GRP_TX_QUEUE_DISABLE_BIT_NUM)) {
         printw("TX disabled, ");
      }
      else {
         printw("TX enabled,  ");
      }
      if(val&(1<<MAC_GRP_RX_QUEUE_DISABLE_BIT_NUM)) {
         printw("RX disabled, ");
      }
      else {
         printw("RX enabled,  ");
      }
      if(val&(1<<MAC_GRP_RESET_MAC_BIT_NUM)) {
         printw("reset on,    ");
      }
      else {
         printw("reset off,   ");
      }
      printw("mac config 0x%02x\n", val>>MAC_GRP_MAC_DISABLE_TX_BIT_NUM);

      readReg(&nf2, MAC_GRP_2_CONTROL_REG, &val);
      printw("MAC 2 Control: 0x%08x ", val);
      if(val&(1<<MAC_GRP_TX_QUEUE_DISABLE_BIT_NUM)) {
         printw("TX disabled, ");
      }
      else {
         printw("TX enabled,  ");
      }
      if(val&(1<<MAC_GRP_RX_QUEUE_DISABLE_BIT_NUM)) {
         printw("RX disabled, ");
      }
      else {
         printw("RX enabled,  ");
      }
      if(val&(1<<MAC_GRP_RESET_MAC_BIT_NUM)) {
         printw("reset on,    ");
      }
      else {
         printw("reset off,   ");
      }
      printw("mac config 0x%02x\n", val>>MAC_GRP_MAC_DISABLE_TX_BIT_NUM);

      readReg(&nf2, MAC_GRP_3_CONTROL_REG, &val);
      printw("MAC 3 Control: 0x%08x ", val);
      if(val&(1<<MAC_GRP_TX_QUEUE_DISABLE_BIT_NUM)) {
         printw("TX disabled, ");
      }
      else {
         printw("TX enabled,  ");
      }
      if(val&(1<<MAC_GRP_RX_QUEUE_DISABLE_BIT_NUM)) {
         printw("RX disabled, ");
      }
      else {
         printw("RX enabled,  ");
      }
      if(val&(1<<MAC_GRP_RESET_MAC_BIT_NUM)) {
         printw("reset on,    ");
      }
      else {
         printw("reset off,   ");
      }
      printw("mac config 0x%02x\n", val>>MAC_GRP_MAC_DISABLE_TX_BIT_NUM);

      move (12,0);
      printw("                   Port 0    CPU 0   Port 1    CPU 1   Port 2    CPU 2   Port 3    CPU 3\n");
      printw("Packets Lost:\n");
      printw("Packets Stored:\n");
      printw("Packets Removed:\n");
      printw("Bytes Stored:\n");
      printw("Bytes Removed:\n");
      printw("Low address:\n");
      printw("High address:\n");
      printw("Write address:\n");
      printw("Read address:\n");

      move (13,17);
      readReg(&nf2, OQ_QUEUE_0_NUM_PKTS_DROPPED_REG, &val); lost[0] = val;
      printw("%8i", lost[0]);
      readReg(&nf2, OQ_QUEUE_1_NUM_PKTS_DROPPED_REG, &val);lost[1] = val;
      printw(" %8i", lost[1]);
      readReg(&nf2, OQ_QUEUE_2_NUM_PKTS_DROPPED_REG, &val);lost[2] = val;
      printw(" %8i", lost[2]);
      readReg(&nf2, OQ_QUEUE_3_NUM_PKTS_DROPPED_REG, &val);lost[3] = val;
      printw(" %8i", lost[3]);
      readReg(&nf2, OQ_QUEUE_4_NUM_PKTS_DROPPED_REG, &val);lost[4] = val;
      printw(" %8i", lost[4]);
      readReg(&nf2, OQ_QUEUE_5_NUM_PKTS_DROPPED_REG, &val);lost[5] = val;
      printw(" %8i", lost[5]);
      readReg(&nf2, OQ_QUEUE_6_NUM_PKTS_DROPPED_REG, &val);lost[6] = val;
      printw(" %8i", lost[6]);
      readReg(&nf2, OQ_QUEUE_7_NUM_PKTS_DROPPED_REG, &val);lost[7] = val;
      printw(" %8i", lost[7]);

      move (14,17);
      readReg(&nf2, OQ_QUEUE_0_NUM_PKTS_STORED_REG, &val);stored[0] = val;
      printw("%8i", stored[0]);
      readReg(&nf2, OQ_QUEUE_1_NUM_PKTS_STORED_REG, &val);stored[1] = val;
      printw(" %8i", stored[1]);
      readReg(&nf2, OQ_QUEUE_2_NUM_PKTS_STORED_REG, &val);stored[2] = val;
      printw(" %8i", stored[2]);
      readReg(&nf2, OQ_QUEUE_3_NUM_PKTS_STORED_REG, &val);stored[3] = val;
      printw(" %8i", stored[3]);
      readReg(&nf2, OQ_QUEUE_4_NUM_PKTS_STORED_REG, &val);stored[4] = val;
      printw(" %8i", stored[4]);
      readReg(&nf2, OQ_QUEUE_5_NUM_PKTS_STORED_REG, &val);stored[5] = val;
      printw(" %8i", stored[5]);
      readReg(&nf2, OQ_QUEUE_6_NUM_PKTS_STORED_REG, &val);stored[6] = val;
      printw(" %8i", stored[6]);
      readReg(&nf2, OQ_QUEUE_7_NUM_PKTS_STORED_REG, &val);stored[7] = val;
      printw(" %8i", stored[7]);

      move (15,17);
      readReg(&nf2, OQ_QUEUE_0_NUM_PKTS_REMOVED_REG, &val);removed[0] = val;
      printw("%8i", removed[0]);
      readReg(&nf2, OQ_QUEUE_1_NUM_PKTS_REMOVED_REG, &val);removed[1] = val;
      printw(" %8i", removed[1]);
      readReg(&nf2, OQ_QUEUE_2_NUM_PKTS_REMOVED_REG, &val);removed[2] = val;
      printw(" %8i", removed[2]);
      readReg(&nf2, OQ_QUEUE_3_NUM_PKTS_REMOVED_REG, &val);removed[3] = val;
      printw(" %8i", removed[3]);
      readReg(&nf2, OQ_QUEUE_4_NUM_PKTS_REMOVED_REG, &val);removed[4] = val;
      printw(" %8i", removed[4]);
      readReg(&nf2, OQ_QUEUE_5_NUM_PKTS_REMOVED_REG, &val);removed[5] = val;
      printw(" %8i", removed[5]);
      readReg(&nf2, OQ_QUEUE_6_NUM_PKTS_REMOVED_REG, &val);removed[6] = val;
      printw(" %8i", removed[6]);
      readReg(&nf2, OQ_QUEUE_7_NUM_PKTS_REMOVED_REG, &val);removed[7] = val;
      printw(" %8i", removed[7]);

      move (16,17);
      readReg(&nf2, OQ_QUEUE_0_NUM_PKT_BYTES_STORED_REG, &val);
      printw("%8i", val);
      readReg(&nf2, OQ_QUEUE_1_NUM_PKT_BYTES_STORED_REG, &val);
      printw(" %8i", val);
      readReg(&nf2, OQ_QUEUE_2_NUM_PKT_BYTES_STORED_REG, &val);
      printw(" %8i", val);
      readReg(&nf2, OQ_QUEUE_3_NUM_PKT_BYTES_STORED_REG, &val);
      printw(" %8i", val);
      readReg(&nf2, OQ_QUEUE_4_NUM_PKT_BYTES_STORED_REG, &val);
      printw(" %8i", val);
      readReg(&nf2, OQ_QUEUE_5_NUM_PKT_BYTES_STORED_REG, &val);
      printw(" %8i", val);
      readReg(&nf2, OQ_QUEUE_6_NUM_PKT_BYTES_STORED_REG, &val);
      printw(" %8i", val);
      readReg(&nf2, OQ_QUEUE_7_NUM_PKT_BYTES_STORED_REG, &val);
      printw(" %8i", val);

      move (17,17);
      readReg(&nf2, OQ_QUEUE_0_NUM_PKT_BYTES_REMOVED_REG, &val);
      printw("%8i", val);
      readReg(&nf2, OQ_QUEUE_1_NUM_PKT_BYTES_REMOVED_REG, &val);
      printw(" %8i", val);
      readReg(&nf2, OQ_QUEUE_2_NUM_PKT_BYTES_REMOVED_REG, &val);
      printw(" %8i", val);
      readReg(&nf2, OQ_QUEUE_3_NUM_PKT_BYTES_REMOVED_REG, &val);
      printw(" %8i", val);
      readReg(&nf2, OQ_QUEUE_4_NUM_PKT_BYTES_REMOVED_REG, &val);
      printw(" %8i", val);
      readReg(&nf2, OQ_QUEUE_5_NUM_PKT_BYTES_REMOVED_REG, &val);
      printw(" %8i", val);
      readReg(&nf2, OQ_QUEUE_6_NUM_PKT_BYTES_REMOVED_REG, &val);
      printw(" %8i", val);
      readReg(&nf2, OQ_QUEUE_7_NUM_PKT_BYTES_REMOVED_REG, &val);
      printw(" %8i", val);

      move (18,17);
      readReg(&nf2, OQ_QUEUE_0_ADDR_LO_REG, &val);lo_addr[0] = val;
      printw("%8x", lo_addr[0]<<3);
      readReg(&nf2, OQ_QUEUE_1_ADDR_LO_REG, &val);lo_addr[1] = val;
      printw(" %8x", lo_addr[1]<<3);
      readReg(&nf2, OQ_QUEUE_2_ADDR_LO_REG, &val);lo_addr[2] = val;
      printw(" %8x", lo_addr[2]<<3);
      readReg(&nf2, OQ_QUEUE_3_ADDR_LO_REG, &val);lo_addr[3] = val;
      printw(" %8x", lo_addr[3]<<3);
      readReg(&nf2, OQ_QUEUE_4_ADDR_LO_REG, &val);lo_addr[4] = val;
      printw(" %8x", lo_addr[4]<<3);
      readReg(&nf2, OQ_QUEUE_5_ADDR_LO_REG, &val);lo_addr[5] = val;
      printw(" %8x", lo_addr[5]<<3);
      readReg(&nf2, OQ_QUEUE_6_ADDR_LO_REG, &val);lo_addr[6] = val;
      printw(" %8x", lo_addr[6]<<3);
      readReg(&nf2, OQ_QUEUE_7_ADDR_LO_REG, &val);lo_addr[7] = val;
      printw(" %8x", lo_addr[7]<<3);

      move (19,17);
      readReg(&nf2, OQ_QUEUE_0_ADDR_HI_REG, &val);hi_addr[0] = val;
      printw("%8x", hi_addr[0]<<3);
      readReg(&nf2, OQ_QUEUE_1_ADDR_HI_REG, &val);hi_addr[1] = val;
      printw(" %8x", hi_addr[1]<<3);
      readReg(&nf2, OQ_QUEUE_2_ADDR_HI_REG, &val);hi_addr[2] = val;
      printw(" %8x", hi_addr[2]<<3);
      readReg(&nf2, OQ_QUEUE_3_ADDR_HI_REG, &val);hi_addr[3] = val;
      printw(" %8x", hi_addr[3]<<3);
      readReg(&nf2, OQ_QUEUE_4_ADDR_HI_REG, &val);hi_addr[4] = val;
      printw(" %8x", hi_addr[4]<<3);
      readReg(&nf2, OQ_QUEUE_5_ADDR_HI_REG, &val);hi_addr[5] = val;
      printw(" %8x", hi_addr[5]<<3);
      readReg(&nf2, OQ_QUEUE_6_ADDR_HI_REG, &val);hi_addr[6] = val;
      printw(" %8x", hi_addr[6]<<3);
      readReg(&nf2, OQ_QUEUE_7_ADDR_HI_REG, &val);hi_addr[7] = val;
      printw(" %8x", hi_addr[7]<<3);

      move (20,17);
      readReg(&nf2, OQ_QUEUE_0_WR_ADDR_REG, &val);
      printw("%8x", val<<3);
      readReg(&nf2, OQ_QUEUE_1_WR_ADDR_REG, &val);
      printw(" %8x", val<<3);
      readReg(&nf2, OQ_QUEUE_2_WR_ADDR_REG, &val);
      printw(" %8x", val<<3);
      readReg(&nf2, OQ_QUEUE_3_WR_ADDR_REG, &val);
      printw(" %8x", val<<3);
      readReg(&nf2, OQ_QUEUE_4_WR_ADDR_REG, &val);
      printw(" %8x", val<<3);
      readReg(&nf2, OQ_QUEUE_5_WR_ADDR_REG, &val);
      printw(" %8x", val<<3);
      readReg(&nf2, OQ_QUEUE_6_WR_ADDR_REG, &val);
      printw(" %8x", val<<3);
      readReg(&nf2, OQ_QUEUE_7_WR_ADDR_REG, &val);
      printw(" %8x", val<<3);

      move (21,17);
      readReg(&nf2, OQ_QUEUE_0_RD_ADDR_REG, &val);
      printw("%8x", val<<3);
      readReg(&nf2, OQ_QUEUE_1_RD_ADDR_REG, &val);
      printw(" %8x", val<<3);
      readReg(&nf2, OQ_QUEUE_2_RD_ADDR_REG, &val);
      printw(" %8x", val<<3);
      readReg(&nf2, OQ_QUEUE_3_RD_ADDR_REG, &val);
      printw(" %8x", val<<3);
      readReg(&nf2, OQ_QUEUE_4_RD_ADDR_REG, &val);
      printw(" %8x", val<<3);
      readReg(&nf2, OQ_QUEUE_5_RD_ADDR_REG, &val);
      printw(" %8x", val<<3);
      readReg(&nf2, OQ_QUEUE_6_RD_ADDR_REG, &val);
      printw(" %8x", val<<3);
      readReg(&nf2, OQ_QUEUE_7_RD_ADDR_REG, &val);
      printw(" %8x", val<<3);

      move (22,0);
      printw("Size:");
      move (22,16);
      for (i=0;i<8;i++) {
	 printw(" %6iKB", ((hi_addr[i]-lo_addr[i])/128));
      }

	move (24,0);
	readReg(&nf2, ANTI_SPOOF_AS_NUM_HITS_REG, &val);
	printw("MAC lut num hits:              %u\n", val);
	readReg(&nf2, ANTI_SPOOF_AS_NUM_MISSES_REG, &val);
	printw("MAC lut num misses:            %u\n\n", val);
	for(i=0; i<16; i=i+1){
	  writeReg(&nf2, ANTI_SPOOF_AS_MAC_LUT_RD_ADDR_REG, i);
	  readReg(&nf2, ANTI_SPOOF_AS_PORTS_MAC_HI_REG, &val);
	  printw("   CAM table entry %02u: wr_protect: %u, ports: 0x%04x, mac: 0x%04x", i, val>>31, (val&0x7fff0000)>>16, (val&0xffff));
	  readReg(&nf2, ANTI_SPOOF_AS_MAC_LO_REG, &val);
	  printw("%08x\n", val);
	}


      refresh();

      sleep(1);

   }

}