/* ================== CON_Print ================== */ void CON_Print(const char *msg) { int col; bool scroll = (lastline > scrollline && lastline <= scrollline + LOG_LINES); if (!curses_on) { CON_Print_tty(msg); return; } // Print the message in the log window CON_ColorPrint(logwin, msg, qtrue); getyx(logwin, lastline, col); if (col) lastline++; if (scroll) { scrollline = lastline - LOG_LINES; if (scrollline < 0) scrollline = 0; pnoutrefresh(logwin, scrollline, 0, 2, 1, LOG_LINES + 1, LOG_COLS + 1); } // Add the message to the log buffer if (insert + strlen(msg) >= logbuf + sizeof(logbuf)) { memmove(logbuf, logbuf + sizeof(logbuf) / 2, sizeof(logbuf) / 2); memset(logbuf + sizeof(logbuf) / 2, 0, sizeof(logbuf) / 2); insert -= sizeof(logbuf) / 2; } strcpy(insert, msg); insert += strlen(msg); // Update the scrollbar CON_DrawScrollBar(); // Move the cursor back to the input field CON_UpdateCursor(); doupdate(); }
int STRUM2::run() { for (int i = 0; i < framesToRun(); i++) { if (--_branch <= 0) { doupdate(); _branch = getSkip(); } float out[2]; out[0] = _strum->next() * _amp; if (outputChannels() == 2) { out[1] = out[0] * (1.0f - _pan); out[0] *= _pan; } rtaddout(out); increment(); } return framesToRun(); }
int shNCursesInterface::diag (const char *format, ...) { int res; va_list ap; mColor = kMagenta; va_start (ap, format); char dbgbuf[100]; res = vsnprintf (dbgbuf, 100, format, ap); if (mWin[kDiag]) { wattrset (mWin[kDiag], ColorMap[kCyan]); waddstr (mWin[kDiag], dbgbuf); waddch (mWin[kDiag], '\n'); touchwin (mWin[kDiag]); wnoutrefresh (mWin[kDiag]); doupdate (); } debug.log ("%s", dbgbuf); va_end (ap); mColor = kGray; return res; }
void LYrefresh( void ) { if ( stdscr != LYwin ) { int y = -1, x = -1; if ( LYcols - ( LYShowScrollbar != 0 ) < x ) x = LYcols - ( LYShowScrollbar != 0 ); wmove( stdscr, y, x ); wnoutrefresh( stdscr ); pnoutrefresh( LYwin, 0, LYshiftWin, 0, 0, LYlines, LYscreenWidth( ) + -1 ); if ( my_subwindow ) { wtouchln( my_subwindow, 0, -1, 1 ); wnoutrefresh( my_subwindow ); } doupdate( ); } else { wrefresh( stdscr ); } return; }
int PAN :: run() { const int samps = framesToRun() * inputChannels(); rtgetin(in, this, samps); for (int i = 0; i < samps; i += inputChannels()) { if (--branch <= 0) { doupdate(); branch = skip; } float insig = in[i + inchan] * amp; float out[2]; out[0] = insig * pan[0]; out[1] = insig * pan[1]; rtaddout(out); increment(); } return framesToRun(); }
void showmenu(struct MENU *menu) { struct ITEM *itemptr; /* points to each item in turn */ int ctr = 1; /* counts each item */ wattrset(menu->menuwin, BOXATTR); /* set to bg+/b */ colorwin(menu->menuwin); /* color window */ box(menu->menuwin, ACS_VLINE, ACS_HLINE); /* draw border */ itemptr = menu->itemlist; /* point to start */ wattrset(menu->menuwin, STDATTR); do { /* display items */ wmove(menu->menuwin, ctr, 1); showitem(menu, itemptr, NOTSELECTED); /* show items, initially unselected */ ctr++; itemptr = itemptr->next; } while (ctr <= menu->itemcount); update_panels(); doupdate(); }
void Ozette::run() { if (_editors.empty()) show_browser(); timeout(100); do { if (sig_io_flag.exchange(false)) { _shell.poll(); } int ch = fix_control_quirks(getch()); switch (ch) { case Control::UpArrow: show_browser(); break; case Control::NewFile: new_file(); break; case Control::Open: open_file(); break; case Control::Directory: change_directory(); break; case Control::Help: show_help(); break; case Control::Execute: execute(); break; case KEY_F(4): search(); break; case KEY_F(5): build(); break; default: _done |= !_shell.process(ch); } update_panels(); doupdate(); } while (!_done); }
/* * render_cb * * Called by the rendering loop, which is the tightest of the event loops. * It writes any modified state to the screen, and tries not to calculate much * itself, since it has to return quickly. * Repeat: .02 seconds */ void render_cb(EV_P_ ev_timer *w, int revents) { spin_render_loop(); if (game_is_paused) pause_loop(); tick(); free_nouns(); update_nouns(); dock_update(); print_dock(); update_map_control(); update_panels(); /* Were slowing down performance, unnecessary */ doupdate(); MAPBOOK->restack(ACTIVE); map_refresh(ACTIVE); ev_timer_again(EV_DEFAULT, w); }
/** * Recreate the 2 readline panels with respect to the screen size. * * @param rows Size of the screen in rows * @param cols Size of the screen in cols * @return Void */ void readline_recreate(int rows, int cols) { struct term_window_size newsize = { .rows = 1, .cols = cols, .start_row = rows - 1, .start_col = 0, }; readline_pan1 = term_resize_panel(readline_pan1, &newsize); readline_pan2 = term_resize_panel(readline_pan2, &newsize); apply_readline_options(panel_window(readline_pan1)); apply_readline_options(panel_window(readline_pan2)); } /** * Puts the currently active readline panel on the top of all panels * in the stack. */ void readline_top_panel(void) { if (panel_state == PANEL1_ACTIVE) { if (readline_pan1) (void) top_panel(readline_pan1); } else if (panel_state == PANEL2_ACTIVE) { if (readline_pan2) (void) top_panel(readline_pan2); } else { sw_assert_not_reached(); } update_panels(); (void) doupdate(); }
static void input_loop(int portfd) { if (portfd >= FD_SETSIZE) { destroy_screen(); fputs("File descriptor too large\n", stderr); exit(1); } for (;;) { fd_set fds; FD_ZERO(&fds); FD_SET(STDIN_FILENO, &fds); FD_SET(portfd, &fds); int rc = select(portfd + 1, &fds, 0, 0, 0); if (rc <= 0) { if (rc < 0 && errno != EINTR) exit_error("select", errno); continue; } if (FD_ISSET(portfd, &fds)) receive_kctext(portfd, win_output); if (FD_ISSET(STDIN_FILENO, &fds) && handle_key_input(portfd, win_input)) break; wnoutrefresh(win_input); doupdate(); } }
/******************************************************\ * Description: Creates a "window popup" where given * * the parameters, and message, it * * creates a window and displays the * * message. Some current restrictions * * are that it must only be one line, and* * it is assumed that the text is padded * * with one space left for the border and* * another space left for aesthetics * \******************************************************/ void popupWin(char *msg, int time) { WINDOW *tmpwin; int y = (LINES / 2) - 3, /* calc location */ len = strlen(msg), x = (COLS - len)/2; y = (y < 2) ? 2 : y; /* minimum height */ time = (!time) ? 2 : time; tmpwin = drawbox(y, x, 5, len + 6); /* create window */ keypad(tmpwin, TRUE); mvwprintw(tmpwin,2,3, msg); /* output mesg */ wmove(tmpwin,2,len+4); wrefresh(tmpwin); if (time == -1) wgetch(tmpwin); else sleep(time); /* wait */ delwin(tmpwin); wtouchln(windows->hex, y - 1, 5, 1); /* touch windows */ wtouchln(windows->ascii, y - 1, 5, 1); wtouchln(windows->address, y - 1, 5, 1); wtouchln(windows->hex_outline, y, 5, 1); wtouchln(windows->ascii_outline, y, 5, 1); wtouchln(windows->scrollbar, y, 5, 1); refreshall(windows); /* refresh all wins */ doupdate(); }
void addfield(struct FIELDLIST *list, unsigned int len, unsigned int y, unsigned int x, char *initstr) { struct FIELD *newfield; int i; newfield = malloc(sizeof(struct FIELD)); if (list->list == NULL) { list->list = newfield; newfield->prevfield = newfield; newfield->nextfield = newfield; } else { newfield->prevfield = list->list->prevfield; list->list->prevfield->nextfield = newfield; list->list->prevfield = newfield; newfield->nextfield = list->list; } newfield->xpos = x; newfield->ypos = y; newfield->len = len; newfield->tlen = strlen(initstr); newfield->buf = malloc(len + 1); strcpy(newfield->buf, initstr); wattrset(list->fieldwin, FIELDATTR); wmove(list->fieldwin, y, x); for (i = 1; i <= (signed)len; i++) wprintw(list->fieldwin, " "); wmove(list->fieldwin, y, x); wprintw(list->fieldwin, "%s", initstr); update_panels(); doupdate(); }
void destroymenu(struct MENU *menu) { struct ITEM *tnode; struct ITEM *tnextnode; if (menu->itemlist != NULL) { tnode = menu->itemlist; tnextnode = menu->itemlist->next; tnode->prev->next = NULL; while (tnode != NULL) { free(tnode); tnode = tnextnode; if (tnextnode != NULL) tnextnode = tnextnode->next; } } del_panel(menu->menupanel); delwin(menu->menuwin); update_panels(); doupdate(); }
int main() { WINDOW *my_wins[3]; PANEL *my_panels[3]; int lines = 15, cols = 45, y = 2, x = 4, i; initscr(); cbreak(); noecho(); /* Create windows for the panels */ my_wins[0] = newwin(lines, cols, y, x); my_wins[1] = newwin(lines, cols, y + 1, x + 5); my_wins[2] = newwin(lines, cols, y + 2, x + 10); /* * Create borders around the windows so that you can see the effect * of panels */ for(i = 0; i < 3; ++i) box(my_wins[i], 0, 0); /* Attach a panel to each window */ /* Order is bottom up */ my_panels[0] = new_panel(my_wins[0]); /* Push 0, order: stdscr-0 */ my_panels[1] = new_panel(my_wins[1]); /* Push 1, order: stdscr-0-1 */ my_panels[2] = new_panel(my_wins[2]); /* Push 2, order: stdscr-0-1-2 */ /* Update the stacking order. 2nd panel will be on top */ update_panels(); /* Show it on the screen */ doupdate(); getch(); endwin(); }
int MSHAKERS :: run() { int i; float out[2]; for (i = 0; i < framesToRun(); i++) { if (--branch <= 0) { doupdate(); branch = getSkip(); } out[0] = theShake->tick() * aamp; if (outputChannels() == 2) { out[1] = out[0] * (1.0 - pctleft); out[0] *= pctleft; } rtaddout(out); increment(); } return framesToRun(); }
/** * Main game loop. */ static void loop(void) { extern nyancat_t nc; gametime_t time; int key_ready = 0, ch; /* switch to intro mode */ gamemode_enter(mode_intro); gamemode_draw(); while (gamemode_valid()) { /* look for the first to run event */ time = queue_get_first_time(); if (time) { /* wait for time to run the first event form queue or the first * keypress, wichever comes first. */ key_ready = io_wait_for_key(time); } else { /* no event queue item found */ io_wait_for_key(0); key_ready = 1; } if (key_ready > 0) { ch = getch(); /* no redraw call explicite because this should be done bey the * key handlers called functions */ gamemode_key(ch); } else { /* TODO find a better way for prevening hight cpu usage here. But * for now insert a sleep for the minimum ticks used in game */ usleep(SECOND * TICK(0.1)); queue_run_until(time); } doupdate(); } }
void view_flush() { /* fill the screen with blanks */ int x,y; for(y=0;y<getmaxy(stdscr);y++) for(x=0;x<getmaxx(stdscr);x++) mvaddch(y,x,' '); /* empty the screen */ attron(A_BOLD); for(y=0;y<getmaxy(stdscr)-1;y++) mvaddch(y,0,'~'); /* display blank lines */ attroff(A_BOLD); /* display the message at the bottom of the screen */ mvaddstr(getmaxy(stdscr)-1,0,displayed_message()); if(view_layout.hsplit) { /* paint a line down the center */ attrset(A_REVERSE); for(y=0;y<getmaxy(stdscr)-1;y++) mvaddch(y,view_layout.v1size,'|'); attrset(A_NORMAL); /* display a bottom row with info */ /* buffer 1 info */ /* buffer 2 info */ } else if(view_layout.vsplit) { /* display a line through the middle */ attrset(A_REVERSE); attrset(A_NORMAL); } else { /* just draaw the view */ draw_view(view_layout.active,0,0,getmaxy(stdscr)-1,getmaxx(stdscr)); } /* update and refresh the screen (curses stuff) */ doupdate(); refresh(); }
static void ex_draw() { log_msg("EXCMD", "ex_draw"); werase(ex.nc_win); if (ex.ex_state == EX_CMD_STATE) menu_draw(ex.menu); pos_T max = layout_size(); wchar_t *wline = str2wide(ex.line); int len = 2 + wcswidth(wline, -1); int offset = MAX(len - (max.col - 1), 0); mvwaddch(ex.nc_win, 0, 0, ex.state_symbol); mvwaddwstr(ex.nc_win, 0, 1, &wline[offset]); mvwchgat(ex.nc_win, 0, 0, 1, A_NORMAL, ex.col_symb, NULL); mvwchgat(ex.nc_win, 0, 1, -1, A_NORMAL, ex.col_text, NULL); doupdate(); curs_set(1); wmove(ex.nc_win, 0, (ex.curpos + 1) - offset); wnoutrefresh(ex.nc_win); free(wline); }
/* Returns a character read from stdin with appropriate interpretation */ int get_event (Gpm_Event *event, int redo_event, int block) { int c; static int flag; /* Return value from select */ static int dirty = 3; if ((dirty == 1) || is_idle ()){ refresh (); doupdate (); dirty = 1; } else dirty++; vfs_timeout_handler (); c = block ? getch_with_delay () : get_key_code (1); if (!c) { /* Code is 0, so this is a Control key or mouse event */ return EV_NONE; /* FIXME: mouse not supported */ } return c; }
int MBANDEDWG :: run() { int i; float out[2]; for (i = 0; i < framesToRun(); i++) { if (--branch <= 0) { doupdate(); branch = getSkip(); } out[0] = theBar->tick(velocity) * amp; if (outputChannels() == 2) { out[1] = out[0] * (1.0 - pctleft); out[0] *= pctleft; } rtaddout(out); increment(); } return framesToRun(); }
/** * Key left */ static void case_key_left(volatile struct readline_session_context *ctx) { struct current_cursor_pos yx; if (ctx->bufpos == 0) { term_beep(); return; } if (loLim_isset(ctx->act, ctx->prompt_size)) { magic_swap_panels(ctx, false); } ctx->bufpos--; yx = term_get_pos(ctx->act); if (wmove(ctx->act, yx.cury, yx.curx - 1) == ERR) { readline_error(EPERM, "wmove"); } update_panels(); (void) doupdate(); }
/** * Key right */ static void case_key_right(volatile struct readline_session_context *ctx) { struct current_cursor_pos yx; if (!ctx->insert_mode) { term_beep(); return; } if (hiLim_isset(ctx->act)) { magic_swap_panels(ctx, true); } ctx->bufpos++; yx = term_get_pos(ctx->act); if (wmove(ctx->act, yx.cury, yx.curx + 1) == ERR) { readline_error(EPERM, "wmove"); } update_panels(); (void) doupdate(); }
int flushinp(void) { #ifdef DEBUG if (outf) fprintf(outf, "flushinp(), file %x, SP %x\n", cur_term->Filedes, SP); #endif /* DEBUG */ #ifdef SYSV (void) ioctl(cur_term -> Filedes, TCFLSH, 0); #else /* SYSV */ /* for insurance against someone using their own buffer: */ (void) ioctl(cur_term -> Filedes, TIOCGETP, &(PROGTTY)); /* * SETP waits on output and flushes input as side effect. * Really want an ioctl like TCFLSH but Berkeley doesn't have one. */ (void) ioctl(cur_term -> Filedes, TIOCSETP, &(PROGTTY)); #endif /* SYSV */ /* * Get rid of any typeahead which was read(). * Leave characters which were ungetch()'d. */ cur_term->_chars_on_queue = cur_term->_ungotten; /* * Have to doupdate() because, if we have stopped output due to * typeahead, now that typeahead is gone, so we had better catch up. */ if (_INPUTPENDING) (void) doupdate(); return (OK); }
int PINK::run() { for (int i = 0; i < framesToRun(); i++) { if (--_branch <= 0) { doupdate(); _branch = getSkip(); } /* This is an approximation to a -10dB/decade filter using a weighted sum of first order filters. It is accurate to within +/-0.05dB above 9.2Hz (44100Hz sampling rate). Unity gain is at Nyquist, but can be adjusted by scaling the numbers at the end of each line. -Paul Kellet */ const double white = rrand() * _amp; _b0 = _b0 * 0.99886 + white * 0.0555179; _b1 = _b1 * 0.99332 + white * 0.0750759; _b2 = _b2 * 0.96900 + white * 0.1538520; _b3 = _b3 * 0.86650 + white * 0.3104856; _b4 = _b4 * 0.55000 + white * 0.5329522; _b5 = _b5 * -0.7616 - white * 0.0168980; double pink = _b0 + _b1 + _b2 + _b3 + _b4 + _b5 + _b6 + white * 0.5362; _b6 = white * 0.115926; float out[2]; out[0] = pink * 0.15; if (outputChannels() == 2) { out[1] = out[0] * (1.0 - _pan); out[0] *= _pan; } rtaddout(out); increment(); } return framesToRun(); }
/** * Handles what happens if the delete key is pressed. */ static void case_key_dc(volatile struct readline_session_context *ctx) { wchar_t *ptr; const int this_index = ctx->bufpos + 1; if (!ctx->insert_mode) { term_beep(); return; } ptr = &ctx->buffer[this_index]; (void) wmemmove(ptr - 1, ptr, wcslen(ptr)); ctx->buffer[--ctx->n_insert] = 0L; if (wdelch(ctx->act) == ERR || wclrtoeol(ctx->act) == ERR) { readline_error(EPERM, "wdelch or wclrtoeol"); } readline_winsnstr(ctx->act, &ctx->buffer[ctx->bufpos], -1); update_panels(); (void) doupdate(); }
/** * For Lua instruments, the run method also performs the Lua * portion of the init method. That is because the init * method is called from the main RTcmix thread whereas the * run method is called from the traverse thread, but Lua * is not thread-safe and our Lua state management code * creates a separate Lua state for each thread. */ virtual int run() { //advise("LUAINST::run", "Began (thread %p)...", pthread_self()); int result = 0; if (state.parameters[2] != 0.0) { state.inputSampleCount = RTBUFSAMPS * inputChannels(); rtgetin(state.input, this, state.inputSampleCount); } lua_State *L = manageLuaState(); LuaInstrumentClass_t &luaInstrumentClass = manageLuaInstrumentClass(L, state.name); if (!luaInstrumentClass.initialized) { const char *luacode = luaCodeForInstrumentNames[state.name].c_str(); advise("LUAINST", "Defining Lua instrument code:\n\n%0.120s\n...\n", luacode); result = luaL_dostring(L, luacode); if (result == 0) { char init_function[0x100]; std::snprintf(init_function, 0x100, "%s_init", state.name); lua_getglobal(L, init_function); if (!lua_isnil(L, 1)) { luaInstrumentClass.init_key = luaL_ref(L, LUA_REGISTRYINDEX); lua_pop(L, 1); } else { exit(die("LUAINST", "Failed to register: %s.", init_function)); } char run_function[0x100]; std::snprintf(run_function, 0x100, "%s_run", state.name); lua_getglobal(L, run_function); if (!lua_isnil(L, 1)) { luaInstrumentClass.run_key = luaL_ref(L, LUA_REGISTRYINDEX); lua_pop(L, 1); } else { exit(die("LUAINST", "Failed to register: %s.", run_function)); } } else { warn("LUAINST", "Failed with: %d\n", result); } luaInstrumentClass.initialized = true; } if (!state.initialized) { lua_rawgeti(L, LUA_REGISTRYINDEX, luaInstrumentClass.init_key); lua_pushlightuserdata(L, &state); if (lua_pcall(L, 1, 1, 0) != 0) { rterror("LUAINST", "Lua error in \"%s_init\": %s.\n", state.name, lua_tostring(L, -1)); } result = lua_tonumber(L, -1); lua_pop(L, 1); state.initialized = true; } state.startFrame = state.endFrame; long frameCount = framesToRun(); state.endFrame += frameCount; doupdate(); lua_rawgeti(L, LUA_REGISTRYINDEX, luaInstrumentClass.run_key); lua_pushlightuserdata(L, &state); if (lua_pcall(L, 1, 1, 0) != 0) { die("LUAINST", "Lua error in \"%s_run\": %s with key %p frame %i.\n", state.name, lua_tostring(L, -1), luaInstrumentClass.run_key, state.currentFrame); exit(-1); } result = lua_tonumber(L, -1); lua_pop(L, 1); rtbaddout(state.output, frameCount); increment(frameCount); return framesToRun(); }
WRAP_API int wrap_doupdate(void) { return doupdate(); }
/******************************************************************************* Funktion NeuesSpiel() Uebergabe Parameter: iSchwierigkeit, ccNickname[] Rueckgabe: - Beschreibung: Startet ein neues Spiel und initialisiert die dafuer notwendigen Komponenten. Verarbeitet in einer Dauerschleife die Benutzereingaben. Verwaltet die Spielelemente. *******************************************************************************/ void NeuesSpiel(int iSchwierigkeit, const char ccNickname[]) { WINDOW *spielfeldFenster, *infoFenster, *kommandoFenster; SUDOKUFELD spielfelder[ANZAHL_SPIELFELDER]; CURSOR cursor = { CURSOR_START_POSITION_SPALTE, CURSOR_START_POSITION_ZEILE, CURSOR_START_ZEILE, CURSOR_START_SPALTE }; time_t Startzeit; int iGedrueckteTaste = -1, iAnzahlHilfeGenutzt = 0; int iSpielGeloest = FALSE; char cZeit[9]; timeout(33); // Erstellen der einzelnen Fenster spielfeldFenster = ErstelleNeuesSpielfeldFenster(); infoFenster = ErstelleNeuesInfoFenster(); kommandoFenster = ErstelleNeuesKommandoFenster(); // Initialisierung vom Cursor sowie die Befuellung der Spielfelder InitialisiereCursor(&cursor); BefuelleSpielfelder(spielfelder, iSchwierigkeit); // Zeichnen der einzelnen Fenster ZeichneSpielfeld(spielfeldFenster); ZeichneSpielfelder(spielfeldFenster, spielfelder); ZeichneInfo(infoFenster); ZeichneKommandos(kommandoFenster); // Holen der Startzeit time(&Startzeit); // Loesungsanzeige oder ein geloestes Spiel als Abbruchbedingung while(!iSpielGeloest && (iGedrueckteTaste != 'L' && iGedrueckteTaste != 'l')) { // Entgegennehmen und verarbeiten der gedrueckten Tasten iGedrueckteTaste = VerarbeiteEingabe(spielfelder, &cursor, &iAnzahlHilfeGenutzt); ZeichneVerstricheneZeit(infoFenster, Startzeit, iAnzahlHilfeGenutzt); ZeichneAnzahlGenutzterHilfe(infoFenster, iAnzahlHilfeGenutzt); doupdate(); // Zeichne alles auf einmal neu // Ueberpruefung, ob das Sudoku komplett ausgefuellt ist if(AlleFelderGefuellt(spielfelder)) { /* Ueberpruefung, ob das ausgefuellte Sudoku mit der Loesung uebereinstimmt */ if(FelderKorrektAusgefuellt(spielfelder)) { // Endzeit berechnen BerechneVerstricheneZeit(cZeit, Startzeit, iAnzahlHilfeGenutzt); SpielGewonnenMenue(cZeit); // Nur wenn eingeloggter Benutzer if(strlen(ccNickname) > 0) { InBestenlisteEintragenDialog(iSchwierigkeit, ccNickname, cZeit); } iSpielGeloest = TRUE; } else { /* Hinweis, dass sich ein Fehler im ausgefuellten Sudoku befindet */ mvwprintw(kommandoFenster, 5, 0, "Im Sudoku befindet"); mvwprintw(kommandoFenster, 6, 0, "sich ein Fehler!"); wnoutrefresh(kommandoFenster); } } } timeout(-1); // Timeout deaktivieren // Zeichne die Loesung nur wenn das Spiel nicht vom Benutzer geloest wurde if(!iSpielGeloest) { ZeichneLoesung(spielfeldFenster, spielfelder); } // Schließen der zuvor erstellten Fenster delwin(infoFenster); delwin(spielfeldFenster); delwin(kommandoFenster); clear(); // Bildschirm leeren }
int main() { WINDOW *new_window_ptr; WINDOW *popup_window_ptr; int x_loop; int y_loop; char a_letter = 'a'; initscr(); move(5,5); printw("%s", "Testing multiple windows"); refresh(); for (y_loop = 0; y_loop < LINES - 1; y_loop++) { for (x_loop = 0; x_loop < COLS - 1; x_loop++) { mvwaddch(stdscr, y_loop, x_loop, a_letter); a_letter++; if (a_letter > 'z') a_letter = 'a'; } } refresh(); sleep(2); new_window_ptr = newwin(10, 20, 5, 5); mvwprintw(new_window_ptr, 2, 2, "%s", "Hello World"); mvwprintw(new_window_ptr, 5, 2, "%s", "Notice how very long lines wrap inside the window"); wrefresh(new_window_ptr); sleep(2); a_letter = '0'; for (y_loop = 0; y_loop < LINES - 1; y_loop++) { for (x_loop = 0; x_loop < COLS - 1; x_loop++) { mvwaddch(stdscr, y_loop, x_loop, a_letter); a_letter++; if (a_letter > '9') a_letter = '0'; } } wnoutrefresh(stdscr); doupdate(); sleep(2); //however it will not change, you cannot see this window wnoutrefresh(new_window_ptr); doupdate(); sleep(2); //touch means repainting when wrefresh. you will see the window. touchwin(new_window_ptr); wrefresh(new_window_ptr); sleep(2); popup_window_ptr = newwin(10, 20, 8, 8); box(popup_window_ptr, '|', '-'); mvwprintw(popup_window_ptr, 5, 2, "%s", "Pop Up window!"); wrefresh(popup_window_ptr); sleep(2); touchwin(new_window_ptr); wrefresh(new_window_ptr); sleep(2); wclear(new_window_ptr); wrefresh(new_window_ptr); sleep(2); delwin(new_window_ptr); touchwin(popup_window_ptr); wrefresh(popup_window_ptr); sleep(2); delwin(popup_window_ptr); touchwin(stdscr); refresh(); sleep(2); endwin(); exit(EXIT_SUCCESS); //when you want to see the window. //do add touchwin before you wrefresh }
/* * _nd_help() displays helpfiles */ void _nd_help(char *document) { STRING(Page) pages; Page *cur, *up = 0; int rc; void *help, *chain; char *topic; /* help topic title, for putting on the * help box titlebar*/ if (document == 0) return; CREATE(pages); cur = &EXPAND(pages); cur->cursor = 0; cur->file = helpfile(document, root); do { help = newHelp(0, 0, (COLS*3)/4, LINES-10, cur->file, (pfo)ndhcallback, 0); /*setObjTitle(help, cur->file);*/ if (cur->cursor) setHelpCursor(help, cur->cursor); chain = ObjChain(help, newCancelButton(0,"Done", 0, 0)); rc = MENU(chain, -1, -1, getHelpTopic(help), 0, 0); if (rc == MENU_OK) { if (( topic = currentHtmlTag(help) )) { cur->cursor = getHelpCursor(help); up = cur; cur = &EXPAND(pages); cur->cursor = 0; cur->file = helpfile(topic, up ? up->file : root); } } else if (rc == MENU_ESCAPE) { free(cur->file); S(pages)--; up = (S(pages) > 1) ? &T(pages)[S(pages)-2]:0; cur = &T(pages)[S(pages)-1]; } else if (rc == MENU_CANCEL) { int i; for (i = 0; i < S(pages); i++) free(T(pages)[i].file); } deleteObjChain(chain); } while ( S(pages) > 0 ); DELETE(pages); #if HAVE_DOUPDATE doupdate(); #else refresh(); #endif } /* _nd_help */