int main(int argc, char *argv[])
{
struct winsize Size;
if(isatty(STDIN_FILENO)==0)
exit(NO_FD_WITH_TERM);
if(ioctl(STDIN_FILENO,TIOCGWINSZ,&Size)<0)
exit(GET_WINDOW_SIZE_ERROR);
//The size should be fixed.or it's hard to control
ROWS=Size.ws_row+1; //39
COLUMNS=(Size.ws_col+1)*7/15; //70
N=sizeof(char)*ROWS*COLUMNS;
ScreenTable=(char*)malloc(N+4);
memset(ScreenTable,0,N);
OtherScreen=(char*)malloc(N+4);
memset(OtherScreen,0,N);
Move=(char*)malloc(N);
memset(Move,0,N);
initscr();
move(ROWS/2,COLUMNS/2-5);
printw("%s","Ready?Go!");
refresh();
sleep(1);
clear();
refresh();
//create a thread to receive keyboard input
int res;
pthread_t keyb;
res=pthread_create(&keyb,NULL,animation,NULL);
if(res!=0)
{
perror("Thread 1 Creation failed");
safe_exit(THREAD_CREATE_FAILED);
}
/*
pthread_t anti;
res=pthread_create(&anti,NULL,another_window,NULL);
if(res!=0)
{
perror("Thread 2 Creation failed");
safe_exit(THREAD_CREATE_FAILED);
}
*/
pthread_t info;
res=pthread_create(&info,NULL,middle_window,NULL);
if(res!=0)
{
perror("Thread 3 Creation failed");
safe_exit(THREAD_CREATE_FAILED);
}
cbreak();
noecho();
while(1)
{
TYPINGCHAR=getch();
while(TYPINGCHAR=='\n')
break;
isOld=0;
}
safe_exit(EXIT_SUCCESS);
}
int useradd()
{
noecho();
keypad(stdscr, TRUE);
while(1) {
DrawAddUserScreen();
AddUserKey = getch();
switch(AddUserKey)
{
/* Help */
case KEY_F(1):
break;
/* Reset Fields */
case KEY_F(2):
sprintf(ui.username, "_");
sprintf(ui.gecos, "_");
sprintf(ui.user_id, "_");
sprintf(ui.group_id, "_");
sprintf(ui.shell, "_");
sprintf(ui.homedir, "_");
break;
/* Username */
case KEY_F(3):
echo();
attron(A_REVERSE);
mvprintw(8,35, "[_______________________]");
mvwgetnstr(stdscr, 8,36, userinfobuf, 15);
strcpy(ui.username, userinfobuf);
attroff(A_REVERSE);
noecho();
unamefield = 1;
break;
/* User Comment/Gecos */
case KEY_F(4):
echo();
attron(A_REVERSE);
mvprintw(9,35, "[_______________________]");
mvwgetnstr(stdscr, 9,36, userinfobuf, 20);
strcpy(ui.gecos, userinfobuf);
attroff(A_REVERSE);
noecho();
break;
/* User ID*/
case KEY_F(5):
echo();
attron(A_REVERSE);
mvprintw(10,35, "[_______________________]");
mvwgetnstr(stdscr, 10,36, userinfobuf, 20);
strcpy(ui.user_id, userinfobuf);
attroff(A_REVERSE);
noecho();
uidfield = 1;
break;
/* Group ID*/
case KEY_F(6):
echo();
attron(A_REVERSE);
mvprintw(11,35, "[_______________________]");
mvwgetnstr(stdscr, 11,36, userinfobuf, 20);
strcpy(ui.group_id, userinfobuf);
attroff(A_REVERSE);
noecho();
gidfield = 1;
break;
/* Login Shell */
case KEY_F(7):
echo();
attron(A_REVERSE);
mvprintw(12,35, "[_______________________]");
mvwgetnstr(stdscr, 12,36, userinfobuf, 23);
strcpy(ui.shell, userinfobuf);
attroff(A_REVERSE);
noecho();
break;
/* Home Dir */
case KEY_F(8):
echo();
attron(A_REVERSE);
mvprintw(13,35, "[_______________________]");
mvwgetnstr(stdscr, 13,36, userinfobuf, 23);
strcpy(ui.homedir, userinfobuf);
attroff(A_REVERSE);
noecho();
break;
case KEY_F(9):
execute_default_shell();
break;
/* Quit */
case KEY_F(10):
return 0;
break;
/* Commence Add */
case KEY_F(11):
add_user();
break;
};
};
return 0;
}
void run_timer(int seconds, std::string msg, bool quit)
{
std::string timer;
timer = secsToTime(seconds);
(void) signal(SIGINT, finish_curses_and_quit); /* arrange interrupts to terminate */
(void) initscr(); /* initialize the curses library */
keypad(stdscr, TRUE); /* enable keyboard mapping */
(void) nonl(); /* tell curses not to do NL->CR/NL on output */
(void) cbreak(); /* take input chars one at a time, no wait for \n */
(void) noecho(); /* don't echo input */
if (has_colors())
{
start_color();
/*
* Simple color assignment, often all we need.
*/
init_pair(COLOR_BLACK, COLOR_BLACK, COLOR_BLACK);
init_pair(COLOR_GREEN, COLOR_GREEN, COLOR_BLACK);
init_pair(COLOR_RED, COLOR_RED, COLOR_BLACK);
init_pair(COLOR_CYAN, COLOR_CYAN, COLOR_BLACK);
init_pair(COLOR_WHITE, COLOR_WHITE, COLOR_BLACK);
init_pair(COLOR_MAGENTA, COLOR_MAGENTA, COLOR_BLACK);
init_pair(COLOR_BLUE, COLOR_BLUE, COLOR_BLACK);
init_pair(COLOR_YELLOW, COLOR_YELLOW, COLOR_BLACK);
}
int row,col; /* to store the number of rows and *
* the number of colums of the screen */
initscr(); /* start the curses mode */
getmaxyx(stdscr,row,col); /* get the number of rows and columns */
mvprintw(row/2,(col-strlen(timer.c_str()))/2,"%s",timer.c_str());
/* print the message at the center of the screen */
mvprintw(row-1,0, msg.c_str());
//printw("Try resizing your window(if possible) and then run this program again");
refresh();
for (;;)
{
//int c = getch(); /* refresh, accept single keystroke of input */
/* process the command keystroke */
sleep(1);
if(--seconds == 0)
{
mvprintw(row/2,(col-strlen("TIME IS UP!"))/2,"%s","TIME IS UP!");
refresh();
system("play ring.wav > /dev/null 2>&1 &");
if(!quit)
{
return finish_curses(0);
}
else
{
finish_curses_and_quit(0);
}
}
mvprintw(row/2,(col-strlen(" "))/2,"%s"," ");
timer = secsToTime(seconds);
mvprintw(row/2,(col-strlen(timer.c_str()))/2,"%s",timer.c_str());
refresh();
}
if(!quit)
{
return finish_curses(0);
}
else
{
finish_curses_and_quit(0);
}
}
int
main(int argc, const char *const argv[], const char *const envp[])
{
ifmon_t *ifmons;
char **ifnames;
int nifs;
int ret;
int flags;
int ch;
double delta;
double dtxb;
double drxb;
double dtxp;
double drxp;
int i;
if ( 2 > argc ) {
_usage(argv[0]);
}
/* Get interfaces */
nifs = argc - 1;
ifnames = malloc(sizeof(char *) * nifs);
if ( NULL == ifnames ) {
perror("malloc()");
return EXIT_FAILURE;
}
ifmons = malloc(sizeof(ifmon_t) * nifs);
if ( NULL == ifmons ) {
perror("malloc()");
return EXIT_FAILURE;
}
for ( i = 0; i < nifs; i++ ) {
ifnames[i] = strdup(argv[i+1]);
if ( NULL == ifnames[i] ) {
perror("strdup()");
return EXIT_FAILURE;
}
if ( NULL == ifmon_init(&ifmons[i], ifnames[i]) ) {
/* Error */
fprintf(stderr, "Error: ifname=%s\n", ifnames[i]);
return EXIT_FAILURE;
}
}
#if WITH_CURSES
/* curses */
if ( NULL == initscr() ) {
fprintf(stderr, "initscr(): Cannot initialize screen\n");
return EXIT_FAILURE;
}
cbreak();
noecho();
scrollok(stdscr, FALSE);
move(0, 0);
#endif
/* Set stdin as non-blocking */
flags = fcntl(STDIN_FILENO, F_GETFL, 0);
if ( -1 == flags ) {
flags = 0;
}
fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK);
for ( ;; ) {
#if WITH_CURSES
ch = getch();
if ( 'q' == ch ) {
break;
}
#endif
for ( i = 0; i < nifs; i++ ) {
ret = ifmon_update(&ifmons[i]);
if ( 0 != ret ) {
/* Error */
break;
}
}
#if WITH_CURSES
clear();
#endif
#if WITH_CURSES
time_t timer;
time(&timer);
/*
struct tm *tm;
tm = localtime(&timer);
*/
/*printw("Time: %.6f\n", );*/
printw("Interface statistics\n%s\n", ctime(&timer));
printw(" pkts/s kbps\n");
printw(" TX RX TX RX\n");
#endif
for ( i = 0; i < nifs; i++ ) {
delta = ifmons[i].curstat.time - ifmons[i].prevstat.time;
dtxp = ifmons[i].curstat.total_pkts.tx
- ifmons[i].prevstat.total_pkts.tx;
drxp = ifmons[i].curstat.total_pkts.rx
- ifmons[i].prevstat.total_pkts.rx;
dtxb = ifmons[i].curstat.total_bytes.tx
- ifmons[i].prevstat.total_bytes.tx;
drxb = ifmons[i].curstat.total_bytes.rx
- ifmons[i].prevstat.total_bytes.rx;
#if WITH_CURSES
printw("%-8.8s: %11.02lf %11.02lf %11.02lf %11.02lf\n",
ifnames[i], dtxp/delta, drxp/delta,
8*dtxb/delta/1000, 8*drxb/delta/1000);
#else
printf("%-8.8s: %11.02lf %11.02lf %11.02lf %11.02lf\n",
ifnames[i], dtxp/delta, drxp/delta,
8*dtxb/delta/1000, 8*drxb/delta/1000);
#endif
}
#if 0
printw("Time: %.6f (%.6f)\n",
ifmon.curstat.time, ifmon.curstat.time - ifmon.prevstat.time);
printw("\tTX: %15llu pkts\tRX: %15llu pkts\n",
ifmon.curstat.total_pkts.tx - ifmon.prevstat.total_pkts.tx,
ifmon.curstat.total_pkts.rx - ifmon.prevstat.total_pkts.rx);
printw("\tTX: %15llu bytes\tRX: %15llu bytes\n",
ifmon.curstat.total_bytes.tx - ifmon.prevstat.total_bytes.tx,
ifmon.curstat.total_bytes.rx - ifmon.prevstat.total_bytes.rx);
#endif
#if WITH_CURSES
refresh();
#endif
sleep(1);
}
#if WITH_CURSES
/* End curses */
endwin();
#endif
return 0;
}
int main(int argc, char *argv[])
{
#ifdef ENABLE_LOGGING
setupDebug();
#endif
int seed = time(NULL);
//args: world seeding only.
argc--; argv++;
while (argc){
if(std::string(argv[0]) == "--seed"){
argc--; argv++;
if(argc){
seed = djb2_hash((unsigned char*)argv[0]);
argc--; argv++;
}
}
else // ignore unknown args.
argc--; argv++;
}
// ncurses stuff
load_options(); // For getting size options
initscr(); // Initialize ncurses
noecho(); // Don't echo keypresses
cbreak(); // C-style breaks (e.g. ^C to SIGINT)
keypad(stdscr, true); // Numpad is numbers
init_colors(); // See color.cpp
curs_set(0); // Invisible cursor
std::srand(seed);
bool quit_game = false;
bool delete_world = false;
game *g = new game;
MAPBUFFER.set_game(g);
MAPBUFFER.load();
#if (!(defined _WIN32 || defined WINDOWS))
struct sigaction sigIntHandler;
sigIntHandler.sa_handler = exit_handler;
sigemptyset(&sigIntHandler.sa_mask);
sigIntHandler.sa_flags = 0;
sigaction(SIGINT, &sigIntHandler, NULL);
#endif
do {
g->setup();
while (!g->do_turn()) ;
if (g->uquit == QUIT_DELETE_WORLD)
delete_world = true;
if (g->game_quit())
quit_game = true;
} while (!quit_game);
if (delete_world)
{
g->delete_save();
} else {
MAPBUFFER.save_if_dirty();
}
exit_handler(-999);
return 0;
}
/** Demo program using curses.
*
* This demo displays the text entered in a top windows that stretches
* across the screen. The current prediction is displayed immediately
* underneath the text window, at the leftmost position.
*
* The previous predictions are displayed in cronological order to the
* right of the current prediction.
*
* Subsequent predictions shifted to the right, so that the current
* prediction is always on the left hand side.
* Context switches are marked in some way (either a vertical bar or a
* box enclosing the other prediction boxes).
*
*/
int main(int argc, char** argv)
{
parseCommandLineArgs(argc, argv);
// magic starts here
PresageCallback* callback = new PresageDemoCallback(buffer);
Presage presage(callback, config);
// configuration variable may be read and written programmatically
if (suggestions.empty()) {
suggestions = presage.config("Presage.Selector.SUGGESTIONS");
} else {
presage.config("Presage.Selector.SUGGESTIONS", suggestions);
}
// curses
initscr();
noecho();
cbreak();
keypad(stdscr, TRUE);
clear();
refresh();
disclaimer();
// curses title window
const int TITLE_WIN_HEIGHT = 6;
const int TITLE_WIN_WIDTH = COLS;
const int TITLE_WIN_BEGIN_Y = 0;
const int TITLE_WIN_BEGIN_X = 0;
WINDOW* title_win = newwin(TITLE_WIN_HEIGHT, TITLE_WIN_WIDTH, TITLE_WIN_BEGIN_Y, TITLE_WIN_BEGIN_X);
draw_title_win(title_win);
// curses context window
const int CONTEXT_WIN_HEIGHT = 5;
const int CONTEXT_WIN_WIDTH = COLS;
const int CONTEXT_WIN_BEGIN_Y = TITLE_WIN_BEGIN_Y + TITLE_WIN_HEIGHT + 1;
const int CONTEXT_WIN_BEGIN_X = 0;
WINDOW* context_win = newwin(CONTEXT_WIN_HEIGHT, CONTEXT_WIN_WIDTH, CONTEXT_WIN_BEGIN_Y, CONTEXT_WIN_BEGIN_X);
draw_context_win(context_win, std::string(""));
// curses function keys window
const int FUNCTION_WIN_HEIGHT = atoi(suggestions.c_str()) + 2;
const int FUNCTION_WIN_WIDTH = 4;
const int FUNCTION_WIN_BEGIN_Y = CONTEXT_WIN_BEGIN_Y + CONTEXT_WIN_HEIGHT + 1;
const int FUNCTION_WIN_BEGIN_X = 0;
WINDOW* function_win = newwin(FUNCTION_WIN_HEIGHT, FUNCTION_WIN_WIDTH, FUNCTION_WIN_BEGIN_Y, FUNCTION_WIN_BEGIN_X);
draw_function_keys(function_win);
mvprintw(LINES - 1, 0, "Press F12 to quit.");
refresh();
std::vector<std::string> words;
int c = ' ';
do {
size_t size = words.size();
if ((KEY_F0 < c) && (c <= KEY_F(size)) && (c - KEY_F0 <= size)) {
// prediction was successful. user pressed the function
// key corresponding to desired token. selecting
// suggestion.
std::string message = "Last selected word: " + words[c - KEY_F0 - 1];
mvprintw(LINES - 3, 0, message.c_str());
clrtoeol();
move(LINES, COLS);
// update buffer with prediction completion
buffer << presage.completion(words[c - KEY_F0 - 1]);
// ask presage to predict next token
words = presage.predict();
} else {
// prediction unsuccessful. get next character from user
// and elaborate a new prediction.
buffer << static_cast<char>(c);
words = presage.predict();
// refresh curses screen
refresh();
}
draw_context_win(context_win, presage.context());
draw_previous_suggestions(words,
presage.context_change(),
CONTEXT_WIN_BEGIN_Y + CONTEXT_WIN_HEIGHT + 1,
FUNCTION_WIN_BEGIN_X + FUNCTION_WIN_WIDTH + 1 );
c = getch();
} while( c != KEY_F(12) );
delwin(title_win);
delwin(context_win);
delwin(function_win);
endwin();
return 0;
}
int getchoice(char *greet, char *choices[]) {
static int selected_row = 0; // static so we can re-highlight choice
int max_row = 0;
int start_screenrow = MESSAGE_LINE, start_screencol = 10;
char **option;
int selected;
int key = 0;
// determine the number of rows
option = choices;
while (*option) {
max_row++;
option++;
}
/* deal with the case where menu gets shorter after a cd is deleted */
if (selected_row >= max_row) {
selected_row = 0;
}
clear_all_screen();
mvprintw(start_screenrow - 2, start_screencol, greet);
// turn on keypad, cbreak, noecho
keypad(stdscr, TRUE);
cbreak();
noecho();
// loop over the menu redraw until the press 'q' or until they have
// a choice highlighted and press enter.
key = 0;
while (key != 'q' && key != KEY_ENTER && key != '\n') {
// move the selection up or down. Wrap across line 0.
if (key == KEY_UP) {
if (selected_row == 0) {
selected_row = max_row - 1;
} else {
selected_row--;
}
} else if (key == KEY_DOWN) {
if (selected_row == max_row - 1) {
selected_row = 0;
} else {
selected_row++;
}
}
// [] has higher precedence than *, so this is the same as
// choices[selected_row][0].
selected = *choices[selected_row];
// draw the menu, then get the next key. Note initial case is handled.
draw_menu(choices, selected_row, start_screenrow, start_screencol);
key = getch();
}
// turn off keypad, cbreak, noecho
keypad(stdscr, TRUE);
nocbreak();
echo();
return selected;
}
int
main(int argc, char **argv)
{
int FromCol, ToCol;
setlocale(LC_ALL, "");
switch (argc) {
case 1:
NTiles = DEFAULTTILES;
break;
case 2:
NTiles = atoi(argv[1]);
if (NTiles > MAXTILES || NTiles < MINTILES) {
fprintf(stderr, "Range %d to %d\n", MINTILES, MAXTILES);
ExitProgram(EXIT_FAILURE);
}
break;
case 3:
if (strcmp(argv[2], "a")) {
Usage();
ExitProgram(EXIT_FAILURE);
}
NTiles = atoi(argv[1]);
if (NTiles > MAXTILES || NTiles < MINTILES) {
fprintf(stderr, "Range %d to %d\n", MINTILES, MAXTILES);
ExitProgram(EXIT_FAILURE);
}
AutoFlag = TRUE;
break;
default:
Usage();
ExitProgram(EXIT_FAILURE);
}
initscr();
if (has_colors()) {
int i;
short bg = COLOR_BLACK;
start_color();
#if HAVE_USE_DEFAULT_COLORS
if (use_default_colors() == OK)
bg = -1;
#endif
for (i = 0; i < 9; i++)
init_pair((short) (i + 1), bg, TileColour[i]);
}
cbreak();
if (LINES < 24) {
endwin();
fprintf(stderr, "Min screen length 24 lines\n");
ExitProgram(EXIT_FAILURE);
}
if (AutoFlag) {
curs_set(0);
leaveok(stdscr, TRUE); /* Attempt to remove cursor */
}
InitTiles();
DisplayTiles();
if (AutoFlag) {
do {
noecho();
AutoMove(0, 2, NTiles);
} while (!Solved(NTiles));
sleep(2);
} else {
echo();
for (;;) {
if (GetMove(&FromCol, &ToCol))
break;
if (InvalidMove(FromCol, ToCol)) {
MvAddStr(STATUSLINE, 0, "Invalid Move !!");
refresh();
beep();
continue;
}
MakeMove(FromCol, ToCol);
if (Solved(NTiles)) {
MvPrintw(STATUSLINE, 0,
"Well Done !! You did it in %d moves", NMoves);
refresh();
sleep(5);
break;
}
}
}
endwin();
ExitProgram(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
log_options_t opts = LOG_OPTS_STDERR_ONLY;
node_info_msg_t *node_info_ptr = NULL;
node_info_msg_t *new_node_ptr = NULL;
int error_code;
int height = 40;
int width = 100;
int startx = 0;
int starty = 0;
int end = 0;
int i;
int rc;
log_init(xbasename(argv[0]), opts, SYSLOG_FACILITY_DAEMON, NULL);
parse_command_line(argc, argv);
if (params.verbose) {
opts.stderr_level += params.verbose;
log_alter(opts, SYSLOG_FACILITY_USER, NULL);
}
if (params.cluster_dims == 4) {
min_screen_width = 92;
} else if (params.cluster_dims == 3)
min_screen_width = 92;
/* no need for this if you are resolving */
while (slurm_load_node((time_t) NULL,
&new_node_ptr, SHOW_ALL)) {
if (params.resolve || (params.display == COMMANDS)) {
new_node_ptr = NULL;
break; /* just continue */
}
error_code = slurm_get_errno();
printf("slurm_load_node: %s\n",
slurm_strerror(error_code));
if (params.iterate == 0)
exit(1);
sleep(10); /* keep trying to reconnect */
}
select_g_ba_init(new_node_ptr, 0);
if (dim_size == NULL) {
dim_size = get_cluster_dims(new_node_ptr);
if ((dim_size == NULL) || (dim_size[0] < 1))
fatal("Invalid system dimensions");
}
_init_colors();
if (params.resolve) {
char *ret_str = resolve_mp(params.resolve, new_node_ptr);
if (ret_str) {
printf("%s", ret_str);
xfree(ret_str);
}
_smap_exit(0); /* Calls exit(), no return */
}
if (!params.commandline) {
int check_width = min_screen_width;
initscr();
init_grid(new_node_ptr, COLS);
signal(SIGWINCH, (void (*)(int))_resize_handler);
if (params.cluster_dims == 4) {
height = dim_size[2] * dim_size[3] + dim_size[2] + 3;
width = (dim_size[1] + dim_size[3] + 1) * dim_size[0]
+ 2;
check_width += width;
} else if (params.cluster_dims == 3) {
height = dim_size[1] * dim_size[2] + dim_size[1] + 3;
width = dim_size[0] + dim_size[2] + 3;
check_width += width;
} else {
height = 10;
width = COLS;
}
if ((COLS < check_width) || (LINES < height)) {
endwin();
error("Screen is too small make sure the screen "
"is at least %dx%d\n"
"Right now it is %dx%d\n",
check_width,
height,
COLS,
LINES);
_smap_exit(1); /* Calls exit(), no return */
}
raw();
keypad(stdscr, TRUE);
noecho();
cbreak();
curs_set(0);
nodelay(stdscr, TRUE);
start_color();
_set_pairs();
grid_win = newwin(height, width, starty, startx);
max_display = (getmaxy(grid_win) - 1) * (getmaxx(grid_win) - 1);
if (params.cluster_dims == 4) {
startx = width;
COLS -= 2;
width = COLS - width;
height = LINES;
} else if (params.cluster_dims == 3) {
startx = width;
COLS -= 2;
width = COLS - width;
height = LINES;
} else {
startx = 0;
starty = height;
height = LINES - height;
}
text_win = newwin(height, width, starty, startx);
}
while (!end) {
if (!params.commandline) {
_get_option();
redraw:
clear_window(text_win);
clear_window(grid_win);
move(0, 0);
update_grid(new_node_ptr);
main_xcord = 1;
main_ycord = 1;
}
if (!params.no_header)
print_date();
clear_grid();
switch (params.display) {
case JOBS:
get_job();
break;
case RESERVATIONS:
get_reservation();
break;
case SLURMPART:
get_slurm_part();
break;
case COMMANDS:
#ifdef HAVE_BG
wclear(text_win);
get_command();
#else
error("Must be on a real BG SYSTEM to "
"run this command");
if (!params.commandline)
endwin();
_smap_exit(1); /* Calls exit(), no return */
#endif
break;
case BGPART:
if (params.cluster_flags & CLUSTER_FLAG_BG)
get_bg_part();
else {
error("Must be on a BG SYSTEM to "
"run this command");
if (!params.commandline)
endwin();
_smap_exit(1); /* Calls exit(), no return */
}
break;
}
if (!params.commandline) {
box(text_win, 0, 0);
wnoutrefresh(text_win);
print_grid();
box(grid_win, 0, 0);
wnoutrefresh(grid_win);
doupdate();
node_info_ptr = new_node_ptr;
if (node_info_ptr) {
error_code = slurm_load_node(
node_info_ptr->last_update,
&new_node_ptr, SHOW_ALL);
if (error_code == SLURM_SUCCESS)
slurm_free_node_info_msg(
node_info_ptr);
else if (slurm_get_errno()
== SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_node_ptr = node_info_ptr;
}
} else {
error_code = slurm_load_node(
(time_t) NULL,
&new_node_ptr, SHOW_ALL);
}
if (error_code && (quiet_flag != 1)) {
if (!params.commandline) {
mvwprintw(
text_win,
main_ycord,
1,
"slurm_load_node: %s",
slurm_strerror(
slurm_get_errno()));
main_ycord++;
} else {
printf("slurm_load_node: %s",
slurm_strerror(
slurm_get_errno()));
}
}
}
if (params.iterate) {
for (i = 0; i < params.iterate; i++) {
sleep(1);
if (!params.commandline) {
if ((rc = _get_option()) == 1)
goto redraw;
else if (resize_screen) {
resize_screen = 0;
goto redraw;
}
}
}
} else
break;
}
if (!params.commandline) {
nodelay(stdscr, FALSE);
getch();
endwin();
}
_smap_exit(0); /* Calls exit(), no return */
exit(0); /* Redundant, but eliminates compiler warning */
}
int main(int argc, char **argv) {
struct timeval t;
int bytes_read, bytes_sent;
int queryRegister;
int i,n;
int firstRegister=0;
int lastRegister=39;
char canInterface[128];
strcpy(canInterface,"can0");
while ((n = getopt (argc, argv, "hvi:")) != -1) {
switch (n) {
case 'h':
fprintf(stdout,"# -p\tOutput a pretty human readable display to stderr\n");
fprintf(stdout,"#\n");
fprintf(stdout,"# -h\tThis help message then exit\n");
fprintf(stdout,"#\n");
fprintf(stdout,"# -i\tCAN interface to use (eg can0, can1, etc)\n");
return 0;
case 'i':
strncpy(canInterface,optarg,sizeof(canInterface));
canInterface[sizeof(canInterface)-1]='\0';
fprintf(stdout,"# CAN interface = %s\n",canInterface);
break;
case 'v':
outputDebug=1;
fprintf(stdout,"# verbose (debugging) output to stderr enabled\n");
break;
}
}
if ( !outputDebug ) {
fprintf(stdout,"# warning: no output format is selected. Nothing will show.\n");
}
/* setup ncurses screen */
initscr();
cbreak();
noecho();
/* non-blocking non-buffered character reads */
nodelay(stdscr, TRUE);
scrollok(stdscr, TRUE);
/* initialize CAN frames */
update_frame_event_update('\0');
update_frame_operating_hours_fuel_level('\0');
update_frame_status('\0');
/* Create the socket */
skt = socket( PF_CAN, SOCK_RAW, CAN_RAW );
/* Locate the interface you wish to use */
if ( outputDebug) printw("# Locating interface %s ... ",canInterface);
struct ifreq ifr;
strcpy(ifr.ifr_name, canInterface);
ioctl(skt, SIOCGIFINDEX, &ifr); /* ifr.ifr_ifindex gets filled with that device's index */
if ( outputDebug) printw("done\n");
/* Select that CAN interface, and bind the socket to it. */
if ( outputDebug) printw("# Binding to interface ... ");
struct sockaddr_can addr;
addr.can_family = AF_CAN;
addr.can_ifindex = ifr.ifr_ifindex;
if ( 0 != bind( skt, (struct sockaddr*)&addr, sizeof(addr) ) ) {
printw("\n# Error binding to interface. Bye.\n");
return 1;
}
if ( outputDebug) printw("done\n");
for ( ; ; ) {
int ch;
/* 100 millisecond timer */
t.tv_sec = 0;
t.tv_usec = 100000;
select(0, NULL, NULL, NULL, &t);
update_frame_operating_hours_fuel_level('\0'); /* running time gets incremented everytime through */
periodic_100ms();
ch=getch();
if ( '~' == ch ) {
break;
} else if ( ch >= 'a' && ch <= 'f' ) {
update_frame_event_update(ch);
} else if ( ch >= 'g' && ch <= 'j' ) {
update_frame_operating_hours_fuel_level(ch);
} else if ( ch >= 'k' && ch <= 'l' ) {
update_frame_status(ch);
}
}
/* tear down ncurses window */
endwin();
return 0;
}
int main() {
setlocale(LC_ALL,"");
clit_config *config = malloc(sizeof(clit_config));
if(parse_config(config) == -1) {
// first run
int res = authorize(config);
if(res == -1) {
printf("Please retry.\n");
}
else
printf("Authorization finished. Run the program again.\n");
free(config);
exit(0);
}
me = newuser();
me->screen_name = config->screen_name;
me->id = config->user_id;
init_oauth(config->key,config->secret);
free(config);
init_mutex();
raw_event_stream = new_raw_event_queue();
printf("Loading the timelines....\n");
if(init_timelines() == -1) {
pthread_mutex_lock(&error_mutex);
printf("Cannot load the timeline. Please check your network connection.\n");
pthread_mutex_unlock(&error_mutex);
goto exit_twilc;
}
initscr();
curs_set(0);
//if(has_colors() == FALSE)
//goto exit_twilc;
raw();
keypad(stdscr,TRUE);
noecho();
start_color();
move(0,0);
refresh();
if(init_ui() == -1)
goto exit_twilc;
start_userstream();
wait_command(tl_win);
exit_twilc:
destroy_ui();
curs_set(1);
endwin();
destroy_mutex();
for(int i = 0; i < TIMELINE_COUNT; ++i)
destroy_timeline(timelines[i]);
stop_userstream();
pthread_mutex_lock(&event_buffer_mutex);
destroy_raw_event_queue(raw_event_stream);
raw_event_stream = NULL;
pthread_mutex_unlock(&event_buffer_mutex);
return 0;
}
/**
* Prepare "curses" for use by the file "ui-term.c"
*
* Installs the "hook" functions defined above, and then activates
* the main screen "term", which clears the screen and such things.
*
* Someone should really check the semantics of "initscr()"
*/
errr init_gcu(int argc, char **argv) {
int i;
int rows, cols, y, x;
int next_win = 0;
/* Initialize info about terminal capabilities */
termtype = getenv("TERM");
loaded_terminfo = termtype && tgetent(0, termtype) == 1;
/* Parse args */
for (i = 1; i < argc; i++) {
if (prefix(argv[i], "-b")) {
term_count = 1;
} else if (prefix(argv[i], "-B")) {
bold_extended = TRUE;
} else if (prefix(argv[i], "-a")) {
ascii_walls = TRUE;
} else if (prefix(argv[i], "-n")) {
term_count = atoi(&argv[i][2]);
if (term_count > MAX_TERM_DATA) term_count = MAX_TERM_DATA;
else if (term_count < 1) term_count = 1;
} else {
plog_fmt("Ignoring option: %s", argv[i]);
}
}
/* Extract the normal keymap */
keymap_norm_prepare();
/* We do it like this to prevent a link error with curseses that
* lack ESCDELAY. */
if (!getenv("ESCDELAY"))
putenv("ESCDELAY=20");
/* Initialize */
if (initscr() == NULL) return (-1);
/* Activate hooks */
quit_aux = hook_quit;
/* Require standard size screen */
if (LINES < MIN_TERM0_LINES || COLS < MIN_TERM0_COLS)
quit("Angband needs at least an 80x24 'curses' screen");
#ifdef A_COLOR
/* Do we have color, and enough color, available? */
can_use_color = ((start_color() != ERR) && has_colors() &&
(COLORS >= 8) && (COLOR_PAIRS >= 8));
#ifdef HAVE_USE_DEFAULT_COLORS
/* Should we use curses' "default color" */
if (use_default_colors() == OK) bg_color = -1;
#endif
/* Attempt to use colors */
if (can_use_color) {
/* Prepare the color pairs */
/* PAIR_WHITE (pair 0) is *always* WHITE on BLACK */
init_pair(PAIR_RED, COLOR_RED, bg_color);
init_pair(PAIR_GREEN, COLOR_GREEN, bg_color);
init_pair(PAIR_YELLOW, COLOR_YELLOW, bg_color);
init_pair(PAIR_BLUE, COLOR_BLUE, bg_color);
init_pair(PAIR_MAGENTA, COLOR_MAGENTA, bg_color);
init_pair(PAIR_CYAN, COLOR_CYAN, bg_color);
init_pair(PAIR_BLACK, COLOR_BLACK, bg_color);
/* Prepare the colors */
colortable[COLOUR_DARK] = (COLOR_PAIR(PAIR_BLACK));
colortable[COLOUR_WHITE] = (COLOR_PAIR(PAIR_WHITE) | A_BRIGHT);
colortable[COLOUR_SLATE] = (COLOR_PAIR(PAIR_WHITE));
colortable[COLOUR_ORANGE] = (COLOR_PAIR(PAIR_YELLOW) | A_BRIGHT);
colortable[COLOUR_RED] = (COLOR_PAIR(PAIR_RED));
colortable[COLOUR_GREEN] = (COLOR_PAIR(PAIR_GREEN));
colortable[COLOUR_BLUE] = (COLOR_PAIR(PAIR_BLUE));
colortable[COLOUR_UMBER] = (COLOR_PAIR(PAIR_YELLOW));
colortable[COLOUR_L_DARK] = (COLOR_PAIR(PAIR_BLACK) | A_BRIGHT);
colortable[COLOUR_L_WHITE] = (COLOR_PAIR(PAIR_WHITE));
colortable[COLOUR_L_PURPLE] = (COLOR_PAIR(PAIR_MAGENTA));
colortable[COLOUR_YELLOW] = (COLOR_PAIR(PAIR_YELLOW) | A_BRIGHT);
colortable[COLOUR_L_RED] = (COLOR_PAIR(PAIR_MAGENTA) | A_BRIGHT);
colortable[COLOUR_L_GREEN] = (COLOR_PAIR(PAIR_GREEN) | A_BRIGHT);
colortable[COLOUR_L_BLUE] = (COLOR_PAIR(PAIR_BLUE) | A_BRIGHT);
colortable[COLOUR_L_UMBER] = (COLOR_PAIR(PAIR_YELLOW));
colortable[COLOUR_PURPLE] = (COLOR_PAIR(PAIR_MAGENTA));
colortable[COLOUR_VIOLET] = (COLOR_PAIR(PAIR_MAGENTA));
colortable[COLOUR_TEAL] = (COLOR_PAIR(PAIR_CYAN));
colortable[COLOUR_MUD] = (COLOR_PAIR(PAIR_YELLOW));
colortable[COLOUR_L_YELLOW] = (COLOR_PAIR(PAIR_YELLOW | A_BRIGHT));
colortable[COLOUR_MAGENTA] = (COLOR_PAIR(PAIR_MAGENTA | A_BRIGHT));
colortable[COLOUR_L_TEAL] = (COLOR_PAIR(PAIR_CYAN) | A_BRIGHT);
colortable[COLOUR_L_VIOLET] = (COLOR_PAIR(PAIR_MAGENTA) | A_BRIGHT);
colortable[COLOUR_L_PINK] = (COLOR_PAIR(PAIR_MAGENTA) | A_BRIGHT);
colortable[COLOUR_MUSTARD] = (COLOR_PAIR(PAIR_YELLOW));
colortable[COLOUR_BLUE_SLATE] = (COLOR_PAIR(PAIR_BLUE));
colortable[COLOUR_DEEP_L_BLUE] = (COLOR_PAIR(PAIR_BLUE));
}
#endif
/* Paranoia -- Assume no waiting */
nodelay(stdscr, FALSE);
/* Prepare */
cbreak();
noecho();
nonl();
/* Tell curses to rewrite escape sequences to KEY_UP and friends */
keypad(stdscr, TRUE);
/* Extract the game keymap */
keymap_game_prepare();
/* Now prepare the term(s) */
for (i = 0; i < term_count; i++) {
/* Get the terminal dimensions; if the user asked for a big screen
* then we'll put the whole screen in term 0; otherwise we'll divide
* it amongst the available terms */
get_gcu_term_size(i, &rows, &cols, &y, &x);
/* Skip non-existant windows */
if (rows <= 0 || cols <= 0) continue;
/* Create a term */
term_data_init_gcu(&data[next_win], rows, cols, y, x);
/* Remember the term */
angband_term[next_win] = &data[next_win].t;
/* One more window */
next_win++;
}
/* Activate the "Angband" window screen */
Term_activate(&data[0].t);
/* Remember the active screen */
term_screen = &data[0].t;
/* Success */
return (0);
}
int
main(int argc, char *argv[])
{
int optc;
int option_differences = 0,
option_differences_cumulative = 0,
option_exec = 0,
option_beep = 0,
option_color = 0,
option_errexit = 0,
option_help = 0,
option_version = 0,
option_clear = 1;
double interval = 2;
char *command;
wchar_t *wcommand = NULL;
char **command_argv;
int command_length = 0; /* not including final \0 */
int wcommand_columns = 0; /* not including final \0 */
int wcommand_characters = 0; /* not including final \0 */
watch_usec_t next_loop; /* next loop time in us, used for precise time
keeping only */
int pipefd[2];
int status;
pid_t child;
setlocale(LC_ALL, "");
progname = argv[0];
while ((optc = getopt_long(argc, argv, "+bced::hn:pvtx", longopts, (int *) 0))
!= EOF) {
switch (optc) {
case 'b':
option_beep = 1;
break;
case 'c':
option_color = 1;
break;
case 'd':
option_differences = 1;
if (optarg)
option_differences_cumulative = 1;
break;
case 'e':
option_errexit = 1;
break;
case 'h':
option_help = 1;
break;
case 't':
show_title = 0;
break;
case 'x':
option_exec = 1;
break;
case 'C':
option_clear = 0;
break;
case 'n':
{
char *str;
interval = strtod(optarg, &str);
if (!*optarg || *str)
do_usage();
if(interval < 0.1)
interval = 0.1;
if(interval > ~0u/1000000)
interval = ~0u/1000000;
}
break;
case 'p':
precise_timekeeping = 1;
break;
case 'v':
option_version = 1;
break;
default:
do_usage();
break;
}
}
if (option_version) {
fprintf(stderr, "%s\n", VERSION);
if (!option_help)
exit(0);
}
if (option_help) {
fprintf(stderr, usage, progname);
fputs(" -b, --beep\t\t\t\tbeep if the command has a non-zero exit\n", stderr);
fputs(" -d, --differences[=cumulative]\thighlight changes between updates\n", stderr);
fputs("\t\t(cumulative means highlighting is cumulative)\n", stderr);
fputs(" -e, --errexit\t\t\t\texit watch if the command has a non-zero exit\n", stderr);
fputs(" -h, --help\t\t\t\tprint a summary of the options\n", stderr);
fputs(" -n, --interval=<seconds>\t\tseconds to wait between updates\n", stderr);
fputs(" -p, --precise\t\t\t\tprecise timing, ignore command run time\n", stderr);
fputs(" -v, --version\t\t\t\tprint the version number\n", stderr);
fputs(" -t, --no-title\t\t\tturns off showing the header\n", stderr);
fputs(" -x, --exec\t\t\t\tpass command to exec instead of sh\n", stderr);
fputs(" -C, --no-clear\t\t\tturns off clearing the screen each time\n", stderr);
exit(0);
}
if (optind >= argc)
do_usage();
command_argv=&(argv[optind]); /* save for later */
command = strdup(argv[optind++]);
command_length = strlen(command);
for (; optind < argc; optind++) {
char *endp;
int s = strlen(argv[optind]);
command = realloc(command, command_length + s + 2); /* space and \0 */
endp = command + command_length;
*endp = ' ';
memcpy(endp + 1, argv[optind], s);
command_length += 1 + s; /* space then string length */
command[command_length] = '\0';
}
// convert to wide for printing purposes
//mbstowcs(NULL, NULL, 0);
wcommand_characters = mbstowcs(NULL, command, 0);
if(wcommand_characters < 0) {
fprintf(stderr, "Unicode Handling Error\n");
exit(1);
}
wcommand = (wchar_t*)malloc((wcommand_characters+1) * sizeof(wcommand));
if(wcommand == NULL) {
fprintf(stderr, "Unicode Handling Error (malloc)\n");
exit(1);
}
mbstowcs(wcommand, command, wcommand_characters+1);
wcommand_columns = wcswidth(wcommand, -1);
get_terminal_size();
/* Catch keyboard interrupts so we can put tty back in a sane state. */
signal(SIGINT, die);
signal(SIGTERM, die);
signal(SIGHUP, die);
signal(SIGWINCH, winch_handler);
/* Set up tty for curses use. */
curses_started = 1;
initscr();
if (option_color) {
if (has_colors()) {
start_color();
use_default_colors();
init_ansi_colors();
} else
option_color = 0;
}
nonl();
noecho();
cbreak();
if (precise_timekeeping)
next_loop = get_time_usec();
for (;;) {
time_t t = time(NULL);
char *ts = ctime(&t);
int tsl = strlen(ts);
char *header;
FILE *p;
int x, y;
int oldeolseen = 1;
if (screen_size_changed) {
get_terminal_size();
resizeterm(height, width);
clear();
/* redrawwin(stdscr); */
screen_size_changed = 0;
first_screen = 1;
}
if (show_title) {
// left justify interval and command,
// right justify time, clipping all to fit window width
int hlen = asprintf(&header, "Every %.1fs: ", interval);
// the rules:
// width < tsl : print nothing
// width < tsl + hlen + 1: print ts
// width = tsl + hlen + 1: print header, ts
// width < tsl + hlen + 4: print header, ..., ts
// width < tsl + hlen + wcommand_columns: print header, truncated wcommand, ..., ts
// width > "": print header, wcomand, ts
// this is slightly different from how it used to be
if(width >= tsl) {
if(width >= tsl + hlen + 1) {
mvaddstr(0, 0, header);
if(width >= tsl + hlen + 2) {
if(width < tsl + hlen + 4) {
mvaddstr(0, width - tsl - 4, "... ");
}else{
if(width < tsl + hlen + wcommand_columns) {
// print truncated
int avail_columns = width - tsl - hlen;
int using_columns = wcommand_columns;
int using_characters = wcommand_characters;
while(using_columns > avail_columns - 4) {
using_characters--;
using_columns = wcswidth(wcommand, using_characters);
}
mvaddnwstr(0, hlen, wcommand, using_characters);
mvaddstr(0, width - tsl - 4, "... ");
}else{
mvaddwstr(0, hlen, wcommand);
}
}
}
}
mvaddstr(0, width - tsl + 1, ts);
}
free(header);
}
/* allocate pipes */
if (pipe(pipefd)<0) {
perror("pipe");
do_exit(7);
}
/* flush stdout and stderr, since we're about to do fd stuff */
fflush(stdout);
fflush(stderr);
/* fork to prepare to run command */
child=fork();
if (child<0) { /* fork error */
perror("fork");
do_exit(2);
} else if (child==0) { /* in child */
close (pipefd[0]); /* child doesn't need read side of pipe */
close (1); /* prepare to replace stdout with pipe */
if (dup2 (pipefd[1], 1)<0) { /* replace stdout with write side of pipe */
perror("dup2");
exit(3);
}
dup2(1, 2); /* stderr should default to stdout */
if (option_exec) { /* pass command to exec instead of system */
if (execvp(command_argv[0], command_argv)==-1) {
perror("exec");
exit(4);
}
} else {
status=system(command); /* watch manpage promises sh quoting */
/* propagate command exit status as child exit status */
if (!WIFEXITED(status)) { /* child exits nonzero if command does */
exit(1);
} else {
exit(WEXITSTATUS(status));
}
}
}
/* otherwise, we're in parent */
close(pipefd[1]); /* close write side of pipe */
if ((p=fdopen(pipefd[0], "r"))==NULL) {
perror("fdopen");
do_exit(5);
}
for (y = show_title; y < height; y++) {
int eolseen = 0, tabpending = 0;
wint_t carry = WEOF;
for (x = 0; x < width; x++) {
wint_t c = L' ';
int attr = 0;
if (!eolseen) {
/* if there is a tab pending, just spit spaces until the
next stop instead of reading characters */
if (!tabpending)
do {
if(carry == WEOF) {
c = my_getwc(p);
}else{
c = carry;
carry = WEOF;
}
}while (c != WEOF && !isprint(c) && c<128
&& wcwidth(c) == 0
&& c != L'\n'
&& c != L'\t'
&& (c != L'\033' || option_color != 1));
if (c == L'\033' && option_color == 1) {
x--;
process_ansi(p);
continue;
}
if (c == L'\n')
if (!oldeolseen && x == 0) {
x = -1;
continue;
} else
eolseen = 1;
else if (c == L'\t')
tabpending = 1;
if (x==width-1 && wcwidth(c)==2) {
y++;
x = -1; //process this double-width
carry = c; //character on the next line
continue; //because it won't fit here
}
if (c == WEOF || c == L'\n' || c == L'\t')
c = L' ';
if (tabpending && (((x + 1) % 8) == 0))
tabpending = 0;
}
move(y, x);
if (option_differences) {
cchar_t oldc;
in_wch(&oldc);
attr = !first_screen
&& ((wchar_t)c != oldc.chars[0]
||
(option_differences_cumulative
&& (oldc.attr & A_ATTRIBUTES)));
}
if (attr)
standout();
addnwstr((wchar_t*)&c,1);
if (attr)
standend();
if(wcwidth(c) == 0) { x--; }
if(wcwidth(c) == 2) { x++; }
}
oldeolseen = eolseen;
}
fclose(p);
/* harvest child process and get status, propagated from command */
if (waitpid(child, &status, 0)<0) {
perror("waitpid");
do_exit(8);
};
/* if child process exited in error, beep if option_beep is set */
if ((!WIFEXITED(status) || WEXITSTATUS(status))) {
if (option_beep) beep();
if (option_errexit) do_exit(8);
}
first_screen = 0;
refresh();
if (precise_timekeeping) {
watch_usec_t cur_time = get_time_usec();
next_loop += USECS_PER_SEC*interval;
if (cur_time < next_loop)
usleep(next_loop - cur_time);
} else
usleep(interval * 1000000);
}
endwin();
return 0;
}
int main(int argc, char *argv[]) {
if( argc == 2 ) {
//printf("The argument supplied is %s\n", argv[1]);
fileToOpen = new char[strlen(argv[1])+1];
strcpy(fileToOpen, argv[1]);
fileNameSupplied = true;
}
//Initiate the NCurses System
initscr();
keypad(stdscr, TRUE);
curs_set(1);
noecho();
//Set the Screen Parameters
getmaxyx(stdscr, WINHEIGHT, WINWIDTH);
//App Name boiler plate!
mvprintw(0, 0, "%s", applicationName);
//Top Bar below menu
attron(A_REVERSE);
for (int i = 0; i < WINWIDTH; i++) {
mvaddch(1, i, ' ');
}
//Bottom Status Bar
for (int i = 0; i < WINWIDTH; i++) {
mvaddch(WINHEIGHT-1, i, ' ');
}
mvprintw(WINHEIGHT-1, 1, "^X:QUIT");
mvprintw(WINHEIGHT-1, 10, "^S:SAVE");
mvprintw(WINHEIGHT-1, 20, "F1:HELP");
mvprintw(WINHEIGHT-1, WINWIDTH-4, "INS");
attroff(A_REVERSE);
refresh();
//displayHelp();
WINDOW* textWin = newwin(WINHEIGHT-3, WINWIDTH, 2, 0);
wrefresh(textWin);
twin* tEditorWin;
if (fileNameSupplied == true) { //name was supplied
if (fileExists(fileToOpen)) { //file exists, so open it
tEditorWin = new twin(textWin, fileToOpen, WINHEIGHT-3, WINWIDTH);
} else { //doesn't exist, so create and open
if (createFile(fileToOpen) == true) {
tEditorWin = new twin(textWin, fileToOpen, WINHEIGHT-3, WINWIDTH);
} else {
printf("Error creating file. Please check access.\n");
exit(1);
}
}
} else {
fileToOpen = new char[strlen((char*)"unnamed.txt")+1];
strcpy(fileToOpen, (char*)"unnamed.txt");
fileNameSupplied = true;
if (createFile(fileToOpen) == true) {
tEditorWin = new twin(textWin, fileToOpen, WINHEIGHT-3, WINWIDTH);
} else {
printf("Error creating file. Please check access.\n");
exit(1);
}
}
tEditorWin->process();
//getch();
delete tEditorWin;
endwin();
return 0;
}
/*
init_nhwindows(int* argcp, char** argv)
-- Initialize the windows used by NetHack. This can also
create the standard windows listed at the top, but does
not display them.
-- Any commandline arguments relevant to the windowport
should be interpreted, and *argcp and *argv should
be changed to remove those arguments.
-- When the message window is created, the variable
iflags.window_inited needs to be set to TRUE. Otherwise
all plines() will be done via raw_print().
** Why not have init_nhwindows() create all of the "standard"
** windows? Or at least all but WIN_INFO? -dean
*/
void curses_init_nhwindows(int* argcp, char** argv)
{
#ifdef PDCURSES
char window_title[BUFSZ];
#endif
#ifdef XCURSES
base_term = Xinitscr(*argcp, argv);
#else
base_term = initscr();
#endif
#ifdef TEXTCOLOR
if (has_colors())
{
start_color();
curses_init_nhcolors();
}
else
{
iflags.use_color = FALSE;
set_option_mod_status("color", SET_IN_FILE);
iflags.wc2_guicolor = FALSE;
set_wc2_option_mod_status(WC2_GUICOLOR, SET_IN_FILE);
}
#else
iflags.use_color = FALSE;
set_option_mod_status("color", SET_IN_FILE);
iflags.wc2_guicolor = FALSE;
set_wc2_option_mod_status(WC2_GUICOLOR, SET_IN_FILE);
#endif
noecho();
raw();
meta(stdscr, TRUE);
orig_cursor = curs_set(0);
keypad(stdscr, TRUE);
#ifdef NCURSES_VERSION
# ifdef __APPLE__
ESCDELAY = 25;
# else
set_escdelay(25);
# endif /* __APPLE__ */
#endif /* NCURSES_VERSION */
#ifdef PDCURSES
# ifdef DEF_GAME_NAME
# ifdef VERSION_STRING
sprintf(window_title, "%s %s", DEF_GAME_NAME, VERSION_STRING);
# else
sprintf(window_title, "%s", DEF_GAME_NAME);
# endif /* VERSION_STRING */
# else
# ifdef VERSION_STRING
sprintf(window_title, "%s %s", "NetHack", VERSION_STRING);
# else
sprintf(window_title, "%s", "NetHack");
# endif /* VERSION_STRING */
# endif /* DEF_GAME_NAME */
PDC_set_title(window_title);
PDC_set_blink(TRUE); /* Only if the user asks for it! */
timeout(1);
(void)getch();
timeout(-1);
#endif /* PDCURSES */
getmaxyx(base_term, term_rows, term_cols);
counting = FALSE;
curses_init_options();
if ((term_rows < 15) || (term_cols < 40))
{
panic("Terminal too small. Must be minumum 40 width and 15 height");
}
curses_create_main_windows();
curses_init_mesg_history();
curses_display_splash_window();
}
int checklogfile_new(char *filename)
{
int lineno;
int tooshort;
char buffer[160];
FILE *fp;
/* check if logfile exist and can be opened for read */
if ((fp = fopen(filename, "r")) == NULL) {
if (errno == EACCES) {
showstring( "Can not access log file: ", filename);
return 1;
}
if (errno == ENOENT) {
/* File not found, create new one */
showmsg( "Log file not found, creating new one");
sleep(2);
if ((fp = fopen(filename, "w")) == NULL) {
/* cannot create logfile */
showmsg( "Creating logfile not possible");
return 1;
}
/* New logfile created */
fclose(fp);
return 0;
}
}
/* check each line of the logfile of correct format */
lineno = 0;
tooshort = 0;
while (fgets(buffer, sizeof(buffer), fp)) {
int band, linelen;
int bandok = 0;
lineno++;
/* if no logline -> complain and back */
band = atoi(buffer);
if ((band == 160) ||
(band == 80) ||
(band == 40) ||
(band == 30) ||
(band == 20) ||
(band == 17) ||
(band == 15) ||
(band == 12) ||
(band == 10))
bandok = 1;
if (!((buffer[0] == ';') || bandok)) {
/* msg no valid logline in line #, cannot handle it */
shownr( "No valid log line in line ", lineno);
return 1;
}
linelen = strlen(buffer);
/* if to long -> complain and back */
if (linelen > LOGLINELEN) {
/* msg length of line # to long,
* cannot handle that log file format */
shownr( "Log line to long in line ", lineno);
showmsg( "Can not handle that log format");
return 1;
}
/* if to short -> remember */
if (linelen < LOGLINELEN) {
tooshort = 1;
}
}
fclose(fp);
if (tooshort) {
char c;
/* some lines in logfile are too short, maybe old logfile format */
showmsg( "Some log lines are too short (maybe an old log format)!" );
showmsg( "Shall I try to repair? Y/(N) " );
echo();
c =toupper( getch() );
noecho();
if (c != 'Y') {
return 1; /* giving up */
}
/* trying to repair */
return repair_log(filename);
}
return 0;
}
int window_online_print()
{
int y,x;
char buf[250];
curseson(); cbreak(); noecho(); nonl(); keypad(stdscr,TRUE);
getmaxyx(stdscr,y,x);
attrset(A_NORMAL);
attrset(COLOR_PAIR(14));
snprintf(buf, x,
"whoIam : %s %140.140s", cfg.identity, " ");
mvaddnstr(y+gui_window_online.y0,
0,
buf,
x-1);
if (josua_online_status==EXOSIP_NOTIFY_UNKNOWN)
snprintf(buf, x,
"IM status: %s %140.140s", "unknown", " ");
else if (josua_online_status==EXOSIP_NOTIFY_PENDING)
snprintf(buf, x,
"IM status: %s %140.140s", "pending", " ");
else if (josua_online_status==EXOSIP_NOTIFY_ONLINE)
snprintf(buf, x,
"IM status: %s %140.140s", "Online", " ");
else if (josua_online_status==EXOSIP_NOTIFY_BUSY)
snprintf(buf, x,
"IM status: %s %140.140s", "Busy", " ");
else if (josua_online_status==EXOSIP_NOTIFY_BERIGHTBACK)
snprintf(buf, x,
"IM status: %s %140.140s", "Be Right Back", " ");
else if (josua_online_status==EXOSIP_NOTIFY_AWAY)
snprintf(buf, x,
"IM status: %s %140.140s", "Away", " ");
else if (josua_online_status==EXOSIP_NOTIFY_ONTHEPHONE)
snprintf(buf, x,
"IM status: %s %140.140s", "On The Phone", " ");
else if (josua_online_status==EXOSIP_NOTIFY_OUTTOLUNCH)
snprintf(buf, x,
"IM status: %s %140.140s", "Out To Lunch", " ");
else if (josua_online_status==EXOSIP_NOTIFY_CLOSED)
snprintf(buf, x,
"IM status: %s %140.140s", "Closed", " ");
else
snprintf(buf, x,
"IM status: ?? %140.140s" , " ");
mvaddnstr(y+gui_window_online.y0+1,
0,
buf,
x-1);
if (josua_registration_status==-1)
{
snprintf(buf, x,
"registred: --Not registred-- %140.140s", " ");
mvaddnstr(y+gui_window_online.y0+2,
0,
buf,
x-1);
}
else if (199<josua_registration_status && josua_registration_status<300)
{
snprintf(buf, x,
"registred: [%i %s] %s %140.140s",
josua_registration_status,
josua_registration_reason_phrase,
josua_registration_server, " ");
mvaddnstr(y+gui_window_online.y0+2,
0,
buf,
x-1);
}
else if (josua_registration_status>299)
{
snprintf(buf, x,
"registred: [%i %s] %s %140.140s",
josua_registration_status,
josua_registration_reason_phrase,
josua_registration_server, " ");
mvaddnstr(y+gui_window_online.y0+2,
0,
buf,
x-1);
}
else if (josua_registration_status==0)
{
snprintf(buf, x,
"registred: [no answer] %s %140.140s",
josua_registration_server, " ");
mvaddnstr(y+gui_window_online.y0+2,
0,
buf,
x-1);
}
return 0;
}
int main(int argc, char *argv[])
{
WINDOW *win;
int key, old_option = -1, new_option = 0, i;
bool quit = FALSE;
setlocale(LC_ALL, "");
if (initTest(&win, argc, argv))
return 1;
for( i = 1; i < argc; i++)
if( argv[i][0] == '-')
switch( argv[i][1])
{
case 'b': case 'B':
PDC_set_blink( TRUE);
break;
case 'l': case 'L':
setlocale( LC_ALL, argv[i] + 2);
break;
case 'i': case 'I':
background_index = (short)atoi( argv[i] + 2);
break;
case 'm': case 'M':
PDC_return_key_modifiers( TRUE);
break;
default:
break;
}
#ifdef A_COLOR
if (has_colors())
{
init_pair(1, COLOR_WHITE, COLOR_BLUE);
wbkgd(win, COLOR_PAIR(1));
}
else
#endif
wbkgd(win, A_REVERSE);
erase();
display_menu(old_option, new_option);
while (1)
{
noecho();
keypad(stdscr, TRUE);
raw();
key = getch();
switch(key)
{
case 10:
case 13:
case KEY_ENTER:
old_option = -1;
erase();
refresh();
(*command[new_option].function)(win);
erase();
display_menu(old_option, new_option);
break;
case KEY_PPAGE:
case KEY_HOME:
old_option = new_option;
new_option = 0;
display_menu(old_option, new_option);
break;
case KEY_NPAGE:
case KEY_END:
old_option = new_option;
new_option = MAX_OPTIONS - 1;
display_menu(old_option, new_option);
break;
case KEY_UP:
old_option = new_option;
new_option = (new_option == 0) ?
new_option : new_option - 1;
display_menu(old_option, new_option);
break;
case KEY_DOWN:
old_option = new_option;
new_option = (new_option == MAX_OPTIONS - 1) ?
new_option : new_option + 1;
display_menu(old_option, new_option);
break;
case KEY_RESIZE:
# ifdef PDCURSES
resize_term(0, 0);
# endif
old_option = -1;
erase();
display_menu(old_option, new_option);
break;
case 'Q':
case 'q':
quit = TRUE;
}
if (quit == TRUE)
break;
}
delwin(win);
endwin();
return 0;
}
// Run the user's paddle
void *moveme(void* vp) {
int ch;
// get the extents of the screen
int maxx;
int maxy;
getmaxyx(win, maxy, maxx);
int vpos = maxy / 2;
// draw the default paddle
drawPaddle(vpos);
while (!quit) {
(void) noecho();
ch = getch();
switch (ch) {
case KEY_UP: // The user has pressed the up arrow. Move the paddle one pixel upwards if possible.
if (!pauseGame) {
undrawPaddle(vpos);
vpos--;
if (vpos < 0 + PADDLE_SIZE / 2) {
vpos = PADDLE_SIZE / 2;
}
drawPaddle(vpos);
}
break;
case KEY_DOWN: // The user has pressed the down arrow. Move the paddle one pixel downward if possible.
if (!pauseGame) {
undrawPaddle(vpos);
vpos++;
if (vpos > (maxy - (PADDLE_SIZE / 2))) {
vpos = (maxy - (PADDLE_SIZE / 2));
}
drawPaddle(vpos);
}
break;
case 'q': // The user has pressed the quiz button. Exit the game.
quit = true;
break;
case 'p':
pauseGame = !pauseGame;
break;
case '+': // The user pressed the plus key to increase the speed of ball
pthread_mutex_lock(&mutex);
int temp = ballMovementDelay / 2;
if(temp > 0)
ballMovementDelay = temp;
pthread_mutex_unlock(&mutex);
break;
case '-': // The user pressed the minus key to decrease the speed of ball
pthread_mutex_lock(&mutex);
ballMovementDelay *= 2;
pthread_mutex_unlock(&mutex);
break;
default:
break;
}
}
return NULL;
}
void inputTest(WINDOW *win)
{
int w, h, bx, by, sw, sh, i, c, num = 0;
int line_to_use = 3;
char buffer[80];
WINDOW *subWin;
static const char spinner[4] = "/-\\|";
int spinner_count = 0;
wclear(win);
getmaxyx(win, h, w);
getbegyx(win, by, bx);
sw = w / 3;
sh = h / 3;
if ((subWin = subwin(win, sh, sw, by + h - sh - 2, bx + w - sw - 2))
== NULL)
return;
#ifdef A_COLOR
if (has_colors())
{
init_pair(2, COLOR_WHITE, COLOR_RED);
wbkgd(subWin, COLOR_PAIR(2) | A_BOLD);
}
else
#endif
wbkgd(subWin, A_BOLD);
box(subWin, ACS_VLINE, ACS_HLINE);
wrefresh(win);
nocbreak();
wclear (win);
mvwaddstr(win, 1, 1,
"Press keys (or mouse buttons) to show their names");
mvwaddstr(win, 2, 1, "Press spacebar to finish");
wrefresh(win);
keypad(win, TRUE);
raw();
noecho();
wtimeout(win, 200);
#ifdef PDCURSES
mouse_set(ALL_MOUSE_EVENTS | REPORT_MOUSE_POSITION);
PDC_save_key_modifiers(TRUE);
// PDC_return_key_modifiers(TRUE);
#endif
curs_set(0); /* turn cursor off */
while (1)
{
while (1)
{
c = wgetch(win);
if (c == ERR)
{
spinner_count++;
if (spinner_count == 4)
spinner_count = 0;
mvwaddch(win, line_to_use, 3, spinner[spinner_count]);
wrefresh(win);
}
else
break;
}
#ifdef PDCURSES
// wmove(win, line_to_use + 1, 18);
// wclrtoeol(win);
#endif
mvwaddstr(win, line_to_use, 5, "Key Pressed: ");
wclrtoeol(win);
wprintw( win, "(%x) ", c);
if (c >= KEY_MIN)
wprintw(win, "%s", keyname(c));
else if (isprint(c))
wprintw(win, "%c", c);
else
wprintw(win, "%s", unctrl(c));
#ifdef PDCURSES
if (c == KEY_MOUSE)
{
int button = 0, status = 0;
request_mouse_pos();
if (BUTTON_CHANGED(1))
button = 1;
else if (BUTTON_CHANGED(2))
button = 2;
else if (BUTTON_CHANGED(3))
button = 3;
else if (BUTTON_CHANGED(4)) /* added 21 Jan 2011: BJG */
button = 4;
else if (BUTTON_CHANGED(5))
button = 5;
if( button)
status = (button > 3 ? Mouse_status.xbutton[(button) - 4] :
Mouse_status.button[(button) - 1]);
wmove(win, line_to_use, 5);
wclrtoeol(win);
wprintw(win, "Button %d: ", button);
if (MOUSE_MOVED)
waddstr(win, "moved: ");
else if (MOUSE_WHEEL_UP)
waddstr(win, "wheel up: ");
else if (MOUSE_WHEEL_DOWN)
waddstr(win, "wheel dn: ");
else if (MOUSE_WHEEL_LEFT)
waddstr(win, "wheel lt: ");
else if (MOUSE_WHEEL_RIGHT)
waddstr(win, "wheel rt: ");
else if ((status & BUTTON_ACTION_MASK) == BUTTON_PRESSED)
waddstr(win, "pressed: ");
else if ((status & BUTTON_ACTION_MASK) == BUTTON_CLICKED)
waddstr(win, "clicked: ");
else if ((status & BUTTON_ACTION_MASK) == BUTTON_DOUBLE_CLICKED)
waddstr(win, "double: ");
else if ((status & BUTTON_ACTION_MASK) == BUTTON_TRIPLE_CLICKED)
waddstr(win, "triple: ");
else
waddstr(win, "released: ");
wprintw(win, "Posn: Y: %d X: %d", MOUSE_Y_POS, MOUSE_X_POS);
if (button && (status & BUTTON_MODIFIER_MASK))
{
if (status & BUTTON_SHIFT)
waddstr(win, " SHIFT");
if (status & BUTTON_CONTROL)
waddstr(win, " CONTROL");
if (status & BUTTON_ALT)
waddstr(win, " ALT");
}
}
else if (PDC_get_key_modifiers())
{
waddstr(win, " Modifier(s):");
if (PDC_get_key_modifiers() & PDC_KEY_MODIFIER_SHIFT)
waddstr(win, " SHIFT");
if (PDC_get_key_modifiers() & PDC_KEY_MODIFIER_CONTROL)
waddstr(win, " CONTROL");
if (PDC_get_key_modifiers() & PDC_KEY_MODIFIER_ALT)
waddstr(win, " ALT");
if (PDC_get_key_modifiers() & PDC_KEY_MODIFIER_NUMLOCK)
waddstr(win, " NUMLOCK");
}
#endif
wrefresh(win);
if (c == ' ')
break;
line_to_use++;
if( line_to_use == 10)
line_to_use = 3;
}
wtimeout(win, -1); /* turn off timeout() */
curs_set(1); /* turn cursor back on */
#ifdef PDCURSES
mouse_set(0L);
PDC_save_key_modifiers(FALSE);
// PDC_return_key_modifiers(FALSE);
#endif
wclear(win);
mvwaddstr(win, 2, 1, "Press some keys for 5 seconds");
mvwaddstr(win, 1, 1, "Pressing ^C should do nothing");
wrefresh(win);
werase(subWin);
box(subWin, ACS_VLINE, ACS_HLINE);
for (i = 0; i < 5; i++)
{
mvwprintw(subWin, 1, 1, "Time = %d", i);
wrefresh(subWin);
napms(1000);
flushinp();
}
delwin(subWin);
werase(win);
flash();
wrefresh(win);
napms(500);
flushinp();
mvwaddstr(win, 2, 1, "Press a key, followed by ENTER");
wmove(win, 9, 10);
wrefresh(win);
echo();
keypad(win, TRUE);
raw();
wgetnstr(win, buffer, 3);
flushinp();
wmove(win, 9, 10);
wdelch(win);
mvwaddstr(win, 4, 1, "The character should now have been deleted");
Continue(win);
refresh();
wclear(win);
echo();
buffer[0] = '\0';
mvwaddstr(win, 3, 2, "The window should have moved");
mvwaddstr(win, 4, 2,
"This text should have appeared without you pressing a key");
mvwaddstr(win, 6, 2, "Enter a number then a string seperated by space");
mvwin(win, 2, 1);
wrefresh(win);
mvwscanw(win, 7, 6, "%d %s", &num, buffer);
mvwprintw(win, 8, 6, "String: %s Number: %d", buffer, num);
Continue(win);
refresh();
wclear(win);
echo();
mvwaddstr(win, 3, 2, "Enter a 5 character string: ");
wgetnstr(win, buffer, 5);
mvwprintw(win, 4, 2, "String: %s", buffer);
Continue(win);
}
/* This function can only be called if a cd has already been selected and
* stored in the globals `current_cd` and `current_cat`. */
void list_tracks() {
FILE *tracks_fp;
char entry[MAX_ENTRY];
int cat_length;
int lines_op = 0;
WINDOW *track_pad;
int ntracks = 0;
int key;
int first_line = 0;
// handle the case of no current cd
if (current_cd[0] == '\0') {
mvprintw(ERROR_LINE, 0, "You must select a CD before listing tracks");
get_return();
return;
}
clear_all_screen();
// First, count the number of tracks for the current CD. close the
// file when done so we can reopen before listing them.
cat_length = strlen(current_cat);
tracks_fp = fopen(TRACKS_FILE, "r");
if (!tracks_fp) return;
while (fgets(entry, MAX_ENTRY, tracks_fp)) {
if (strncmp(current_cat, entry, cat_length) == 0) {
ntracks++;
}
}
fclose(tracks_fp);
// make a new pad. Make sure it is big enough to fill up the boxed region
// even if there are no listings.
// NOTE: we don't actually make a box for this operation... the box is
// only used in update_cd. But we are reusing the same region.
track_pad = newpad(ntracks + 1 + BOXED_LINES, BOXED_COLS + 1);
if (!track_pad) return;
// reopen the tracks file
tracks_fp = fopen(TRACKS_FILE, "r");
if (!tracks_fp) return;
// print out all the tracks onto the pad.
mvprintw(4, 0, "CD Track Listing\n");
while (fgets(entry, MAX_ENTRY, tracks_fp)) {
if (strncmp(current_cat, entry, cat_length) == 0) {
// print the track info. Use `cat_length+1` bc of the comma
// this actually is kind of strange because we are still
// printing a kind of ugly comma-separated track number and
// name, but it works. You could make it better as an exercise.
mvwprintw(track_pad, lines_op++, 0, "%s", entry + cat_length + 1);
}
}
fclose(tracks_fp);
// tell the user what to do
if (lines_op > BOXED_LINES) {
mvprintw(MESSAGE_LINE, 0, "Arrows to scroll, RETURN or q to exit.");
} else {
mvprintw(MESSAGE_LINE, 0, "RETURN or q to exit.");
}
// set up the control keys and such, refresh the main screen
wrefresh(stdscr);
keypad(stdscr, TRUE);
cbreak();
noecho();
// start up a loop over control keys; inside the loop refresh the pad
key = 0;
while (key != '\n' && key != KEY_ENTER && key != 'q') {
if (key == KEY_UP) {
if (first_line > 0) {
first_line--;
}
} else if (key == KEY_DOWN) {
if (first_line + BOXED_LINES < ntracks - 1) {
first_line++;
}
}
prefresh(track_pad, first_line, 0,
BOX_LINE_POS, BOX_COL_POS,
BOX_LINE_POS + BOXED_LINES, BOX_COL_POS + BOXED_COLS);
key = getch();
}
}
int main(void)
{
int ch;
WINDOW *reg_win;
const char *runhalt[]={"Running","Halted ","Trap "};
preload();
rim();
df32_init();
// get ncurses going
initscr();
raw(); // turn off line buffering
noecho();
keypad(stdscr,TRUE); // lets us use function keys etc
scrollok(stdscr,TRUE);
reg_win=newwin(1,79,23,0); // define a register window
nodelay(stdscr, TRUE); // nonblocking tty IO
// set up the registers and stuff
l=0;ac=0; // AC and Link
pc=07000; // PC is set for ODT HIGH
sr=0; // SR is clear
ifr=0; ifrb=0; dfr=0; // Extended memory registers
tty_pun_f=1; // TTY flags preset
tty_rdr_f=0;
tty_pun_clk=0;
cycles=0; // cycle count
halt=0;
// initial display code goes here
mvwprintw(reg_win,0,0,"PC: %05o L: %o AC: %04o MB: %04o %s", (010000*ifr)+pc,l,ac,core[(010000*ifr)+pc],runhalt[halt]);
wrefresh(reg_win);
// main loop begins
while(ch!=KEY_F(12)) { // if the key pressed was F11, we'll leave
ch = getch(); // get a keystroke
if (ch!=ERR) { // there actually *is* a keystroke
switch (ch) {
case KEY_F(2): // F2 is single-step
functionmesh(core[pc+(010000*ifr)]); // do the instruction
break;
case KEY_F(3): // F3 is halt/run
halt=!halt; // pretty simple really
break;
case KEY_F(4): // interrupt (sssh, nasty cheat)
core[00000]=pc+1;
pc=00001;
break;
case KEY_F(9):
pc=07000;
halt=0;
break;
default:
tty_rdr_buf=ch; // keep that ready for later, in the reader buffer
tty_rdr_f=1; // raise the flag, there's a character ready
}
// Eeeew. This bit is horrible. It prints the registers when we single-step
// it's actually done every time we press a key. Ick. I hate this bit
// in fact, let's have a *** FIXME *** right here
mvwprintw(reg_win,0,0,"PC: %05o L: %o AC: %04o MB: %04o %s", (010000*ifr)+pc,l,ac,core[(010000*ifr)+pc],runhalt[halt]);
wrefresh(reg_win);
}
cycles++; // increase the cycle counter
if(!halt) { // CPU is running, let's do the instruction
functionmesh(core[pc+(01000*ifr)]);
} // we can always add more here later
tty_run(); // handle the TTY
df32_run();
// more peripheral handlers will go here
}
endwin(); // leave ncurses mode
return (0);
}
int os_inner_init(const char* title)
{
const char* display;
struct utsname uts;
struct sigaction term_action;
struct sigaction quit_action;
struct sigaction hup_action;
struct sigaction pipe_action;
#ifdef USE_SDL
SDL_version compiled;
#endif
unsigned char endian[4] = { 0x1, 0x2, 0x3, 0x4 };
uint32 endian_little = 0x04030201;
uint32 endian_big = 0x01020304;
log_std(("os: os_inner_init\n"));
if (uname(&uts) != 0) {
log_std(("ERROR:os: uname failed\n"));
} else {
log_std(("os: sys %s\n", uts.sysname));
log_std(("os: release %s\n", uts.release));
log_std(("os: version %s\n", uts.version));
log_std(("os: machine %s\n", uts.machine));
}
#if HAVE_SYSCONF
#ifdef _SC_CLK_TCK
log_std(("os: sysconf(_SC_CLK_TCK) %ld\n", sysconf(_SC_CLK_TCK)));
#endif
#ifdef _SC_NPROCESSORS_CONF
log_std(("os: sysconf(_SC_NPROCESSORS_CONF) %ld\n", sysconf(_SC_NPROCESSORS_CONF)));
#endif
#ifdef _SC_NPROCESSORS_ONLN
log_std(("os: sysconf(_SC_NPROCESSORS_ONLN) %ld\n", sysconf(_SC_NPROCESSORS_ONLN)));
#endif
#ifdef _SC_PHYS_PAGES
log_std(("os: sysconf(_SC_PHYS_PAGES) %ld\n", sysconf(_SC_PHYS_PAGES)));
#endif
#ifdef _SC_AVPHYS_PAGES
log_std(("os: sysconf(_SC_AVPHYS_PAGES) %ld\n", sysconf(_SC_AVPHYS_PAGES)));
#endif
#ifdef _SC_CHAR_BIT
log_std(("os: sysconf(_SC_CHAR_BIT) %ld\n", sysconf(_SC_CHAR_BIT)));
#endif
#ifdef _SC_LONG_BIT
log_std(("os: sysconf(_SC_LONG_BIT) %ld\n", sysconf(_SC_LONG_BIT)));
#endif
#ifdef _SC_WORD_BIT
log_std(("os: sysconf(_SC_WORD_BIT) %ld\n", sysconf(_SC_WORD_BIT)));
#endif
#endif
#ifdef _POSIX_PRIORITY_SCHEDULING /* OSDEF Check for POSIX scheduling */
log_std(("os: scheduling available\n"));
#else
log_std(("os: scheduling NOT available\n"));
#endif
/* print the compiler version */
#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) /* OSDEF Detect compiler version */
#define COMPILER_RESOLVE(a) #a
#define COMPILER(a, b, c) COMPILER_RESOLVE(a) "." COMPILER_RESOLVE(b) "." COMPILER_RESOLVE(c)
log_std(("os: compiler GNU %s\n", COMPILER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)));
#else
log_std(("os: compiler unknown\n"));
#endif
/* check for int size */
if (sizeof(uint8) != 1) {
target_err("The program is compiled with invalid uint8 type.\n");
return -1;
}
if (sizeof(uint16) != 2) {
target_err("The program is compiled with invalid uint16 type.\n");
return -1;
}
if (sizeof(uint32) != 4) {
target_err("The program is compiled with invalid uint32 type.\n");
return -1;
}
if (sizeof(uint64) != 8) {
target_err("The program is compiled with invalid uint64 type.\n");
return -1;
}
/* check for the endianess */
#ifdef USE_MSB
log_std(("os: compiled big endian system\n"));
if (memcmp(endian, &endian_big, 4) != 0) {
target_err("The program is compiled as bigendian but system doesn't appear to be bigendian.\n");
return -1;
}
#endif
#ifdef USE_LSB
log_std(("os: compiled little endian system\n"));
if (memcmp(endian, &endian_little, 4) != 0) {
target_err("The program is compiled as littleendian but system doesn't appear to be littleendian.\n");
return -1;
}
#endif
#ifdef USE_SMP
/* check the thread support */
if (os_thread() != 0) {
target_err("Error on the threading support.\n");
return -1;
}
#endif
/* get DISPLAY environment variable */
display = getenv("DISPLAY");
if (display)
log_std(("os: DISPLAY=%s\n", display));
else
log_std(("os: DISPLAY undef\n"));
/* probe the delay system */
os_delay();
if (!os_internal_wm_active()) {
log_std(("os: save term\n"));
if (tcgetattr(fileno(stdin), &OS.term) != 0) {
log_std(("ERROR:os: error getting the tty state.\n"));
OS.term_active = 0;
} else {
OS.term_active = 1;
}
}
#if defined(USE_X)
OS.x_active = 0;
{
int event_base, error_base;
int major_version, minor_version;
log_std(("os: XOpenDisplay()\n"));
OS.dga_display = XOpenDisplay(0);
if (OS.dga_display) {
OS.x_active = 1;
} else {
log_std(("WARNING:os: XOpenDisplay() failed. All the X drivers will be disabled.\n"));
}
}
#endif
#if defined(USE_SVGALIB)
OS.svgalib_active = 0;
if (!os_internal_wm_active()) {
int h;
log_std(("os: open /dev/svga\n"));
/* try opening the device, otherwise vga_init() will abort the program. */
h = open("/dev/svga", O_RDWR);
if (h >= 0) {
int res;
close(h);
vga_disabledriverreport();
/* check the version of the SVGALIB */
res = vga_setmode(-1);
if (res < 0 || res < 0x1911) { /* 1.9.11 */
log_std(("WARNING:os: invalid SVGALIB version %x. All the SVGALIB drivers will be disabled.\n", (int)res));
/* don't print the message. It may be a normal condition. */
/* target_nfo("Invalid SVGALIB version, you need SVGALIB version 1.9.x or 2.0.x.\nPlease upgrade or recompile without SVGALIB support.\n"); */
} else {
log_std(("os: vga_init()\n"));
if (vga_init() != 0) {
log_std(("os: vga_init() failed\n"));
target_err("Error initializing the SVGALIB video support.\n");
return -1;
}
OS.svgalib_active = 1;
}
} else {
log_std(("WARNING:os: open /dev/svga failed. All the SVGALIB drivers will be disabled.\n"));
/* don't print the message. It may be a normal condition. */
/* target_nfo("Error opening the SVGALIB device /dev/svga.\n"); */
}
} else {
log_std(("WARNING:os: vga_init() skipped because X is active. All the SVGALIB drivers will be disabled.\n"));
/* don't print the message. It may be a normal condition. */
/* target_nfo("SVGALIB not initialized because it's unusable in X.\n"); */
}
#endif
#if defined(USE_SDL)
log_std(("os: SDL_Init(SDL_INIT_NOPARACHUTE)\n"));
if (SDL_Init(SDL_INIT_NOPARACHUTE) != 0) {
log_std(("os: SDL_Init() failed, %s\n", SDL_GetError()));
target_err("Error initializing the SDL video support.\n");
return -1;
}
OS.sdl_active = 1;
SDL_VERSION(&compiled);
log_std(("os: compiled with sdl %d.%d.%d\n", compiled.major, compiled.minor, compiled.patch));
log_std(("os: linked with sdl %d.%d.%d\n", SDL_Linked_Version()->major, SDL_Linked_Version()->minor, SDL_Linked_Version()->patch));
#ifdef USE_MSB
if (SDL_BYTEORDER != SDL_BIG_ENDIAN) {
target_err("Invalid SDL endianess.\n");
return -1;
}
#endif
#ifdef USE_LSB
if (SDL_BYTEORDER != SDL_LIL_ENDIAN) {
target_err("Invalid SDL endianess.\n");
return -1;
}
#endif
#endif
#if defined(USE_SLANG)
OS.slang_active = 0;
if (!os_internal_wm_active()) {
log_std(("os: SLtt_get_terminfo()\n"));
SLtt_get_terminfo();
log_std(("os: SLsmg_init_smg()\n"));
SLsmg_init_smg();
OS.slang_active = 1;
} else {
log_std(("WARNING:os: SLang_init_tty() skipped because X is active. All the SLang drivers will be disabled.\n"));
}
#endif
#if defined(USE_CURSES)
OS.curses_active = 0;
if (!os_internal_wm_active()) {
log_std(("os: initscr()\n"));
initscr();
start_color();
cbreak();
noecho();
nonl();
OS.curses_active = 1;
} else {
log_std(("WARNING:os: curses initscr() skipped because X is active. All the curses drivers will be disabled.\n"));
}
#endif
/* set the titlebar */
sncpy(OS.title_buffer, sizeof(OS.title_buffer), title);
/* set some signal handlers */
/* STANDARD signals */
term_action.sa_handler = (void (*)(int))os_signal;
/* block external generated signals in the signal handler */
sigemptyset(&term_action.sa_mask);
sigaddset(&term_action.sa_mask, SIGALRM);
sigaddset(&term_action.sa_mask, SIGINT);
sigaddset(&term_action.sa_mask, SIGTERM);
sigaddset(&term_action.sa_mask, SIGHUP);
sigaddset(&term_action.sa_mask, SIGQUIT);
term_action.sa_flags = SA_RESTART | SA_SIGINFO;
/* external generated */
sigaction(SIGALRM, &term_action, 0);
sigaction(SIGINT, &term_action, 0);
sigaction(SIGTERM, &term_action, 0);
/* internal generated */
sigaction(SIGABRT, &term_action, 0);
sigaction(SIGFPE, &term_action, 0);
sigaction(SIGILL, &term_action, 0);
sigaction(SIGSEGV, &term_action, 0);
sigaction(SIGBUS, &term_action, 0);
/* HUP signal */
hup_action.sa_handler = os_hup_signal;
sigemptyset(&hup_action.sa_mask);
hup_action.sa_flags = SA_RESTART;
sigaction(SIGHUP, &hup_action, 0);
/* QUIT signal */
quit_action.sa_handler = os_quit_signal;
sigemptyset(&quit_action.sa_mask);
quit_action.sa_flags = SA_RESTART;
sigaction(SIGQUIT, &quit_action, 0);
/* PIPE signal, ignoring it force some functions to */
/* return with error. It happen for example on the LCD sockets. */
pipe_action.sa_handler = SIG_IGN;
sigemptyset(&pipe_action.sa_mask);
pipe_action.sa_flags = SA_RESTART;
sigaction(SIGPIPE, &pipe_action, 0);
return 0;
}
//void sigintcallback();
int main() {
//INIT stuff
initscr();
raw();
noecho();
timeout(-1); //turn off blocking
//signal(SIGINT, &sigintcallback);
char vorgabe[MAXPOS];
char versuch[MAXPOS]; //jede Eingabe
char getroffen[MAXPOS]; //getroffene Buchstaben
int schwarz, weiss; //zaehler fuer getroffene buchstaben
printw("Bitte geben sie ihre zu ratende Kombination ein (B,G,Y,O,R,M): ");
for(int i=0;i<MAXPOS; i++){ //lese Vorgabe ein
char buf;
do {
buf = toupper(getch());
}
while(buf<=MAXPOS+1);
vorgabe[i] = buf;
printw("_%c_", vorgabe[i]);
}
refresh(); //update screen
//sleep(1); //zur kontrolle
clear(); //clear screen
for(int v=0;v<=MAXVERSUCHE;v++){
for(int a=0;a<MAXPOS;a++) getroffen[a] = vorgabe[a]; //Wert kopieren
if(v==MAXVERSUCHE){
printw("Pech! Die richtige Kombination lautet: _");
for(int i=0;i<MAXPOS;i++){
printw("_%c_", vorgabe[i]);
}
putchar('_');
break;
}
else if(schwarz==MAXPOS){
printw("Gratulation! Geraten nach %d Versuchen.", v);
break;
}
schwarz=0; weiss=0; //clear variables
printw("%d. Versuch: ", v+1);
//gehe in Abfrageschleife
for(int i=0;i<MAXPOS; i++){ //lese Versuch ein
versuch[i] = toupper(getch());
printw("_%c_", versuch[i]);
}
//vergleiche Versuch mit Vorgabe
for(int vindex=0;vindex<MAXPOS; vindex++){ //gehe durch getroffen und versuch; index ist der einzelne char
if(versuch[vindex] == getroffen[vindex]){
schwarz++; //richtiger Char an richtiger Stelle
getroffen[vindex] = 0; //markieren
}
else{ //suche nun f�r den aktuellen index in versuch einen gleichen in getroffen
bool isDuplicate = false;
bool occuredOnce = false;
for(int gindex=0;gindex<MAXPOS;gindex++){ //gehe durch getroffen und suche nach uebereinstmmungen zum aktuellen vindex
if(getroffen[gindex] == versuch[vindex]){
for(int gr=0;gr<MAXPOS;gr++){
if(getroffen[gr] == vindex){
if(!occuredOnce) occuredOnce = true;
else isDuplicate = true;
}
}
if(!isDuplicate) weiss++; //irgendwo ein richtiger Char
versuch[vindex] = gindex+1; //markieren
}
}
}
}
printw("\t|| Schwarz: %d\t Weiss: %d\n", schwarz, weiss);
}
getch();
//printf("\e[2J\e[H"); //clrscr
endwin();
return 0;
}
static int ncurses_init_graphics(caca_display_t *dp)
{
static int curses_colors[] =
{
/* Standard curses colours */
COLOR_BLACK,
COLOR_BLUE,
COLOR_GREEN,
COLOR_CYAN,
COLOR_RED,
COLOR_MAGENTA,
COLOR_YELLOW,
COLOR_WHITE,
/* Extra values for xterm-16color */
COLOR_BLACK + 8,
COLOR_BLUE + 8,
COLOR_GREEN + 8,
COLOR_CYAN + 8,
COLOR_RED + 8,
COLOR_MAGENTA + 8,
COLOR_YELLOW + 8,
COLOR_WHITE + 8
};
mmask_t newmask;
int fg, bg, max;
dp->drv.p = malloc(sizeof(struct driver_private));
#if defined HAVE_GETENV && defined HAVE_PUTENV
ncurses_install_terminal(dp);
#endif
#if defined HAVE_SIGNAL
sigwinch_d = dp;
signal(SIGWINCH, sigwinch_handler);
#endif
#if defined HAVE_LOCALE_H
setlocale(LC_ALL, "");
#endif
_caca_set_term_title("caca for ncurses");
initscr();
keypad(stdscr, TRUE);
nonl();
raw();
noecho();
nodelay(stdscr, TRUE);
curs_set(0);
/* Activate mouse */
newmask = REPORT_MOUSE_POSITION | ALL_MOUSE_EVENTS;
mousemask(newmask, &dp->drv.p->oldmask);
mouseinterval(-1); /* No click emulation */
/* Set the escape delay to a ridiculously low value */
#if defined set_escdelay
set_escdelay(10);
#else
ESCDELAY = 10;
#endif
/* Activate colour */
start_color();
/* If COLORS == 16, it means the terminal supports full bright colours
* using setab and setaf (will use \e[90m \e[91m etc. for colours >= 8),
* we can build 16*16 colour pairs.
* If COLORS == 8, it means the terminal does not know about bright
* colours and we need to get them through A_BOLD and A_BLINK (\e[1m
* and \e[5m). We can only build 8*8 colour pairs. */
max = COLORS >= 16 ? 16 : 8;
for(bg = 0; bg < max; bg++)
for(fg = 0; fg < max; fg++)
{
/* Use ((max + 7 - fg) % max) instead of fg so that colour 0
* is light gray on black. Some terminals don't like this
* colour pair to be redefined. */
int col = ((max + 7 - fg) % max) + max * bg;
init_pair(col, curses_colors[fg], curses_colors[bg]);
dp->drv.p->attr[fg + 16 * bg] = COLOR_PAIR(col);
if(max == 8)
{
/* Bright fg on simple bg */
dp->drv.p->attr[fg + 8 + 16 * bg] = A_BOLD | COLOR_PAIR(col);
/* Simple fg on bright bg */
dp->drv.p->attr[fg + 16 * (bg + 8)] = A_BLINK
| COLOR_PAIR(col);
/* Bright fg on bright bg */
dp->drv.p->attr[fg + 8 + 16 * (bg + 8)] = A_BLINK | A_BOLD
| COLOR_PAIR(col);
}
}
caca_add_dirty_rect(dp->cv, 0, 0, dp->cv->width, dp->cv->height);
dp->resize.allow = 1;
caca_set_canvas_size(dp->cv, COLS, LINES);
dp->resize.allow = 0;
return 0;
}
int adduser(void)
{
/* Declarations */
getmaxyx(stdscr, y,x); /* Screen Sizes */
int key;
while(true)
{
drawauscreen(); /* Draw the Screen */
refresh();
do
{
key = getch();
switch(key)
{
/* Field Edit Keys which are number keys */
case '1':
echo();
if((loginname = malloc(sizeof(char) * USER_BUFFER + 1)) == NULL)
return(1);
attron(A_REVERSE);
mvprintw(7, 35, "_________________");
mvwgetnstr(stdscr, 7,35, loginname, 15);
attroff(A_REVERSE);
noecho();
break;
case '2':
echo();
if((usergecos = malloc(sizeof(char) * USER_BUFFER + 1)) == NULL)
return(1);
attron(A_REVERSE);
mvprintw(8, 35, "_________________");
mvwgetnstr(stdscr, 8,35, usergecos, 15);
attroff(A_REVERSE);
noecho();
break;
case '3':
echo();
if((userid = malloc(sizeof(char) * USER_BUFFER + 1)) == NULL)
return(1);
attron(A_REVERSE);
mvprintw(9, 35, "_________________");
mvwgetnstr(stdscr, 9,35, userid, 5);
attroff(A_REVERSE);
noecho();
break;
case '4':
echo();
if((groupid = malloc(sizeof(char) * USER_BUFFER + 1)) == NULL)
return(1);
attron(A_REVERSE);
mvprintw(10, 35, "_________________");
mvwgetnstr(stdscr, 10,35, groupid, 5);
attroff(A_REVERSE);
noecho();
break;
case '5':
echo();
if((usershell = malloc(sizeof(char) * USER_BUFFER + 1)) == NULL)
return(1);
attron(A_REVERSE);
mvprintw(11, 35, "_________________");
mvwgetnstr(stdscr, 11,35, usershell, 15);
attroff(A_REVERSE);
noecho();
break;
case '6':
echo();
if((homedir = malloc(sizeof(char) * USER_BUFFER + 1)) == NULL)
return(1);
attron(A_REVERSE);
mvprintw(12, 35, "_________________");
mvwgetnstr(stdscr, 12,35, homedir, 15);
attroff(A_REVERSE);
noecho();
break;
/* Function Key Controls */
case KEY_F(1): /* Help */
break;
case KEY_F(2): /* Refresh */
refresh();
break;
case KEY_F(3): /* Cancel Key */
break;
case KEY_F(4):
/* Reset Fields if statements to prevent crashing if pressed more than once. strcmp does cause segmentation fault */
if(loginname != "(cleared)")
free(loginname);
if(usergecos != "(cleared)")
free(usergecos);
if(usershell != "(cleared)")
free(usershell);
if(homedir != "(cleared)")
free(homedir);
if(userid != "(cleared)")
free(userid);
if(groupid != "(cleared)")
free(groupid);
loginname = "(cleared)";
usergecos = "(cleared)";
usershell = "(cleared)";
homedir = "(cleared)";
userid = "(cleared)";
groupid = "(cleared)";
break;
case KEY_F(5): /* Run Command */
//executecmd(command); /* Execute command */
break;
case KEY_F(6): /* Add User */
verifyadd(); /* Confirms then Add or quits */
break;
case KEY_F(9): /* Run Default Shell */
clear();
endwin();
system(DEFAULT_SHELL);
break;
case KEY_F(10): /* Quits Dialog */
return(0);
break;
}
drawauscreen();
refresh();
} while(key != '\n');
/* Other Statments goes here */
};
/* Finish up */
free(loginname);
free(usergecos);
free(usershell);
free(homedir);
return 0;
}
int main()
{ WINDOW *menu_win;
int highlight = 1;
int choice = 0;
int c;
int fd;
fd = open("/dev/fb1",O_RDWR);
if(fd < 0)
{
printf("Can not open device\n");
return -1;
}
initscr();
clear();
noecho();
cbreak(); /* Line buffering disabled. pass on everything */
startx = (80 - WIDTH) / 2;
starty = (24 - HEIGHT) / 2;
menu_win = newwin(HEIGHT, WIDTH, starty, startx);
keypad(menu_win, TRUE);
mvprintw(0, 0, "Use arrow keys to go up and down, Press enter to select a choice");
refresh();
print_menu(menu_win, highlight);
while(1)
{ c = wgetch(menu_win);
switch(c)
{ case KEY_UP:
if(highlight == 1)
highlight = n_choices;
else
--highlight;
break;
case KEY_DOWN:
if(highlight == n_choices)
highlight = 1;
else
++highlight;
break;
case KEY_RIGHT:
if (cur_value[highlight-1]<100)
cur_value[highlight-1]++;
break;
case KEY_LEFT:
if (cur_value[highlight-1]>0)
cur_value[highlight-1]--;
break;
case 10:
choice = highlight;
break;
default:
mvprintw(24, 0, "Charcter pressed is = %3d Hopefully it can be printed as '%c'", c, c);
refresh();
break;
}
brightness = cur_value[0];
brightness_coeff = 2.0 * ((float)brightness/100.);
contrast = cur_value[1];
contrast_coeff = 2.0 * ((float)contrast/100.);
saturation = cur_value[2];
saturation_coeff = 2.0 * ((float)saturation/100.);
hue = cur_value[3];
hue_coeff = 180 + (180 * ((float)hue/100.));
memcpy(color_correction_matrix,default_matrix_coeff_hd,sizeof(default_matrix_coeff_hd));
create_color_correction_matrix();
fb_set_std_table(fd, 255);
print_menu(menu_win, highlight);
if(choice != 0) /* User did a choice come out of the infinite loop */
break;
}
mvprintw(23, 0, "You chose choice %d with choice string %s\n", choice, choices[choice - 1]);
clrtoeol();
refresh();
endwin();
return 0;
}
static void
test_inserts(int level)
{
static bool first = TRUE;
int ch;
int limit;
int row = 1;
int col;
int row2, col2;
int length;
wchar_t buffer[BUFSIZ];
WINDOW *look = 0;
WINDOW *work = 0;
WINDOW *show = 0;
int margin = (2 * MY_TABSIZE) - 1;
Options option = ((m_opt ? oMove : oDefault)
| ((w_opt || (level > 0)) ? oWindow : oDefault));
if (first) {
static char cmd[80];
setlocale(LC_ALL, "");
putenv(strcpy(cmd, "TABSIZE=8"));
initscr();
(void) cbreak(); /* take input chars one at a time, no wait for \n */
(void) noecho(); /* don't echo input */
keypad(stdscr, TRUE);
}
limit = LINES - 5;
if (level > 0) {
look = newwin(limit, COLS - (2 * (level - 1)), 0, level - 1);
work = newwin(limit - 2, COLS - (2 * level), 1, level);
show = newwin(4, COLS, limit + 1, 0);
box(look, 0, 0);
wnoutrefresh(look);
limit -= 2;
} else {
work = stdscr;
show = derwin(stdscr, 4, COLS, limit + 1, 0);
}
keypad(work, TRUE);
for (col = margin + 1; col < COLS; col += MY_TABSIZE)
mvwvline(work, row, col, '.', limit - 2);
mvwvline(work, row, margin, ACS_VLINE, limit - 2);
mvwvline(work, row, margin + 1, ACS_VLINE, limit - 2);
limit /= 2;
mvwaddstr(work, 1, 2, "String");
mvwaddstr(work, limit + 1, 2, "Chars");
wnoutrefresh(work);
buffer[length = 0] = '\0';
legend(show, level, option, buffer, length);
wnoutrefresh(show);
doupdate();
/*
* Show the characters inserted in color, to distinguish from those that
* are shifted.
*/
if (has_colors()) {
start_color();
init_pair(1, COLOR_WHITE, COLOR_BLUE);
wbkgdset(work, COLOR_PAIR(1) | ' ');
}
while ((ch = read_linedata(work)) != ERR && !isQUIT(ch)) {
wmove(work, row, margin + 1);
switch (ch) {
case key_RECUR:
test_inserts(level + 1);
touchwin(look);
touchwin(work);
touchwin(show);
wnoutrefresh(look);
wnoutrefresh(work);
wnoutrefresh(show);
doupdate();
break;
case key_NEWLINE:
if (row < limit) {
++row;
/* put the whole string in, all at once */
col2 = margin + 1;
switch (option) {
case oDefault:
if (n_opt > 1) {
for (col = 0; col < length; col += n_opt) {
col2 = ColOf(buffer, col, margin);
if (move(row, col2) != ERR) {
InsNStr(buffer + col, LEN(col));
}
}
} else {
if (move(row, col2) != ERR) {
InsStr(buffer);
}
}
break;
case oMove:
if (n_opt > 1) {
for (col = 0; col < length; col += n_opt) {
col2 = ColOf(buffer, col, margin);
MvInsNStr(row, col2, buffer + col, LEN(col));
}
} else {
MvInsStr(row, col2, buffer);
}
break;
case oWindow:
if (n_opt > 1) {
for (col = 0; col < length; col += n_opt) {
col2 = ColOf(buffer, col, margin);
if (wmove(work, row, col2) != ERR) {
WInsNStr(work, buffer + col, LEN(col));
}
}
} else {
if (wmove(work, row, col2) != ERR) {
WInsStr(work, buffer);
}
}
break;
case oMoveWindow:
if (n_opt > 1) {
for (col = 0; col < length; col += n_opt) {
col2 = ColOf(buffer, col, margin);
MvWInsNStr(work, row, col2, buffer + col, LEN(col));
}
} else {
MvWInsStr(work, row, col2, buffer);
}
break;
}
/* do the corresponding single-character insertion */
row2 = limit + row;
for (col = 0; col < length; ++col) {
col2 = ColOf(buffer, col, margin);
switch (option) {
case oDefault:
if (move(row2, col2) != ERR) {
InsCh((chtype) buffer[col]);
}
break;
case oMove:
MvInsCh(row2, col2, (chtype) buffer[col]);
break;
case oWindow:
if (wmove(work, row2, col2) != ERR) {
WInsCh(work, (chtype) buffer[col]);
}
break;
case oMoveWindow:
MvWInsCh(work, row2, col2, (chtype) buffer[col]);
break;
}
}
} else {
beep();
}
break;
default:
buffer[length++] = ch;
buffer[length] = '\0';
/* put the string in, one character at a time */
col = ColOf(buffer, length - 1, margin);
switch (option) {
case oDefault:
if (move(row, col) != ERR) {
InsStr(buffer + length - 1);
}
break;
case oMove:
MvInsStr(row, col, buffer + length - 1);
break;
case oWindow:
if (wmove(work, row, col) != ERR) {
WInsStr(work, buffer + length - 1);
}
break;
case oMoveWindow:
MvWInsStr(work, row, col, buffer + length - 1);
break;
}
/* do the corresponding single-character insertion */
switch (option) {
case oDefault:
if (move(limit + row, col) != ERR) {
InsCh(ch);
}
break;
case oMove:
MvInsCh(limit + row, col, ch);
break;
case oWindow:
if (wmove(work, limit + row, col) != ERR) {
WInsCh(work, ch);
}
break;
case oMoveWindow:
MvWInsCh(work, limit + row, col, ch);
break;
}
wnoutrefresh(work);
legend(show, level, option, buffer, length);
wnoutrefresh(show);
doupdate();
break;
}
}
if (level > 0) {
delwin(show);
delwin(work);
delwin(look);
}
}
int main()
{
struct usb_bus *busses;
usb_init();
usb_find_busses();
usb_find_devices();
busses = usb_get_busses();
struct usb_bus *bus;
int c, i, a;
/* ... */
for (bus = busses; bus; bus = bus->next)
{
struct usb_device *dev;
for (dev = bus->devices; dev; dev = dev->next)
{
/* Check if this device is a printer */
if (dev->descriptor.idVendor == 6465)
{
launcher = usb_open(dev);
//do stuff
int claimed = usb_claim_interface(launcher, 0); //the device is put into the associated state, these commands are not one shots. As such, you have to send a message triple where all 3 messages are all zeroes in order to stop whatever is happening (in my case, pressing a key sends the move/fire m
if (claimed == 0)
{
int c;
int redrawNeeded = 0;
//movement_handler(0x10);
//c = getchar();
//movement_handler(0x0);
//set up curses
initscr();
noecho();
keypad(stdscr, TRUE);
cbreak();
nodelay(stdscr, TRUE);
//draw the interface
drawScreen();
//main program loop
while ( c = getch() )
{
//up
if (c == '8')
{
movement_handler(1);
move(halfLines - 2, halfCols);
addch('8' | A_BOLD);
redrawNeeded = 1;
pauseForMove();
}
//down
else if (c == '5')
{
movement_handler(2);
move(halfLines + 2, halfCols);
addch('5' | A_BOLD);
redrawNeeded = 1;
pauseForMove();
}
//left
else if (c == '4')
{
movement_handler(4);
move(halfLines, halfCols - 3);
addch('4' | A_BOLD);
redrawNeeded = 1;
pauseForMove();
}
//right
else if (c == '6')
{
movement_handler(8);
move(halfLines, halfCols + 3);
addch('6' | A_BOLD);
redrawNeeded = 1;
pauseForMove();
}
//fire
else if (c == '0')
{
fire();
}
else if (c == 'q')
{
break;
}
else
{
movement_handler(0);
if (redrawNeeded)
{
fixHighlights();
redrawNeeded = 0;
}
}
}
//stop curses
endwin();
usb_release_interface(launcher, 0);
}
usb_close(launcher);
}
}
}
}
int main(int argc, char *argv[])
{
if (argc < 4) {
printf("[!] Usage: %s [IP] [port] [public_key] <nokey>\n", argv[0]);
exit(0);
}
int c;
int on = 0;
initMessenger();
//if keyfiles exist
if(argc > 4){
if(strncmp(argv[4], "nokey", 6) < 0){
//load_key();
}
} else {
load_key();
}
m_callback_friendrequest(print_request);
m_callback_friendmessage(print_message);
m_callback_namechange(print_nickchange);
m_callback_userstatus(print_statuschange);
char idstring0[200];
char idstring1[32][5];
char idstring2[32][5];
uint32_t i;
for(i = 0; i < 32; i++)
{
if(self_public_key[i] < 16)
strcpy(idstring1[i],"0");
else
strcpy(idstring1[i], "");
sprintf(idstring2[i], "%hhX",self_public_key[i]);
}
strcpy(idstring0,"[i] your ID: ");
for (i=0; i<32; i++) {
strcat(idstring0,idstring1[i]);
strcat(idstring0,idstring2[i]);
}
initscr();
noecho();
raw();
getmaxyx(stdscr,y,x);
new_lines(idstring0);
new_lines("[i] commands: /f ID (to add friend), /m friendnumber message (to send message), /s status (to change status), /n nick (to change nickname), /q (to quit)");
strcpy(line, "");
IP_Port bootstrap_ip_port;
bootstrap_ip_port.port = htons(atoi(argv[2]));
int resolved_address = resolve_addr(argv[1]);
if (resolved_address != -1)
bootstrap_ip_port.ip.i = resolved_address;
else
exit(1);
DHT_bootstrap(bootstrap_ip_port, hex_string_to_bin(argv[3]));
nodelay(stdscr, TRUE);
while(true) {
if (on == 0 && DHT_isconnected()) {
new_lines("[i] connected to DHT\n[i] define username with /n");
on = 1;
}
doMessenger();
c_sleep(1);
do_refresh();
c = getch();
if (c == ERR || c == 27)
continue;
getmaxyx(stdscr, y, x);
if (c == '\n') {
line_eval(lines, line);
strcpy(line, "");
} else if (c == 127) {
line[strlen(line) - 1] = '\0';
} else if (isalnum(c) || ispunct(c) || c == ' ') {
strcpy(line, appender(line, (char) c));
}
}
endwin();
return 0;
}
