static void show_flag_status(void) { int keypress; int flag_val; clear_line(); bb_putchar('_'); keypress = less_getch(1); switch (keypress) { case 'M': flag_val = option_mask32 & FLAG_M; break; case 'm': flag_val = option_mask32 & FLAG_m; break; case '~': flag_val = option_mask32 & FLAG_TILDE; break; case 'N': flag_val = option_mask32 & FLAG_N; break; case 'E': flag_val = option_mask32 & FLAG_E; break; default: flag_val = 0; break; } clear_line(); printf(HIGHLIGHT"The status of the flag is: %u"NORMAL, flag_val != 0); }
static void add_mark(void) { int letter; int mark_line; clear_line(); printf("Mark: "); letter = tless_getch(); if (isalpha(letter)) { mark_line = line_pos; /* If we exceed 15 marks, start overwriting previous ones */ if (num_marks == 14) num_marks = 0; mark_lines[num_marks][0] = letter; mark_lines[num_marks][1] = line_pos; num_marks++; } else { clear_line(); printf("%s%s%s", HIGHLIGHT, "Invalid mark letter", NORMAL); } }
//-------------------------------------------------------------- //record_floor_reqs() -- get requests from riders outside car void building::record_floor_reqs() { char ch = 'x'; //utility char for input char ustring[BUF_LENGTH]; //utility string for input int iFloor; //floor from which request made char chDirection; //'u' or 'd' for up or down set_cursor_pos(1,22); //bottom of screen cout << "Press [Enter] to call an elevator: "; if( !kbhit() ) //wait for keypress (must be CR) return; cin.ignore(10, '\n'); if(ch=='\x1B') //if escape key, end program exit(0); set_cursor_pos(1,22); clear_line(); //clear old text set_cursor_pos(1,22); //bottom of screen cout << "Enter the floor you're on: "; cin.get(ustring, BUF_LENGTH); //get floor cin.ignore(10, '\n'); //eat chars, including newline iFloor = atoi(ustring); //convert to integer cout << "Enter direction you want to go (u or d): "; cin.get(chDirection); //(avoid multiple linefeeds) cin.ignore(10, '\n'); //eat chars, including newline if(chDirection=='u' || chDirection=='U') floor_request[UP][iFloor-1] = true; //up floor request if(chDirection=='d' || chDirection=='D') floor_request[DN][iFloor-1] = true; //down floor request set_cursor_pos(1,22); clear_line(); //clear old text set_cursor_pos(1,23); clear_line(); set_cursor_pos(1,24); clear_line(); } //end record_floor_reqs()
static el_status_t h_search(void) { static int Searching; const char *old_prompt; const char *(*move)(void); const char *p; if (Searching) return el_ring_bell(); Searching = 1; clear_line(); old_prompt = rl_prompt; rl_prompt = "Search: "; tty_puts(rl_prompt); move = Repeat == NO_ARG ? prev_hist : next_hist; p = editinput(); rl_prompt = old_prompt; Searching = 0; tty_puts(rl_prompt); if (p == NULL && el_intr_pending > 0) { el_intr_pending = 0; clear_line(); return redisplay(); } p = search_hist(p, move); clear_line(); if (p == NULL) { el_ring_bell(); return redisplay(); } return do_insert_hist(p); }
void move_cursor_to_start_of_prompt(int erase) { int termwidth = winsize.ws_col; int promptlen_on_screen, number_of_lines_in_prompt, curpos, count; int cooked = (saved_rl_state.cooked_prompt != NULL); DPRINTF2(DEBUG_READLINE,"prompt_is_still_uncooked: %d, impatient_prompt: %d", prompt_is_still_uncooked, impatient_prompt); if (prompt_is_still_uncooked && ! impatient_prompt) return; /* @@@ is this necessary ?*/ promptlen_on_screen = colourless_strlen_unmarked(saved_rl_state.cooked_prompt ? saved_rl_state.cooked_prompt : saved_rl_state.raw_prompt, termwidth); curpos = (within_line_edit ? 1 : 0); /* if the user has pressed a key the cursor will be 1 past the current prompt */ assert(termwidth > 0); number_of_lines_in_prompt = 1 + ((promptlen_on_screen + curpos -1) / termwidth); /* integer arithmetic! (e.g. 171/80 = 2) */ cr(); for (count = 0; count < number_of_lines_in_prompt -1; count++) { if (erase) clear_line(); curs_up(); } clear_line(); DPRINTF4(DEBUG_READLINE,"moved cursor up %d lines (erase = %d, len=%d, cooked=%d)", number_of_lines_in_prompt - 1, erase, promptlen_on_screen, cooked); }
static void show_flag_status(void) { int keypress; int flag_val; clear_line(); putchar('_'); keypress = tless_getch(); switch (keypress) { case 'M': flag_val = flags & FLAG_M; break; case 'm': flag_val = flags & FLAG_m; break; case '~': flag_val = flags & FLAG_TILDE; break; case 'N': flag_val = flags & FLAG_N; break; case 'E': flag_val = flags & FLAG_E; break; default: flag_val = 0; break; } clear_line(); printf("%s%s%i%s", HIGHLIGHT, "The status of the flag is: ", flag_val != 0, NORMAL); }
void init_display_buffer(ui_context * ctx) { int i; font_type * font; font = font_list[ctx->font_id]; ctx->screen_txt_xsize = ctx->SCREEN_XRESOL / font->char_x_size; ctx->screen_txt_ysize = (ctx->SCREEN_YRESOL / font->char_y_size); ctx->NUMBER_OF_ENTRIES_ON_DISPLAY = ctx->screen_txt_ysize - 2; // (Display size minus top + bottom) ctx->NUMBER_OF_FILE_ON_DISPLAY = ctx->NUMBER_OF_ENTRIES_ON_DISPLAY - 1; // (Display size minus top + bottom + tittle) chg_video_conf(ctx); // Clear all lines. for(i=0;i<ctx->screen_txt_ysize;i++) { clear_line(ctx, i, 0 ); } // Footprint : Current software / firmware version and title clear_line(ctx, ctx->screen_txt_ysize - 1, INVERTED); hxc_printf(ctx,LEFT_ALIGNED | INVERTED,0, ctx->screen_txt_ysize - 1,"FW %s",ctx->FIRMWAREVERSION); hxc_print(ctx,CENTER_ALIGNED | INVERTED,0,ctx->screen_txt_ysize - 1,(char*)title_msg); hxc_print(ctx,RIGHT_ALIGNED | INVERTED,0,ctx->screen_txt_ysize - 1,(char*)copyright_msg); // Top header : current folder path clear_line(ctx, 0, INVERTED); hxc_print(ctx,LEFT_ALIGNED|INVERTED,0,0, (char*)cur_folder_msg); }
static int find_command(char *line, int curr_index, int forward) { int res, cmd_ind, len, ind, c, line_size; char str[READ_BUF_SIZE]; char text[READ_BUF_SIZE]; len = strlen(line) + strlen(Title); clear_line(len, len); if (forward) { if (curr_index == current_hist_ind) { printf("%c", BELL_KEY); return(curr_index); } } else { if (curr_index <= 0) { printf("%c", BELL_KEY); return(0); } }; memset(text, 0, READ_BUF_SIZE); len = 0; ind = 0; cmd_ind = curr_index; for (;;) { line_size = ind + strlen(History[cmd_ind]); if (forward) res = find_cmd_by_text(text, cmd_ind, 1); else res = find_cmd_by_text(text, cmd_ind, 0); if (res != -1) cmd_ind = res; else printf("%c", BELL_KEY); if (forward) snprintf(str, READ_BUF_SIZE, "(i-search)`%s': ", text); else snprintf(str, READ_BUF_SIZE, "(revers-i-search)`%s': ", text); clear_line(ind, line_size); ind = print_str_by_index(str, 0, -1); print_str_by_index(History[cmd_ind], 0, 0); c = getchar(); if (c == BACKSP_KEY) { len--; if (len < 0) len = 0; text[len] = 0; } else if ((c < ' ') || (c > 'z')) { ungetc(c, stdin); break; }; text[len++] = c; if (len >= READ_BUF_SIZE) break; }; res = ind + strlen(History[cmd_ind]); clear_line(ind, res); return(cmd_ind); }
void exception_handler(int vec_no, int err_code, int eip, int cs, int eflags) { char *err_msg[] = { "#DE: Dvivde Error", "#DB: RESERVED", "-- : NMI Interrupt", "#BP: Breakppoint", "#OF: Overflow", "#BR: BOUND Range Exceeded", "#UD: Invalid Opcode (Undefined Opcode)", "#NM: Device Not Available (No Math Coprocessor)", "#DF: Double Fault", " : Coprocessor Segment Overrun (reserved)", "#TS: Invalid TSS", "#NP: Segment Not Present", "#SS: Stack-Segment Fault", "#GP: General Protection", "#PF: Page Fault", "-- : (Intel reserved. Do not use.)", "#MF: x87 FPU Floating-Point Error (Math Fault)", "#AC: Alignment Check", "#MC: Machine Check", "#XF: SIMD Floating-Point Exceprion" }; //clear(); s32_print("exception_handler", (u8*)(0xb8000+160*24)); u8 str[12]=""; u8 *str_ptr = str; clear_line(0); clear_line(1); clear_line(2); clear_line(3); clear_line(23); s32_print(err_msg[vec_no], (u8*)(0xb8000+160*23)); str_ptr = s32_itoa(eflags, str_ptr, 16); s32_print("eflags", (u8*)(0xb8000+160*0)); s32_print(str_ptr, (u8*)(0xb8000+160*1)); str_ptr = s32_itoa(cs, str_ptr, 16); s32_print("cs", (u8*)(0xb8000+160*2)); s32_print(str_ptr, (u8*)(0xb8000+160*3)); str_ptr = s32_itoa(eip, str_ptr, 16); clear_line(4); s32_print("eip", (u8*)(0xb8000+160*4)); clear_line(5); s32_print(str_ptr, (u8*)(0xb8000+160*5)); if (err_code != 0xffffffff) { str_ptr = s32_itoa(err_code, str_ptr, 16); clear_line(6); s32_print("err_code", (u8*)(0xb8000+160*6)); clear_line(7); s32_print(str_ptr, (u8*)(0xb8000+160*7)); } }
// ************************************************************************************************* // @fn display_selection_altaccum // @brief Display altitude accumulator ON or OFF // @param u8 segments where to display, usually LCD_SEG_L2_4_0 // u32 index 0 = OFF, 1 = ON // u8 digits Not used // u8 blanks Not used // @return none // ************************************************************************************************* void display_selection_altaccum (u8 segments, u32 index, u8 digits, u8 blanks) { if (index) { clear_line(LINE2); display_chars(segments, (u8*)" ON ", SEG_ON_BLINK_ON); // display "ON" on bottom line } else { clear_line(LINE2); display_chars(segments, (u8*)" OFF ", SEG_ON_BLINK_ON); // display "OFF" on bottom line } }
// ************************************************************************************************* // @fn display_update // @brief Process display flags and call LCD update routines. // @param none // @return none // ************************************************************************************************* void display_update(void) { unsigned char line; unsigned char string[8]; // --------------------------------------------------------------------- // Call Line1 display function if (display.flag.full_update || display.flag.line1_full_update) { clear_line(LINE1); fptr_lcd_function_line1(LINE1, DISPLAY_LINE_UPDATE_FULL); } else if (ptrMenu_L1->display_update()) { // Update line1 only when new data is available fptr_lcd_function_line1(LINE1, DISPLAY_LINE_UPDATE_PARTIAL); } // --------------------------------------------------------------------- // If message text should be displayed on Line2, skip normal update if (message.flag.show) { line = LINE2; // Select message to display if (message.flag.type_locked) memcpy(string, " LO?T", 6); else if (message.flag.type_unlocked) memcpy(string, " OPEN", 6); // Clear previous content clear_line(line); fptr_lcd_function_line2(line, DISPLAY_LINE_CLEAR); // Next second tick erases message and repaints original screen content message.all_flags = 0; message.flag.erase = 1; } // --------------------------------------------------------------------- // Call Line2 display function else if (display.flag.full_update || display.flag.line2_full_update) { clear_line(LINE2); fptr_lcd_function_line2(LINE2, DISPLAY_LINE_UPDATE_FULL); } else if (ptrMenu_L2->display_update() && !message.all_flags) { // Update line2 only when new data is available fptr_lcd_function_line2(LINE2, DISPLAY_LINE_UPDATE_PARTIAL); } // Clear display flag display.all_flags = 0; }
void CaenVmeIrqCheck(int32_t BHandle, man_par_t *man) { CVErrorCodes ret ; con_printf(" CHECK IRQ\n"); CAENVME_IRQCheck(BHandle,&man->irqstat); // Check IRQ Status con_printf(" IRQ status: %02X\n",man->irqstat); con_printf(" Interrupt Level to Acknowledge (0 to exit) : "); // Get the int level con_scanf("%x",&man->level); if (man->level == 0) { clear_line(Y_COMM); clear_line(Y_COMM+1); clear_line(Y_COMM+2); return ; } con_printf_xy(X_COMM,Y_COMM+2," Waiting for interrupt ... Press any key to stop."); while (!(man->irqstat & (1<<(man->level-1))) && !con_kbhit()) // Check Int loop CAENVME_IRQCheck(BHandle,&man->irqstat); gotoxy(X_COMM,Y_COMM) ; if(man->irqstat & (1<<(man->level-1))) { ret = CAENVME_IACKCycle(BHandle,man->level,&man->data,man->dtsize); switch (ret) { case cvSuccess : con_printf(" Cycle completed normally\n"); con_printf(" Int. Ack. on IRQ%d: StatusID = %0X",man->level,man->data); break ; case cvBusError : con_printf(" Bus Error !!!"); break ; case cvCommError : con_printf(" Communication Error !!!"); break ; default : con_printf(" Unknown Error !!!"); break ; } } else con_printf(" Interrupt request IRQ%d not active",man->level); }
void update_display(void) { void (*display_handler)(char*,char*) = state_handlers[state].display; char line_1[17]; char line_2[17]; clear_line(line_1); clear_line(line_2); if (display_handler == NULL) return; display_handler(line_1, line_2); display_line(LCD_LINE_1, line_1); display_line(LCD_LINE_2, line_2); }
/*ARGSUSED*/ int menu_import(WINDOW *win, node_t *current, node_t *list) { char inv_path[MAXPATHLEN]; struct stat s; char *fstabname; data_t *d; for(;;) { inv_path[0] = '\0'; if(get_string(win, "Path to inventory to be imported: ", inv_path, MAXPATHLEN) == ERR) { put_error("Error: invalid input"); continue; } if(strlen(inv_path) == 0) { clear_line(stdscr, LINES - 1); return BOOL_FALSE; } if(stat(inv_path, &s) < 0 || !S_ISDIR(s.st_mode)) { put_error("Error: invalid path"); continue; } clear_line(stdscr, LINES - 1); fstabname = GetFstabFullPath(inv_path); if(fstabname == NULL) { put_footer("internal memory error: import inventory", ALIGN_LEFT); exit(1); } while(current->next != NULL) { current = current->next; } generate_fstab_menu(inv_path, current, 0, fstabname); free(fstabname); while(current->next != NULL) { current = current->next; d = current->data; d->text[1] = 'I'; d->imported = BOOL_TRUE; } redraw_screen = BOOL_TRUE; break; } return BOOL_FALSE; }
void chg_dir() { extern int fd; WINDOW *ch_win, *newwin(); char *ans, *dir, *expand(), *cwd, *getcwd(), cwdbuf[200]; char *get_str(); cwd = getcwd(cwdbuf, 200); ch_win = newwin(6, 70, 5, 5); mvwprintw(ch_win, 2, 4, "Current directory: %s", cwd); mvwaddstr(ch_win, 3, 4, "New directory: "); box(ch_win, VERT, HORZ); mvwattrstr(ch_win, 0, 3, A_BOLD, " Change directory "); wmove(ch_win, 3, 19); wrefresh(ch_win); /* get the answer */ while ((ans = get_str(ch_win, 80, "", " \t\n")) != NULL) { /* a CR means no change */ if (*ans == '\0') break; /* expand the input */ dir = expand(ans); /* if you have search permission */ if (!access(dir, 1)) { if (!chdir(dir)) break; } beep(); mvwattrstr(ch_win, 4, 15, A_BOLD, "No such directory or no access permission"); wrefresh(ch_win); wait_key(ch_win, 3); /* clean up the mess */ clear_line(ch_win, 3, 19, TRUE); clear_line(ch_win, 4, 14, TRUE); wmove(ch_win, 3, 19); wrefresh(ch_win); } if (fd == -1) { werase(ch_win); wrefresh(ch_win); } delwin(ch_win); return; }
//----------------------------------------------------------------------------- void graphics::show_time(const tm* lcTime, int line_no) { const int SIZE = 50; int length; int xCo; char memBuff[SIZE]; ostrstream oMemBuff(memBuff, SIZE); oMemBuff << dayOfWeek[lcTime->tm_wday] << ", " << lcTime->tm_mday << ' ' << months[lcTime->tm_mon] << ' ' << lcTime->tm_year + 1900 << ". "; if(lcTime->tm_hour < 10) oMemBuff << '0' << lcTime->tm_hour << " : "; else oMemBuff << lcTime->tm_hour << " : "; if(lcTime->tm_min < 10) oMemBuff << '0' << lcTime->tm_min << " : "; else oMemBuff << lcTime->tm_min << " : "; if(lcTime->tm_sec < 10) oMemBuff << '0' << lcTime->tm_sec; else oMemBuff << lcTime->tm_sec; oMemBuff << '\0'; length = strlen(memBuff); xCo = (console_size.X - length) / 2; set_cursor_pos(1, line_no); clear_line(); set_cursor_pos(xCo, line_no); cout << memBuff; }
int distrib_buttons(int i, char **result, char *buffer, int *v) { if (buffer[0] == 10) return (-2); else if (buffer[0] == 27 && buffer[1] == 91) i = distrib_arrow(i, result, buffer, v); else if (buffer[0] == 127) *result = del_c(*result, &i); else if (buffer[0] == 9 && *result && i == ft_strlen(*result)) i = distrib_tab(i, result); else if (buffer[0] == 12) clear_and_prompt(); else if (buffer[0] == 1) i = ctrl_a(i, result); else if (buffer[0] == 5) i = ctrl_k(i, result); else if (buffer[0] == 21) { clear_line(i + 1, ft_strlen(*result)); *result = NULL; i = 0; } else if (buffer[0] == 4) ft_exit(NULL); else ft_putstr(tgetstr("le", NULL)); return (i); }
static void buffer_line(int linenum) { int i; past_eof = 0; if (linenum < 0 || linenum > num_flines) { clear_line(); printf("%s%s%i%s", HIGHLIGHT, "Cannot seek to line number ", linenum + 1, NORMAL); } else if (linenum < (num_flines - height - 2)) { for (i = 0; i < (height - 1); i++) { free(buffer[i]); buffer[i] = bb_xstrdup(flines[linenum + i]); } line_pos = linenum; buffer_print(); } else { for (i = 0; i < (height - 1); i++) { free(buffer[i]); if (linenum + i < num_flines + 2) buffer[i] = bb_xstrdup(flines[linenum + i]); else buffer[i] = bb_xstrdup((flags & FLAG_TILDE) ? "\n" : "~\n"); } line_pos = linenum; /* Set past_eof so buffer_down and buffer_up act differently */ past_eof = 1; buffer_print(); } }
void draw_keybindings(PANEL *panel, const char *keybindings[], int count) { int height, width, key, xpos = 0; // Get window available space WINDOW *win = panel_window(panel); getmaxyx(win, height, width); // Reverse colors on monochrome terminals if (!has_colors()) wattron(win, A_REVERSE); // Write a line all the footer width wattron(win, COLOR_PAIR(CP_DEF_ON_CYAN)); clear_line(win, height - 1); // Draw keys and their actions for (key = 0; key < count; key += 2) { wattron(win, A_BOLD | COLOR_PAIR(CP_WHITE_ON_CYAN)); mvwprintw(win, height - 1, xpos, "%-*s", strlen(keybindings[key]) + 1, keybindings[key]); xpos += strlen(keybindings[key]) + 1; wattroff(win, A_BOLD | COLOR_PAIR(CP_WHITE_ON_CYAN)); wattron(win, COLOR_PAIR(CP_BLACK_ON_CYAN)); mvwprintw(win, height - 1, xpos, "%-*s", strlen(keybindings[key + 1]) + 1, keybindings[key + 1]); wattroff(win, COLOR_PAIR(CP_BLACK_ON_CYAN)); xpos += strlen(keybindings[key + 1]) + 3; } // Disable reverse mode in all cases wattroff(win, A_REVERSE); }
u8 update_schedule() { update_schedule_time(); clear_line(LINE2); if(sSchedule.state == SCHEDULE_ENABLED) { if(sSchedule.currentlyShown == PERIOD) { display_chars(LCD_SEG_L2_4_0, sSchedule.period, SEG_ON); } else if(sSchedule.currentlyShown == TIME) { display_chars(LCD_SEG_L2_3_0, itoa(sSchedule.end, 4, 0), SEG_ON); display_symbol(LCD_SEG_L2_COL0, SEG_ON); } } else if (sSchedule.state == SCHEDULE_DISABLED) { display_chars(LCD_SEG_L2_4_0, sSchedule.period, SEG_ON); } /*else if (sSchedule.state == SCHEDULE_NONE) { if (is_schedule()) { menu_skip_next(LINE2); } }*/ return 1; }
void move_history_down(t_prompt *prompt, char **history) { int max_hist; max_hist = dlen(history); clear_line(prompt); ++prompt->curr_history; while (prompt->curr_history < max_hist && prompt->count_char > 0 && !strncmp(prompt->line, history[prompt->curr_history], prompt->count_char)) ++prompt->curr_history; if (prompt->curr_history == dlen(history)) { memcpy(prompt->line, prompt->tmp_history, strlen(prompt->tmp_history)); prompt->count_char = strlen(prompt->tmp_history); } else { memcpy(prompt->line, history[prompt->curr_history], strlen(history[prompt->curr_history])); prompt->count_char = strlen(history[prompt->curr_history]); } prompt->count_pos = prompt->count_char; }
static void match_left_bracket(char bracket) { int bracket_line = -1; int i; clear_line(); if (strchr(flines[line_pos + height - 2], bracket) == NULL) { printf("%s%s%s", HIGHLIGHT, "No bracket in bottom line", NORMAL); printf("%s", flines[line_pos + height]); sleep(4); } else { for (i = line_pos + height - 2; i >= 0; i--) { if (strchr(flines[i], opp_bracket(bracket)) != NULL) { bracket_line = i; break; } } if (bracket_line == -1) printf("%s%s%s", HIGHLIGHT, "No matching bracket found", NORMAL); buffer_line(bracket_line); } }
/*-----------------------------------------------------------------------------------*/ static void s_ctk_draw_clear(unsigned char y1, unsigned char y2) { for(i = y1; i < y2; ++i) { clear_line(i); } }
uint8_t LCD_service::display_TUN_packet(uint8_t* m_TUN_storage) { // x and y coordinates uint8_t x = 0; uint8_t y = 0; uint8_t LCD_payload_sz = 0; // temp storage uint8_t LCD_payload[MED_BUFF_SZ]; // extract the LCD packet LCD_payload_sz = m_util.get_TUN_payload(m_TUN_storage, LCD_payload, MED_BUFF_SZ); if(LCD_payload_sz != 0) { // get the X and Y coordinates x = m_util.hex_to_int(LCD_X_START, LCD_X_END, LCD_X_SZ, LCD_payload); y = m_util.hex_to_int(LCD_Y_START, LCD_Y_END, LCD_Y_SZ, LCD_payload); // figure out the msg size LCD_payload_sz -= (LCD_X_SZ + LCD_Y_SZ); // clear the line clear_line(x); // set the cursor lcd_setCursor(x, y); // display the string for(uint8_t i = 0; i < LCD_payload_sz; i++) lcd_putc((const char)LCD_payload[i+LCD_MSG_START]); } }
// ************************************************************************************************* // @fn sx_rfbsl // @brief This functions starts the RFBSL // @param line LINE1, LINE2 // @return none // ************************************************************************************************* void sx_rfbsl(u8 line) { // Exit if battery voltage is too low for radio operation if (sys.flag.low_battery) return; // Exit if BlueRobin stack is active if (is_bluerobin()) return; // Exit if SimpliciTI stack is active if (is_rf()) return; rfBSL_button_confirmation++; if (rfBSL_button_confirmation == 2) { // Before entering RFBSL clear the LINE1 Symbols display_symbol(LCD_SYMB_AM, SEG_OFF); clear_line(LINE1); // Write RAM to indicate we will be downloading the RAM Updater first display_chars(LCD_SEG_L2_5_0, (u8 *) " RFBSL", SEG_ON); display_chars(LCD_SEG_L1_3_0, (u8 *) " RAM", SEG_ON); // Call RFBSL CALL_RFSBL(); } }
static void flag_change(void) { int keypress; clear_line(); putchar('-'); keypress = tless_getch(); switch (keypress) { case 'M': flags ^= FLAG_M; break; case 'm': flags ^= FLAG_m; break; case 'E': flags ^= FLAG_E; break; case '~': flags ^= FLAG_TILDE; break; default: break; } }
static void flag_change(void) { int keypress; clear_line(); bb_putchar('-'); keypress = less_getch(1); switch (keypress) { case 'M': option_mask32 ^= FLAG_M; break; case 'm': option_mask32 ^= FLAG_m; break; case 'E': option_mask32 ^= FLAG_E; break; case '~': option_mask32 ^= FLAG_TILDE; break; case 'S': option_mask32 ^= FLAG_S; buffer_fill_and_print(); break; #if ENABLE_FEATURE_LESS_LINENUMS case 'N': option_mask32 ^= FLAG_N; re_wrap(); buffer_fill_and_print(); break; #endif } }
/* Print the status line */ static void status_print(void) { const char *p; if (less_gets_pos >= 0) /* don't touch statusline while input is done! */ return; /* Change the status if flags have been set */ #if ENABLE_FEATURE_LESS_FLAGS if (option_mask32 & (FLAG_M|FLAG_m)) { m_status_print(); return; } /* No flags set */ #endif clear_line(); if (cur_fline && cur_fline < (int)(max_fline - max_displayed_line)) { bb_putchar(':'); return; } p = "(END)"; if (!cur_fline) p = filename; if (num_files > 1) { printf(HIGHLIGHT"%s (file %i of %i)"NORMAL, p, current_file, num_files); return; } print_hilite(p); }
void call_list_draw_header(PANEL *panel) { const char *infile, *coldesc; int height, width, colpos, collen, i; // Get panel info call_list_info_t *info = call_list_info(panel); // Let's draw the fixed elements of the screen WINDOW *win = panel_window(panel); getmaxyx(win, height, width); // Draw panel title draw_title(panel, "sngrep - SIP messages flow viewer"); // Draw a Panel header lines clear_line(win, 1); if ((infile = capture_get_infile())) mvwprintw(win, 1, width - strlen(infile) - 11, "Filename: %s", infile); mvwprintw(win, 2, 2, "Display Filter: "); mvwprintw(win, 1, 2, "Current Mode: %s", capture_get_status_desc()); // Reverse colors on monochrome terminals if (!has_colors()) wattron(win, A_REVERSE); // Draw columns titles wattron(win, A_BOLD | COLOR_PAIR(CP_DEF_ON_CYAN)); mvwprintw(win, 3, 0, "%*s", width, ""); for (colpos = 6, i = 0; i < info->columncnt; i++) { // Get current column width collen = info->columns[i].width; // Get current column title coldesc = sip_attr_get_title(info->columns[i].id); // Check if the column will fit in the remaining space of the screen if (colpos + strlen(coldesc) >= width) break; mvwprintw(win, 3, colpos, "%.*s", collen, coldesc); colpos += collen + 1; } // Print Autoscroll indicator if (info->autoscroll) mvwprintw(win, 3, 0, "A"); wattroff(win, A_BOLD | A_REVERSE | COLOR_PAIR(CP_DEF_ON_CYAN)); // Get filter call counters sip_calls_stats(&info->callcnt, &info->dispcallcnt); // Print calls count (also filtered) mvwprintw(win, 1, 35, "%*s", 35, ""); if (info->callcnt != info->dispcallcnt) { mvwprintw(win, 1, 35, "Dialogs: %d (%d displayed)", info->callcnt, info->dispcallcnt); } else { mvwprintw(win, 1, 35, "Dialogs: %d", info->callcnt); } }
void CaenVmeRead(int32_t BHandle, man_par_t *man) { uint32_t i,old_data=0 ; CVErrorCodes ret,old_ret=cvSuccess; if(man->dtsize == cvD64) { con_printf(" Can't execute a D64 Read Cycle"); return ; } if(man->ncyc == 0) // Infinite Loop con_printf_xy(X_COMM,Y_COMM+2," Running ... Press any key to stop."); for (i=0; ((man->ncyc==0) || (i<man->ncyc)) && !con_kbhit(); i++) { ret = CAENVME_ReadCycle(BHandle,man->addr,&man->data,man->am,man->dtsize); if((i==0) || (ret != old_ret)) { gotoxy(X_COMM,Y_COMM) ; switch (ret) { case cvSuccess : con_printf(" Cycle(s) completed normally\n"); if((i==0) || (old_data != man->data)) { if( man->dtsize == cvD32 ) con_printf(" Data Read : %08X",man->data); if( man->dtsize == cvD16 ) con_printf(" Data Read : %04X",man->data & 0xffff); if( man->dtsize == cvD8 ) con_printf(" Data Read : %02X",man->data & 0xff); } break ; case cvBusError : con_printf(" Bus Error !!!"); break ; case cvCommError : con_printf(" Communication Error !!!"); break ; default : con_printf(" Unknown Error !!!"); break ; } } old_data = man->data; old_ret = ret; if(man->autoinc) { man->addr += man->dtsize; // Increment address (+1 or +2 or +4) con_printf_xy(X_ADDR,Y_ADDR,"%08X]",man->addr); // Update the screen } } if(man->ncyc == 0) clear_line(Y_COMM+2); }