void Text::keystroke(const Event& event) {
if (readOnly_) {
return;
}
char buffer[8]; // needs to be dynamically adjusted
int count = event.mapkey(buffer, 8);
if (count <= 0) {
return;
}
// return causes a newline
if (buffer[0] == '\r') {
buffer[0] = '\n';
}
context_key(buffer[0]);
if (buffer[0] == 2) // control-b
{
if (insertion_.column_ > 0)
{
--insertion_.column_;
damage(insertion_);
repair();
}else if (insertion_.line_ > 0) {
damage(insertion_);
--insertion_.line_;
// now just like a control-e
int index = text_->LineIndex(insertion_.line_);
int end = text_->EndOfLine(index);
insertion_.column_ = end - index;
damage(insertion_);
repair();
}
return;
}
else if (buffer[0] == 1) // control-a
{
insertion_.column_ = 0;
damage(insertion_);
repair();
return;
}
else if (buffer[0] == 6) // control-f
{
int index = text_->LineIndex(insertion_.line_);
int end = text_->EndOfLine(index);
if (insertion_.column_ < end - index)
{
++insertion_.column_;
damage(insertion_);
repair();
}else if (insertion_.line_ < text_->Height()-1) {
damage(insertion_);
++insertion_.line_;
// now just like control-a
insertion_.column_ = 0;
damage(insertion_);
repair();
}
return;
}
else if (buffer[0] == 5) // control-e
{
int index = text_->LineIndex(insertion_.line_);
int end = text_->EndOfLine(index);
insertion_.column_ = end - index;
damage(insertion_);
repair();
return;
}
else if (buffer[0] == 16) { // control-p
if (insertion_.line_ > 0) {
damage(insertion_);
--insertion_.line_;
insertion_.column_ = ctl_pn_col_;
int index = text_->LineIndex(insertion_.line_);
int col = text_->EndOfLine(index) - index;
if (col < insertion_.column_){
insertion_.column_ = col;
}
damage(insertion_);
repair();
}
return;
}else if (buffer[0] == 14) { // control-n
if (insertion_.line_ < text_->Height()-1) {
damage(insertion_);
++insertion_.line_;
insertion_.column_ = ctl_pn_col_;
int index = text_->LineIndex(insertion_.line_);
int col = text_->EndOfLine(index) - index;
if (col < insertion_.column_){
insertion_.column_ = col;
}
damage(insertion_);
repair();
}
return;
}else if (escape_ == 1) { // escaped chars
if (buffer[0] == '>') { // to end of buffer
damage(insertion_);
if (text_->Height() >0) {
insertion_.line_ = text_->Height()-1;
} else {
insertion_.line_ = 0;
}
int index = text_->LineIndex(text_->EndOfText());
insertion_.column_ = text_->EndOfText()-index;
damage(insertion_);
repair();
}else if (buffer[0] == '<') {// to beginning of buffer
damage(insertion_);
insertion_.line_ = 0;
insertion_.column_ = 0;
damage(insertion_);
repair();
}
return;
}else if (buffer[0] == 033) { // ignore the escape itself
return;
}
else if (buffer[0] == 4) // ctrl-d
{
if (!delete_selection()) {
// like a ctrl-f then backspace
int index = text_->LineIndex(insertion_.line_);
int end = text_->EndOfLine(index);
if (insertion_.column_ < end - index)
{
++insertion_.column_;
backspace();
}else if (insertion_.line_ < text_->Height()-1) {
++insertion_.line_;
// now just like control-a
insertion_.column_ = 0;
backspace();
}
}
}
else if (buffer[0] == 21) {
// control u
eraseLine();
}
else if ((buffer[0] == '\b') || (buffer[0] == 127)) {
// backspace and delete
if (!delete_selection()) {
backspace();
}
}
else {
delete_selection();
insertChars(buffer, count);
}
dirty(true);
}
static size_t console_read(struct file *f, char *buf, size_t count)
{
struct console_file *console_file = (struct console_file *)f;
console_lock();
console_retrieve_state();
size_t bytes_read = 0;
while (console->input_buffer_head != console->input_buffer_tail && count > 0)
{
count--;
buf[bytes_read++] = console->input_buffer[console->input_buffer_tail];
console->input_buffer_tail = (console->input_buffer_tail + 1) % MAX_INPUT;
}
if (console->termios.c_lflag & ICANON)
{
char line[MAX_CANON + 1]; /* One more for storing CR or LF */
size_t len = 0;
while (count > 0)
{
INPUT_RECORD ir;
DWORD read;
ReadConsoleInputA(console->in, &ir, 1, &read);
if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown)
{
switch (ir.Event.KeyEvent.wVirtualKeyCode)
{
case VK_RETURN:
{
if (!(console->termios.c_iflag & IGNCR))
line[len++] = console->termios.c_iflag & ICRNL ? '\n' : '\r';
size_t r = min(count, len);
memcpy(buf + bytes_read, line, r);
bytes_read += r;
count -= r;
if (r < len)
{
/* Some bytes not fit, add to input buffer */
console_add_input(line + r, len - r);
}
if (console->termios.c_lflag & ECHO)
crnl();
goto read_done;
}
case VK_BACK:
{
if (len > 0)
{
len--;
if (console->termios.c_lflag & ECHO)
backspace(TRUE);
}
}
default:
{
char ch = ir.Event.KeyEvent.uChar.AsciiChar;
if (ch >= 0x20)
{
if (len < MAX_CANON)
{
line[len++] = ch;
if (console->termios.c_lflag & ECHO)
write_normal(&ch, 1);
}
}
}
}
}
}
}
else /* Non canonical mode */
{
int vtime = console->termios.c_cc[VTIME];
int vmin = console->termios.c_cc[VMIN];
while (count > 0)
{
if (bytes_read > 0 && bytes_read >= vmin)
break;
/* If vmin > 0 and vtime == 0, it is a blocking read, otherwise we need to poll first */
if (vtime > 0 || (vmin == 0 && vtime == 0))
{
if (WaitForSingleObject(console->in, vtime * 100) == WAIT_TIMEOUT)
break;
}
INPUT_RECORD ir;
DWORD read;
ReadConsoleInputA(console->in, &ir, 1, &read);
if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown)
{
switch (ir.Event.KeyEvent.wVirtualKeyCode)
{
case VK_UP:
console_buffer_add_string(buf, &bytes_read, &count, console->cursor_key_mode ? "\x1BOA" : "\x1B[A", 3);
break;
case VK_DOWN:
console_buffer_add_string(buf, &bytes_read, &count, console->cursor_key_mode ? "\x1BOB" : "\x1B[B", 3);
break;
case VK_RIGHT:
console_buffer_add_string(buf, &bytes_read, &count, console->cursor_key_mode ? "\x1BOC" : "\x1B[C", 3);
break;
case VK_LEFT:
console_buffer_add_string(buf, &bytes_read, &count, console->cursor_key_mode ? "\x1BOD" : "\x1B[D", 3);
break;
case VK_HOME:
console_buffer_add_string(buf, &bytes_read, &count, console->cursor_key_mode ? "\x1BOH" : "\x1B[H", 3);
break;
case VK_END:
console_buffer_add_string(buf, &bytes_read, &count, console->cursor_key_mode ? "\x1BOF" : "\x1B[F", 3);
break;
case VK_INSERT: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[2~", 4); break;
case VK_DELETE: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[3~", 4); break;
case VK_PRIOR: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[5~", 4); break;
case VK_NEXT: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[6~", 4); break;
case VK_F1: console_buffer_add_string(buf, &bytes_read, &count, "\x1BOP", 3); break;
case VK_F2: console_buffer_add_string(buf, &bytes_read, &count, "\x1BOQ", 3); break;
case VK_F3: console_buffer_add_string(buf, &bytes_read, &count, "\x1BOR", 3); break;
case VK_F4: console_buffer_add_string(buf, &bytes_read, &count, "\x1BOS", 3); break;
case VK_F5: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[15~", 5); break;
case VK_F6: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[17~", 5); break;
case VK_F7: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[18~", 5); break;
case VK_F8: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[19~", 5); break;
case VK_F9: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[20~", 5); break;
case VK_F10: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[21~", 5); break;
case VK_F11: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[23~", 5); break;
case VK_F12: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[24~", 5); break;
case VK_F13: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[25~", 5); break;
case VK_F14: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[26~", 5); break;
case VK_F15: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[28~", 5); break;
case VK_F16: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[29~", 5); break;
case VK_F17: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[31~", 5); break;
case VK_F18: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[32~", 5); break;
case VK_F19: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[33~", 5); break;
case VK_F20: console_buffer_add_string(buf, &bytes_read, &count, "\x1B[34~", 5); break;
default:
{
char ch = ir.Event.KeyEvent.uChar.AsciiChar;
if (ch == '\r' && console->termios.c_iflag & IGNCR)
break;
if (ch == '\r' && console->termios.c_iflag & ICRNL)
ch = '\n';
else if (ch == '\n' && console->termios.c_iflag & ICRNL)
ch = '\r';
if (ch > 0)
{
count--;
buf[bytes_read++] = ch;
if (console->termios.c_lflag & ECHO)
write_normal(&ch, 1);
}
}
}
}
else
{
/* TODO: Other types of input */
}
}
}
read_done:
/* This will make the caret immediately visible */
set_pos(console->x, console->y);
console_unlock();
return bytes_read;
}
int
main(int argc, char *argv[])
{
int index; /* index of last key we pushed in the bitmap font */
SDL_Window *window;
SDL_Event event; /* last event received */
SDLMod mod; /* key modifiers of last key we pushed */
SDL_scancode scancode; /* scancode of last key we pushed */
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("Error initializing SDL: %s", SDL_GetError());
}
/* create window */
window = SDL_CreateWindow("iPhone keyboard test", 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0);
/* create renderer */
SDL_CreateRenderer(window, 0, 0);
/* load up our font */
loadFont();
/* draw the background, we'll just paint over it */
SDL_SetRenderDrawColor(bg_color.r, bg_color.g, bg_color.b,
bg_color.unused);
SDL_RenderFill(NULL);
SDL_RenderPresent();
int done = 0;
/* loop till we get SDL_Quit */
while (SDL_WaitEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
done = 1;
break;
case SDL_KEYDOWN:
index = keyToIndex(event.key.keysym);
scancode = event.key.keysym.scancode;
mod = event.key.keysym.mod;
if (scancode == SDL_SCANCODE_DELETE) {
/* if user hit delete, delete the last character */
backspace();
lastCharWasColon = 0;
} else if (lastCharWasColon && scancode == SDL_SCANCODE_0
&& (mod & KMOD_SHIFT)) {
/* if our last key was a colon and this one is a close paren, the make a hoppy face */
backspace();
drawIndex(32); /* index for happy face */
numChars++;
drawCursor();
lastCharWasColon = 0;
} else if (index != -1) {
/* if we aren't doing a happy face, then just draw the normal character */
drawIndex(index);
numChars++;
drawCursor();
lastCharWasColon =
(event.key.keysym.scancode == SDL_SCANCODE_SEMICOLON
&& (event.key.keysym.mod & KMOD_SHIFT));
}
/* check if the key was a colon */
/* draw our updates to the screen */
SDL_RenderPresent();
break;
#ifdef __IPHONEOS__
case SDL_MOUSEBUTTONUP:
/* mouse up toggles onscreen keyboard visibility
this function is available ONLY on iPhone OS
*/
SDL_iPhoneKeyboardToggle(window);
break;
#endif
}
}
cleanup();
return 0;
}
static void TermCompletionOnFiles(char **dictionaryFiles, int sizedictionaryFiles,
char *lineBeforeCaret, char *lineAfterCaret, char *filePattern, char *defaultPattern,
char **wk_buf, unsigned int *cursor, unsigned int *cursor_max)
{
if (dictionaryFiles)
{
if (sizedictionaryFiles == 1)
{
char *new_line = completeLine(lineBeforeCaret, dictionaryFiles[0], filePattern, defaultPattern, TRUE, lineAfterCaret);
if (new_line)
{
char buflinetmp[WK_BUF_SIZE + 1];
strcpy(buflinetmp, new_line);
FREE(new_line);
backspace(*cursor);
erase_nchar(*cursor_max);
*cursor = *cursor_max = 0;
CopyLineAtPrompt(wk_buf, buflinetmp, cursor, cursor_max);
return;
}
}
else
{
char *common = getCommonPart(dictionaryFiles, sizedictionaryFiles);
displayCompletionDictionary(dictionaryFiles, sizedictionaryFiles, gettext("File or Directory"));
printf("\n");
backspace(*cursor);
erase_nchar(*cursor_max);
*cursor = *cursor_max = 0;
printPrompt(WRITE_PROMPT);
if (defaultPattern[0] == 0)
{
int lennewline = (int)strlen(lineBeforeCaret) + (int)strlen(lineAfterCaret);
char *new_line = (char *)MALLOC(sizeof(char) * (lennewline + 1));
if (new_line)
{
strcpy(new_line, lineBeforeCaret);
strcat(new_line, lineAfterCaret);
CopyLineAtPrompt(wk_buf, new_line, cursor, cursor_max);
FREE(new_line);
new_line = NULL;
}
}
else if (common)
{
char *new_line = completeLine(lineBeforeCaret, common, filePattern, defaultPattern, TRUE, lineAfterCaret);
if (new_line)
{
char buflinetmp[WK_BUF_SIZE + 1];
strcpy(buflinetmp, new_line);
FREE(new_line);
CopyLineAtPrompt(wk_buf, buflinetmp, cursor, cursor_max);
}
else
{
int lennewline = (int)strlen(lineBeforeCaret) + (int)strlen(lineAfterCaret);
new_line = (char *)MALLOC(sizeof(char) * (lennewline + 1));
if (new_line)
{
strcpy(new_line, lineBeforeCaret);
strcat(new_line, lineAfterCaret);
CopyLineAtPrompt(wk_buf, new_line, cursor, cursor_max);
FREE(new_line);
new_line = NULL;
}
}
}
if (common)
{
FREE(common);
common = NULL;
}
}
}
}
char * editLine(char *prompt)
{
/* The line to be edited is stored in cur_line.*/
/* get characters */
int cur_char;
for(;;) {
cur_char = special_getc();
if(isprint(cur_char) || (((unsigned char)cur_char > 0x7f) &&
cur_char != EOF) || cur_char == '\t') {
int i,inc = 1;
if(cur_char == '\t') {
inc = TABSTOPS;
cur_char = ' ';
}
if(max_pos+inc>=line_len)
extend_cur_line();
for(i=max_pos+inc-1; i-inc>=cur_pos; i--) {
cur_line[i] = cur_line[i-inc];
}
max_pos += inc;
while(inc--) {
user_putc(cur_char);
cur_line[cur_pos++] = cur_char;
}
if (cur_pos < max_pos)
fix_line();
cur_line[max_pos] = '\0';
#if MATCHPAREN
switch(cur_char) {
case ')':backupTo('(',')');break;
case ']':backupTo('[',']');break;
}
#endif
#if defined(VERASE)
} else if(cur_char == term_chars[VERASE] ){ /* DEL? */
if(cur_pos > 0) {
int i;
cur_pos -= 1;
backspace();
for(i=cur_pos; i<max_pos; i++)
cur_line[i] = cur_line[i+1];
max_pos -= 1;
fix_line();
}
} else if(cur_char == term_chars[VEOF] ){ /* ^D? */
if(max_pos == 0) {
copy_line("to exit EiC, enter :exit\n");
user_putc(BELL);
reset_termio();
return((char*)NULL);
}
if((cur_pos < max_pos)&&(cur_char == 004)) { /* ^D */
int i;
for(i=cur_pos; i<max_pos; i++)
cur_line[i] = cur_line[i+1];
max_pos -= 1;
fix_line();
}
} else if(cur_char == term_chars[VKILL] ){ /* ^U? */
clear_line(prompt);
} else if(cur_char == term_chars[VWERASE] ){ /* ^W? */
while((cur_pos > 0) &&
(cur_line[cur_pos-1] == SPACE)) {
cur_pos -= 1;
backspace();
}
while((cur_pos > 0) &&
(cur_line[cur_pos-1] != SPACE)) {
cur_pos -= 1;
backspace();
}
clear_eoline();
max_pos = cur_pos;
} else if(cur_char == term_chars[VREPRINT] ){ /* ^R? */
user_putc(NEWLINE); /* go to a fresh line */
redraw_line(prompt);
} else if(cur_char == term_chars[VSUSP]) {
reset_termio();
kill(0, SIGTSTP);
/* process stops here */
set_termio();
/* print the prompt */
redraw_line(prompt);
#endif
} else {
/* do normal editing commands */
/* some of these are also done above */
int i;
switch(cur_char) {
case EOF:
reset_termio();
return((char *)NULL);
case 001: /* ^A */
while(cur_pos > 0) {
cur_pos -= 1;
backspace();
}
break;
case 002: /* ^B */
if(cur_pos > 0) {
cur_pos -= 1;
backspace();
}
break;
case 005: /* ^E */
while(cur_pos < max_pos) {
user_putc(cur_line[cur_pos]);
cur_pos += 1;
}
break;
case 006: /* ^F */
if(cur_pos < max_pos) {
user_putc(cur_line[cur_pos]);
cur_pos += 1;
}
break;
case 013: /* ^K */
clear_eoline();
max_pos = cur_pos;
break;
case 020: /* ^P */
if(history != NULL) {
if(cur_entry == NULL) {
cur_entry = history;
clear_line(prompt);
copy_line(cur_entry->line);
} else if(cur_entry->prev != NULL) {
cur_entry = cur_entry->prev;
clear_line(prompt);
copy_line(cur_entry->line);
}else
user_putc(BELL);
}else
user_putc(BELL);
break;
case 016: /* ^N */
if(cur_entry != NULL) {
cur_entry = cur_entry->next;
clear_line(prompt);
if(cur_entry != NULL)
copy_line(cur_entry->line);
else
cur_pos = max_pos = 0;
}else
user_putc(BELL);
break;
case 014: /* ^L */
case 022: /* ^R */
user_putc(NEWLINE); /* go to a fresh line */
redraw_line(prompt);
break;
case 0177: /* DEL */
case 010: /* ^H */
if(cur_pos > 0) {
cur_pos -= 1;
backspace();
for(i=cur_pos; i<max_pos; i++)
cur_line[i] = cur_line[i+1];
max_pos -= 1;
fix_line();
}
break;
case 004: /* ^D */
if(max_pos == 0) {
reset_termio();
return((char *)NULL);
}
if(cur_pos < max_pos) {
for(i=cur_pos; i<max_pos; i++)
cur_line[i] = cur_line[i+1];
max_pos -= 1;
fix_line();
}
break;
case 025: /* ^U */
clear_line(prompt);
break;
case 027: /* ^W */
while((cur_pos > 0) &&
(cur_line[cur_pos-1] == SPACE)) {
cur_pos -= 1;
backspace();
}
while((cur_pos > 0) &&
(cur_line[cur_pos-1] != SPACE)) {
cur_pos -= 1;
backspace();
}
clear_eoline();
max_pos = cur_pos;
break;
case '\n': /* ^J */
case '\r': /* ^M */
user_putc(NEWLINE);
cur_line[max_pos+1] = '\0';
cur_line = (char *)ralloc(cur_line,
(unsigned
long)(strlen(cur_line)+2),
"line resize");
line_len=0;
reset_termio();
return cur_line;
default:
break;
}
}
}
}
static void backup(char *buffer, int pos)
{
backspace(xstrlen(&buffer[pos]));
}
int
get_token()
{
long number;
int type = UNDEF;
register int ch;
static char buffer[1024];
register char *ptr;
int dot_flag = FALSE;
while ((ch = next_char()) == '\n' || (isascii(ch) && iswhite(ch)));
if (ch == EOF)
type = EOF;
else {
if (ch == '.') {
dot_flag = TRUE;
while ((ch = next_char()) == ' ' || ch == '\t');
}
if (! isascii(ch) || ! isalnum(ch)) {
warning("Illegal character - '%c'", ch);
panic_mode(',');
}
ptr = buffer;
if (ch != '\n') *(ptr++) = ch;
if (first_column) {
while ((ch = next_char()) != ',' && ch != '\n' && ch != EOF)
*(ptr++) = ch;
if (ch == EOF)
err_abort("Premature EOF");
else if (ch == '\n') {
warning("Newline in middle of terminal name");
panic_mode(',');
}
*ptr = '\0';
curr_token.tk_name = buffer;
type = NAMES;
} else {
ch = next_char();
while (isascii(ch) && isalnum(ch)) {
*(ptr++) = ch;
ch = next_char();
}
*ptr++ = '\0';
switch (ch) {
case ',':
curr_token.tk_name = buffer;
type = BOOLEAN;
break;
case '@':
if (next_char() != ',')
warning("Missing comma");
curr_token.tk_name = buffer;
type = CANCEL;
break;
case '#':
number = 0;
if ((ch = next_char()) == ',')
warning("Missing numeric value");
backspace();
if ((ch = next_char()) == '0') {
if ((ch = next_char()) == 'x' || ch == 'X') {
while (isascii(ch = next_char()) &&
isxdigit(ch)) {
number *= 16;
if (isdigit(ch))
number += ch - '0';
else if (ch >= 'a' && ch <= 'f')
number += 10 + ch - 'a';
else
number += 10 + ch - 'A';
}
} else {
backspace();
while ((ch = next_char()) >= '0' &&
ch <= '7')
number = number * 8 + ch - '0';
}
} else {
backspace();
while (isascii(ch = next_char()) &&
isdigit(ch))
number = number * 10 + ch - '0';
}
if (ch != ',')
warning("Missing comma");
curr_token.tk_name = buffer;
curr_token.tk_valnumber = number;
type = NUMBER;
break;
case '=':
ch = trans_string(ptr);
if (ch != NULL && ch != ',')
warning("Missing comma");
if (ch == NULL)
warning("NULL string value");
curr_token.tk_name = buffer;
curr_token.tk_valstring = ptr;
type = STRING;
break;
default:
warning("Illegal character - '%c'", ch);
}
} /* end else (first_column == FALSE) */
} /* end else (ch != EOF) */
if (dot_flag == TRUE)
DEBUG(8, "Commented out ", "");
if (debug_level >= 8) {
fprintf(stderr, "Token: ");
switch (type) {
case BOOLEAN:
fprintf(stderr, "Boolean; name='%s'\n",
curr_token.tk_name);
break;
case NUMBER:
fprintf(stderr, "Number; name = '%s', value = %d\n",
curr_token.tk_name, curr_token.tk_valnumber);
break;
case STRING:
fprintf(stderr, "String; name = '%s', value = '%s'\n",
curr_token.tk_name, curr_token.tk_valstring);
break;
case CANCEL:
fprintf(stderr, "Cancel; name = '%s'\n",
curr_token.tk_name);
break;
case NAMES:
fprintf(stderr, "Names; value = '%s'\n",
curr_token.tk_name);
break;
case EOF:
fprintf(stderr, "End of file\n");
break;
default:
warning("Bad token type");
}
}
if (dot_flag == TRUE) /* if commented out, use the next one */
type = get_token();
return (type);
}
void get_current()
{
int c,lc,i=0;
raw();
noecho();
keypad(stdscr, TRUE);
while ((c=getch()))
{
if (c == '\t') // Tab
{
if (showing) tab_hits_down();
else {
clrtobot();
if (current_length > 1) {
hunt_current();
show_hits();
tab_hits_down();
}
}
}
else if (c == '\n' && lc == '\n') break; // two-returns to quit
else if (c == 27) { exiting=1;break;break; } // ESC quit
else if (c == 'J' || c == 258) // J | d-arrow down hit list
tab_hits_down();
else if (c == 'K' || c == 353 || c == 259) // K | <shift-TAB> | u-arrow up hit list
tab_hits_up();
else if (c == 32) // SPACE to reset search
{
memset(current,'\0',MAX_LINE);
current_length = 0;
clear_matches();
setup_screen();
mvprintw(LINES - 2, 0, "!: %s", items);
move(cursor_row,cursor_col+3);
refresh();
i=0;
}
else if (c == 127 || c == 8) // DELETE or BACKSPACE
{
if (current_length > 0 )
{
i--;
current_length--;
current[i] = '\0';
clrtobot();
mvprintw(LINES - 2, 0, "!: %s", items);
backspace();
move(cursor_row,cursor_col);
getsyx(cursor_row,cursor_col);
if (showing && current_length > 1) {
hunt_current();
show_hits();
tab_hits_down();
}
}
}
else if (c=='\n') // SELECT hightlighted hit or typed word
{
if (showing && sel_match>-1) strcat(items,tags[matches[sel_match].index]);
else strcat(items,current);
memset(current,'\0',MAX_LINE);
current_length=i=0;
setup_screen();
showing=FALSE;
strcat(items," ");
mvprintw(LINES - 2, 0, "!: %s", items);
move(cursor_row,cursor_col+3);
refresh();
}
else // regular key-typed
{
addch(c);
current[i]=c;
++i;
++current_length;
refresh();
getsyx(cursor_row,cursor_col);
if (showing && (current_length > 1)) {
noraw();
delch();
raw();
refresh();
hunt_current();
show_hits();
tab_hits_down();
}
else showing=FALSE;
}
lc = c;
if (diags) diag(c);
}
current[i] = '\0';
}
/*
* Filter an entire file, writing the result to the standard output.
*/
static void
ManFilter(FILE *ifp)
{
int c;
int level = 0;
int ident = CS_NORMAL;
int esc_mode = ATR_NORMAL;
while ((c = fgetc(ifp)) != EOF) {
switch (c) {
case '\b':
backspace();
break;
case '\r':
if (cur_line != 0)
cur_line->l_this = 0;
break;
case '\n':
next_line();
cur_line->l_this = 0;
break;
case '\t':
do {
put_cell(SPACE, level, ident);
} while (cur_line->l_this & 7);
break;
case '\v':
prev_line();
break;
case SHIFT_IN:
ident = CS_NORMAL;
break;
case SHIFT_OUT:
ident = CS_ALTERNATE;
break;
case ESCAPE:
switch (fgetc(ifp)) {
case '[':
esc_mode = ansi_escape(ifp, ident, level);
break;
case '\007':
case '7':
prev_line();
break;
case '\010':
case '8':
level = half_up(level);
break;
case '\011':
case '9':
level = half_down(level);
break;
default: /* ignore everything else */
break;
}
break;
default: /* ignore other nonprinting characters */
if (isprint(c)) {
put_cell(c, level, ident);
if (c != SPACE) {
if (esc_mode & ATR_BOLD) {
backspace();
put_cell(c, level, ident);
}
if (esc_mode & ATR_UNDER) {
backspace();
put_cell('_', level, ident);
}
}
}
break;
}
}
while (all_lines != 0)
flush_line();
total_lines = 0;
}
/* lineeditor():
* This is a simpler version of lineeditor() (as found in lineedit.c).
* It does not have the capability of the vi-like version; however, for
* those not familiar with ksh, this one is probably a lot more intuitive.
*
* The line is modified in place so, if successful, the function
* returns the same pointer but with its contents modified based
* on the editor commands executed.
* If failure, the function returns (char *)0.
*/
static char *
lineeditor(char *line_to_edit,int type)
{
int state;
if (type == EDITCMDLINE) {
if (getchar() != OPEN_BRACKET) {
putchar('\n');
*line_to_edit = 0;
return((char *)0);
}
}
startOfLine = line_to_edit;
curPos = line_to_edit;
while(*curPos != ESC)
curPos++;
*curPos = 0; /* Remove the escape character from the line */
lineLen = (ulong)curPos - (ulong)startOfLine;
if (lineLen > 0) {
curPos--;
putstr(" \b\b");
}
else
putstr(" \b");
state = GOT_BRACKET;
lastsize = 0;
shwidx = stridx;
srchidx = stridx;
while(1) {
curChar = getchar();
switch(curChar) {
case CTLC:
putchar('\n');
*line_to_edit = 0;
return((char *)0);
case VT100_UP:
if (state == GOT_BRACKET) {
if (type == EDITCMDLINE)
showprev();
state = GOT_NUTTIN;
}
else {
newchar(curChar);
}
break;
case VT100_DOWN:
if (state == GOT_BRACKET) {
if (type == EDITCMDLINE)
shownext();
state = GOT_NUTTIN;
}
else {
newchar(curChar);
}
break;
case VT100_RIGHT:
if (state == GOT_BRACKET) {
if (curPos < startOfLine+lineLen) {
putchar(*curPos);
curPos++;
}
state = GOT_NUTTIN;
}
else {
newchar(curChar);
}
break;
case VT100_LEFT:
if (state == GOT_BRACKET) {
if (curPos > startOfLine) {
putchar('\b');
curPos--;
}
state = GOT_NUTTIN;
}
else {
newchar(curChar);
}
break;
case OPEN_BRACKET:
if (state == GOT_ESCAPE) {
state = GOT_BRACKET;
}
else {
newchar(curChar);
}
break;
case ESC:
state = GOT_ESCAPE;
break;
case VT100_DEL:
if (curPos != (startOfLine + lineLen))
ldelete();
break;
case '\b':
if (curPos > startOfLine)
backspace();
break;
case '\n':
case '\r':
putchar('\n');
if (lineLen == 0)
return((char *)0);
*(char *)(startOfLine + lineLen) = '\0';
return(startOfLine);
default:
newchar(curChar);
break;
}
}
return((char *)0);
}
void eHealthDisplayClass::printAirFlowScreen(void)
{
int j = 0;
for (j=0; j<45; j++)
{
pixel(8, j, 0);
}
delay(10);
//Lung picture
if (millis()-timePreviousMeassure > 10000) {
countsPerMinute = 6*count;
timePreviousMeassure = millis();
//Apnea signal OFF
apneaAdvise(0);
coordinates(94, 52); backspace();
coordinates(99, 52); backspace();
coordinates(104, 52); backspace();
coordinates(109, 52); backspace();
coordinates(114, 52); backspace();
coordinates(119, 52); backspace();
coordinates(124, 52); backspace();
delay(10);
if(count ==0 ){
//Apnea sinal ON
apneaAdvise(1);
coordinates(94, 52);
writeLCD("Apnea");
delay(5);
}
count = 0;
//Clear the space
coordinates(53, 52); backspace();
coordinates(50, 52); backspace();
coordinates(45, 52); backspace();
coordinates(40, 52); backspace();
writeLcdDec(countsPerMinute);
delay(20);
}
//Lung ON
printLung(1);
// Input 1
valRead = analogRead(1);
valRead = map(valRead, 0, 1023, 5, 45);
delay(100);
pixel (x, valRead, 1);
if(x>8){
line(x-1, prevRead, x, valRead, 1);
}
if(valRead> 7) waveState=1;
if(waveState==1)
{
if(valRead<6)
{
//Lung OFF
printLung(0);
count=count+1;
waveState=0;
delay(100);
}
}
//Wave refresh
for (j = 5; j < 40 ; j++)
{
pixel(x+1,j,0);
}
prevRead = valRead;
x++;
if (x == 120) x = 8;
}
/*struct txtfld
{
int x;
int y;
int r;
char *feild_name;
};
struct txtfld t1;*/
void draw_txtbox(int leftx,int lefty,int rightx,char *fname)
{
int pos=0,insflg=0,tempflg=0;
int i=-1,row,j=0,temp,col,maxsize;
char c[1];
ch[0]=(char*)calloc(sizeof(char),20);
row=lefty+7;
col=leftx+5;
maxsize=(rightx-leftx)/8 - 2;
settextstyle(0,0,1);
setcolor(15);
// outtextxy(leftx,lefty-10,fname);
showbox(leftx,lefty,rightx,fname);
do
{
i=i+1;
cursor(ch[j],col,row,pos);
ch[j][i]=temp=bioskey(0);
// printf("%c",ch[j][i]);
ch[j][i+1]='\0';
if(temp == HOME||temp == END||temp ==LEFT||temp ==RIGHT||temp ==DEL||temp ==INSERT)
{
specialkey(ch[j],col,row,temp,&pos,&i,&insflg);
continue;
}
if(ch[j][i]=='\x1B' || ch[j][i]=='\x0D') //escape
{
ch[j][i]='\0';
// hidebox(leftx,lefty,rightx);
// hidebox(leftx,lefty,rightx,fname);
break;
}
if(ch[j][i]!='\t' && ch[j][i]!='\x1B' && ch[j][i]!='\b')
{
if(i==maxsize)
{
ch[j][i]='\0';
i=i-1;
continue;
}
keycheck(ch[j],&i,5,&tempflg);
if(tempflg==1)
{
tempflg=0;
continue;
}
}
if(ch[j][i]=='.') //.(full stop)
{
ch[j][i]='.';
}
setcolor(15);
outtextxy((strlen(ch[j])-1)*8+col,row+2,"_");
setcolor(0);
if(ch[j][i]=='\b') //backspace
{
backspace(ch[j],&i,pos,row,col);
continue;
}
if(insflg%2==1)
{
insert(ch[j],&i,pos,row,col);
continue;
}
// if(ch[j][i]!='\b')
// {
if(pos>0)
{
setfillstyle(1,15);
bar(strlen(ch[j])*8+col-pos*8-8,row,strlen(ch[j])*8+col-pos*8-1,row+7);
ch[j][i-pos]=ch[j][i];
ch[j][i]='\x0';
sprintf(c,"%c",ch[j][i-pos]);
setcolor(0);
outtextxy(strlen(ch[j])*8+col-pos*8,row,c);
pos=pos-1;
i=i-1;
}
else
{
sprintf(c,"%c",ch[j][i]);
setcolor(0);
outtextxy(strlen(ch[j])*8+col-8-pos*8,row,c);
}
// }
}while(ch[j][i]!='\x1B' || ch[j][i]!='\x0D');
}
int main(int argc, char *argv[], char *envp[])
{
read_config(); //read the config file
char c; //reading one letter at time here
//building a command line which will eventually get parsed
line = (char *)malloc(sizeof(char) * 100);
memset(line,0,100);
char *cmd = (char *)malloc(sizeof(char) * 100); //the program (command w/o args)
char *printBuff = (char *)malloc(sizeof(char)*100); //a printing buffer (for use with raw tty)
//holder for history if stuff is typed, then history is used to go back to typed stuff
char *historyHold = (char *)malloc(sizeof(char)*100);
path = (char*)malloc(sizeof(char)*100);
fullPath = (char*)malloc(sizeof(char)*100);
memset(printBuff,0,100);
memset(historyHold,0,100);
memset(cmd,0,100);
signal(SIGINT, handle_sig); //register interrupt signal (for CTRL+C)
int promptLen; //making sure we dont backspace the prompt
int fromHistory = 0; //a type of check to see if our line is from history (not user typed)
if(fork() == 0) {
execve("/usr/bin/clear", argv, envp); //simply clear the screen
exit(1);
}
else {
wait(NULL); //wait to clear screen
}
get_path(); //gets the 2dir path for prompt
tty_raw_mode();//set terminal into raw mode
sprintf(printBuff,"%s:%s",path,PROMPT); //build print buff
promptLen = strlen(printBuff);
curPos = promptLen; //leave a space
write(1,printBuff,promptLen); //print initial prompt
memset(printBuff,0,100); //clear printBuff
clear_args(); //just get any initial crap out
/* MAIN LOOP */
while(1) {
read(0,&c,1); //read 1 character from stdin
if(((c >= 32) && c!=127) || c == 10) {
//here, we only want to process characters that are
//"readable" (or enter). special characters will be
//handled differently
tabPressNo = 0; //they didnt press tab
write(1,&c,1); //write char (echo is off for raw mode)
++curPos;
switch(c) {
case '\n': //end of the line (enter was pressed after input)
if(line[0] == '\0') {
//they didnt type anything
sprintf(printBuff,"%s:%s",path,PROMPT);
write(1,printBuff,promptLen);
}
else if(strcmp(line,"exit")==0) {
printf("\n"); //for niceness
quit_raw_mode(); //play nice and restore term state
return 0; //quit if they type "exit"
}
else { //prepare to actually process
strncat(line,"\0",1);
if(line[0] != '!') {
add_history(line); //add command to history
}
int pipe = 0;
int separ = check_separ(line);
if(!separ){
pipe = check_pipe(line);
}
if(!separ && !pipe){ //try to execute the command if there werent pipes or semicolons
parse_args(line); //build array of arguments
strcpy(cmd, args[0]); //cmd = program to run
execute(cmd);
clear_args(); //resets all arg array strings
}
c = '\0';
memset(cmd, 0, 100); //clear the cmd array
//reprint prompt
sprintf(printBuff,"%s:%s",path,PROMPT);
promptLen = strlen(printBuff);
curPos = promptLen;
write(1,printBuff,promptLen);
}
memset(line,0,100); //clear line array
memset(historyHold,0,100);//clear history hold
break;
default: strncat(line, &c, 1);//build the line
break;
}
}
else if(c == 8) {
//backspace pressed
if(curPos > promptLen) {
backspace(); //backspace until we reach prompt
line[strlen(line)-1] = 0; //thank god this finally works
--curPos;
}
}
else if(c == 27) {
//the user pressed some sort of
//escape sequence
char c1;
char c2;
read(0,&c1,1);
read(0,&c2,1);
//ok, we have the two parts of the
//escape sequence in c1 and c2
if(c1 == 91 && c2 == 65) {
//this is the escape for the up arrow
//which we want to use for history
//browsing
char *tmpLine;
tmpLine = prev_history();
if(tmpLine != 0) {
if(line[0] != '\0' && fromHistory==0) {
//store what user currently has typed (if anything)
memset(historyHold,0,100);
strncpy(historyHold,line,strlen(line));
}
clear_line(strlen(line)); //clears whatever is at the prompt
memset(line,0,100);
strncpy(line,tmpLine,strlen(tmpLine)); //copy this command
free(tmpLine); //play nice
write(1,line,strlen(line)); //write old command
fromHistory = 1; //current line has been replaced by history
curPos = strlen(line) + promptLen; //so we know where are
}
}
else if(c1 == 91 && c2 == 66) {
//this is the escape for the down arrow
//which should make us go "forward"
//in history (if we are back in it)
char *tmpLine;
tmpLine = next_history(); //get the next history
if(tmpLine != 0) {
//next_history gave us a line
clear_line(strlen(line)); //clear old line from screen
memset(line,0,100); //clear old line in mem
strncpy(line,tmpLine,strlen(tmpLine)); //copy new line to old line
write(1,line,strlen(line)); //write new line to screen
curPos = strlen(line) + promptLen; //update pos
free(tmpLine);
}
else if(historyHold[0] != '\0') {
//if we dont have a next_line, lets see if
//we had some buffer before browsing history
clear_line(strlen(line));
memset(line,0,100);
strncpy(line,historyHold,strlen(historyHold));
write(1,line,strlen(line));
curPos = strlen(line) +promptLen;
fromHistory = 0; //back to user typed
}
else {
//it was blank before history was browsed
clear_line(strlen(line));
memset(line,0,100);
curPos = promptLen;
}
}
}
else if(c == '\t') {
//tab press. should i dare try to do tab
//completion? i guess...
//if this is the 2nd time in a row pressing tab
//they want a listing of everything that can be
//completed
if(tabPressNo) {
//print everything in tabHold
tabPressNo = 0;
if(tabCompHold[0] != NULL) {
int i = 1;
char *x = tabCompHold[0];
char *tmp = (char*)malloc(sizeof(char)*100);
memset(tmp,0,100);
write(1,"\n",1);
while(x != NULL) {
sprintf(tmp,"%s\t",x);
write(1,tmp,strlen(tmp));
memset(tmp,0,100);
x = tabCompHold[i];
++i;
}
write(1,"\n",1);
//reprint prompt
sprintf(printBuff,"%s:%s",path,PROMPT);
promptLen = strlen(printBuff);
curPos = promptLen + strlen(line);
write(1,printBuff,promptLen);
//write the line again
write(1,line,strlen(line));
clear_tab_hold();
}
} else {
//otherwise just let tab_complete
//print a single completion
char *tabcomp;
tabcomp = tab_complete(line);
if(tabcomp != NULL) {
//tab comp found a single thing, so
//lets just complete it
int i = 1;
char c = tabcomp[0];
while(c!='\0') {
write(1,&c,1);
strncat(line,&c,1);
c = tabcomp[i];
++i;
}
curPos += strlen(tabcomp); //set our new position
free(tabcomp);
}
++tabPressNo;
}
}
else if(c == '\177') {
//other form of backspace
if(curPos > promptLen) {
backspace(); //backspace until we reach prompt
line[strlen(line)-1] = 0; //thank god this finally works
--curPos;
}
}
memset(printBuff,0,100); //clear printing buffer
}
printf("\n"); //for niceness
quit_raw_mode(); //so we dont get stuck in it
return 0; //goodbye
}
void RtKeyboard::setupFuncKey(void)
{
QPoint FuncPoints[__FUN_NUMS__] = {
QPoint(91,97),QPoint(7,67),QPoint(210,67),QPoint(8,97),QPoint(196,97),
QPoint(58,97),QPoint(163,97)
};
// Func #0 -> Space Key
QString strSpace = " ";
QRect rectBtnText = QRect(0,0,0,0);
m_pFuncButton[__FUN_KEY_0__] = new RtKeyButton(this,__FUN_KEY_0__);
m_pFuncButton[__FUN_KEY_0__]->SetImages(&m_Key4[0],&m_Key4[0]);
m_pFuncButton[__FUN_KEY_0__]->setGeometry(FuncPoints[__FUN_KEY_0__].x(),FuncPoints[__FUN_KEY_0__].y(),m_Key4[0].width(),m_Key4[0].height());
m_pFuncButton[__FUN_KEY_0__]->setButtonText(strSpace,rectBtnText);
connect(m_pFuncButton[__FUN_KEY_0__], SIGNAL(clicked()), signalMapper, SLOT(map()));
signalMapper->setMapping(m_pFuncButton[__FUN_KEY_0__], strSpace);
// Func #1 -> Switch ABC to abc Key
m_pFuncButton[__FUN_KEY_1__] = new RtKeyButton(this,__FUN_KEY_1__);
m_pFuncButton[__FUN_KEY_1__]->SetImages(&m_Key_Switch[0],&m_Key_Switch[0]);
m_pFuncButton[__FUN_KEY_1__]->setGeometry(FuncPoints[__FUN_KEY_1__].x(),FuncPoints[__FUN_KEY_1__].y(),m_Key_Switch[0].width(),m_Key_Switch[0].height());
connect(m_pFuncButton[__FUN_KEY_1__], SIGNAL(clicked()), this, SLOT(switchUpperLower()));
// Func #2 -> Delete Key
m_pFuncButton[__FUN_KEY_2__] = new RtKeyButton(this,__FUN_KEY_2__);
m_pFuncButton[__FUN_KEY_2__]->SetImages(&m_Key_Del[0],&m_Key_Del[0]);
m_pFuncButton[__FUN_KEY_2__]->setGeometry(FuncPoints[__FUN_KEY_2__].x(),FuncPoints[__FUN_KEY_2__].y(),m_Key_Del[0].width(),m_Key_Del[0].height());
connect(m_pFuncButton[__FUN_KEY_2__], SIGNAL(clicked()), this, SIGNAL(backspace()));
// Func #3 -> Switch between ABC and 123 Key
QString strFun3 = "?123";
QRect rectFun3 = QRect(8,6,35,16);
m_pFuncButton[__FUN_KEY_3__] = new RtKeyButton(this,__FUN_KEY_3__);
m_pFuncButton[__FUN_KEY_3__]->SetImages(&m_Key7[0],&m_Key7[0]);
m_pFuncButton[__FUN_KEY_3__]->setGeometry(FuncPoints[__FUN_KEY_3__].x(),FuncPoints[__FUN_KEY_3__].y(),m_Key7[0].width(),m_Key7[0].height());
m_pFuncButton[__FUN_KEY_3__]->setButtonText(strFun3,rectFun3);
connect(m_pFuncButton[__FUN_KEY_3__], SIGNAL(clicked()), this, SLOT(switchAZ09()));
// Func #4 -> Enter Key
m_pFuncButton[__FUN_KEY_4__] = new RtKeyButton(this,__FUN_KEY_4__);
m_pFuncButton[__FUN_KEY_4__]->SetImages(&m_Key_Enter[0],&m_Key_Enter[0]);
m_pFuncButton[__FUN_KEY_4__]->setGeometry(FuncPoints[__FUN_KEY_4__].x(),FuncPoints[__FUN_KEY_4__].y(),m_Key_Enter[0].width(),m_Key_Enter[0].height());
// Func #5 -> "," Key
QString strFun5 = ",";
QRect rectFun5 = QRect(8,6,20,16);
m_pFuncButton[__FUN_KEY_5__] = new RtKeyButton(this,__FUN_KEY_5__);
m_pFuncButton[__FUN_KEY_5__]->SetImages(&m_Key3[0],&m_Key3[0]);
m_pFuncButton[__FUN_KEY_5__]->setGeometry(FuncPoints[__FUN_KEY_5__].x(),FuncPoints[__FUN_KEY_5__].y(),m_Key3[0].width(),m_Key3[0].height());
m_pFuncButton[__FUN_KEY_5__]->setButtonText(strFun5,rectFun5);
m_pFuncButton[__FUN_KEY_5__]->show();
connect(m_pFuncButton[__FUN_KEY_5__], SIGNAL(clicked()), signalMapper, SLOT(map()));
signalMapper->setMapping(m_pFuncButton[__FUN_KEY_5__], strFun5);
// Func #6 -> "." Key
QString strFun6 = ".";
QRect rectFun6 = QRect(8,6,20,16);
m_pFuncButton[__FUN_KEY_6__] = new RtKeyButton(this,__FUN_KEY_6__);
m_pFuncButton[__FUN_KEY_6__]->SetImages(&m_Key3[0],&m_Key3[0]);
m_pFuncButton[__FUN_KEY_6__]->setGeometry(FuncPoints[__FUN_KEY_6__].x(),FuncPoints[__FUN_KEY_6__].y(),m_Key3[0].width(),m_Key3[0].height());
m_pFuncButton[__FUN_KEY_6__]->setButtonText(strFun6,rectFun6);
connect(m_pFuncButton[__FUN_KEY_6__], SIGNAL(clicked()), signalMapper, SLOT(map()));
signalMapper->setMapping(m_pFuncButton[__FUN_KEY_6__], strFun6);
for(int i=0;i<__FUN_NUMS__;i++)
{
m_pFuncButton[i]->show();
connect(m_pFuncButton[i], SIGNAL(MousePress(int,int)), this, SLOT(MouseFuncPress(int,int)));
connect(m_pFuncButton[i], SIGNAL(MouseRelease()), this, SLOT(MouseRelease()));
// connect(m_pKeyButton[i], SIGNAL(ButtonClick(int)), this, SLOT(ButtonClick(int)));
}
}
KeyPad::KeyPad(LCDDisplay *lcd, QWidget *parent, const char *name )
: QGrid(5, parent, name)
{
int i;
QButton *btnButton;
// save lcd at init
display = lcd;
// Init variable
dCurrent = 0;
iLenCurrent = 1;
bIsDec = false;
dDecCurrent = 0;
iPreviousOperator = 0;
dPreviousValue = 0;
// First line
btnClear = new QPushButton("CE/C", this, "Clear");
btn7 = new QPushButton("7", this, "7");
btn8 = new QPushButton("8", this, "8");
btn9 = new QPushButton("9", this, "9");
btnPlus = new QPushButton("+", this, "+");
// 2nd line
btnBackspace = new QPushButton("<-",this, "Backspace");
btn4 = new QPushButton("4", this, "4");
btn5 = new QPushButton("5", this, "5");
btn6 = new QPushButton("6", this, "6");
btnMinus = new QPushButton("-", this, "-");
// 3rd line
btnPercent = new QPushButton("%", this, "percent");
btn1 = new QPushButton("1", this, "1");
btn2 = new QPushButton("2", this, "2");
btn3 = new QPushButton("3", this, "3");
btnMultiply = new QPushButton("X", this, "X");
// 4th line
btnAbout = new QPushButton("?", this, "About");
btn0 = new QPushButton("0", this, "0");
btnDot = new QPushButton(".", this, "dot");
btnEqual = new QPushButton("=", this, "equal");
btnDivide = new QPushButton("/", this, "divide");
// Digit key
grpbtnDigits = new QButtonGroup(0, "digits");
grpbtnDigits->insert(btn0, 0);
grpbtnDigits->insert(btn1, 1);
grpbtnDigits->insert(btn2, 2);
grpbtnDigits->insert(btn3, 3);
grpbtnDigits->insert(btn4, 4);
grpbtnDigits->insert(btn5, 5);
grpbtnDigits->insert(btn6, 6);
grpbtnDigits->insert(btn7, 7);
grpbtnDigits->insert(btn8, 8);
grpbtnDigits->insert(btn9, 9);
// set appearance of buttons
for(i=0; i<10; i++) {
btnButton = grpbtnDigits->find(i);
btnButton->setFixedSize(30,30);
}
// Operator key
grpbtnOperators = new QButtonGroup(0, "operator");
grpbtnOperators->insert(btnPlus, 1);
grpbtnOperators->insert(btnMinus,2);
grpbtnOperators->insert(btnMultiply,3);
grpbtnOperators->insert(btnDivide,4);
grpbtnOperators->insert(btnEqual,5);
// set appearance of buttons
for(i=1; i<6; i++) {
btnButton = grpbtnOperators->find(i);
btnButton->setFixedSize(30,30);
}
btnClear->setFixedSize(30,30);
btnClear->setPalette(QPalette( QColor(255, 99, 71) ) );
btnDot->setFixedSize(30,30);
btnPercent->setFixedSize(30,30);
btnBackspace->setFixedSize(30,30);
btnAbout->setFixedSize(30,30);
m_buttonKeys.insert(Key_0, btn0);
m_buttonKeys.insert(Key_1, btn1);
m_buttonKeys.insert(Key_2, btn2);
m_buttonKeys.insert(Key_3, btn3);
m_buttonKeys.insert(Key_4, btn4);
m_buttonKeys.insert(Key_5, btn5);
m_buttonKeys.insert(Key_6, btn6);
m_buttonKeys.insert(Key_7, btn7);
m_buttonKeys.insert(Key_8, btn8);
m_buttonKeys.insert(Key_9, btn9);
m_buttonKeys.insert(Key_Period, btnDot);
m_buttonKeys.insert(Key_Plus, btnPlus);
m_buttonKeys.insert(Key_Minus, btnMinus);
m_buttonKeys.insert(Key_Equal, btnEqual);
m_buttonKeys.insert(Key_Asterisk, btnMultiply);
m_buttonKeys.insert(Key_Slash, btnDivide);
m_buttonKeys.insert(Key_Percent, btnPercent);
m_buttonKeys.insert(Key_Backspace, btnBackspace);
// SIGNALS AND SLOTS
connect(grpbtnDigits, SIGNAL(clicked(int) ), this, SLOT(enterDigits(int)));
connect(grpbtnOperators, SIGNAL(clicked(int)), this, SLOT(operatorPressed(int)));
connect(btnClear, SIGNAL(clicked()), this, SLOT(clearLCD()));
connect(btnBackspace, SIGNAL(clicked()), this, SLOT(backspace()));
connect(btnAbout, SIGNAL(clicked()), this, SLOT(aboutDialog()));
connect(btnDot, SIGNAL(clicked()), this, SLOT(gotoDec()));
connect(display, SIGNAL(keyPressed(int)), SLOT(slotKeyPressed(int)));
connect(display, SIGNAL(keyReleased(int)), SLOT(slotKeyReleased(int)));
}
void iKeyboard(unsigned char key)
{
upArrow = 0;
downArrow=0; //set arrow flags off
//retrieve charactre index in terms of cursor position
j = x/ charSpace;
i = ((height-15-lineSpace - y)/lineSpace) + s;
if (glutGetModifiers() == GLUT_ACTIVE_CTRL) //ALT key operations
{
if (key == 1) //select all
{
selectAll();
}
else if (key == 3 ) //copy
{
copy();
}
else if (key==15) //file open
{
fOpen =1;
subTemp = (char *)calloc(60,sizeof(char));
x = (width-15)/2-135;
y = (height-19)/2+61;
menuflag = 0;
}
else if (key==16) //file save as
{
save();
char tempfile[80];
strcpy(tempfile, syspath);
strcat(tempfile, ":\\Program Files\\Rword\\saved_files\\");
strcat(tempfile, filename);
ShellExecute(NULL, "print", tempfile, NULL, NULL, NULL); //print document
menuflag = 0;
}
else if (key==19) //file save
{
save();
menuflag = 0;
}
else if (copyFlag && key==22) //paste
{
paste();
}
else if (key == 24 ) //cut
{
cut();
}
}
else if(key >31 && key <127) //character input
{
if (fOpen || fsave)
{
subCharacter(key); //for popups
}
else
{
if (selflag)
seldel();
character(key); // main character input
}
}
else if (key == '\b') //backspace
{
if (fOpen || fsave) //popup
{
if (strlen(subTemp))
{
subTemp[strlen(subTemp)-1] = '\0';
if (strlen(subTemp)>33)
r--;
else
x -= 8;
}
}
else
{
if (selflag)
seldel();
else
backspace(); //main
}
}
else if (key == 127) //del
{
if (selflag)
seldel();
else
del();
}
else if (key == '\r') //enter operations
{
if (fOpen)
{
if (selflag)
seldel();
open();
}
else if (fsave)
{
saveas(); //popups
}
else
{
if (selflag)
seldel();
else
enter(); //main
}
}
else if (key == '\t') //incomplete
{
selflag = 0;
tab();
}
}
bool TextField::handle(Event& e) {
static bool shiftDown = false;
KeyEvent* ke = dynamic_cast<KeyEvent*>(&e);
if (ke) {
if (ke->info.key == "KEY_SHIFT_L") {
shiftDown = ke->info.pressed;
}
if (ke->info.pressed) {
if (ke->info.key == "KEY_BACKSPACE") {
backspace(ke->info);
} else if (ke->info.key == "KEY_ARROW_LEFT") {
cursorMoveStrategy->moveCursor(this, CursorDirection::LEFT, ke->info);
} else if (ke->info.key == "KEY_ARROW_RIGHT") {
cursorMoveStrategy->moveCursor(this, CursorDirection::RIGHT, ke->info);
} else if (ke->info.key == "KEY_A" && ke->info.ctrl) {
marker = 0;
cursor = text.length();
markFor(COMPONENT_REQUIREMENT_PAINT);
} else {
char c = g_keyboard::charForKey(ke->info);
if (c != -1) {
std::stringstream s;
s << c;
insert(s.str());
}
}
}
return true;
}
FocusEvent* fe = dynamic_cast<FocusEvent*>(&e);
if (fe) {
if (fe->type == FOCUS_EVENT_GAINED) {
focused = true;
} else {
focused = false;
}
markFor(COMPONENT_REQUIREMENT_PAINT);
return true;
}
MouseEvent* me = dynamic_cast<MouseEvent*>(&e);
if (me) {
if (me->type == MOUSE_EVENT_ENTER) {
visualStatus = TextFieldVisualStatus::HOVERED;
markFor(COMPONENT_REQUIREMENT_PAINT);
Cursor::set("text");
} else if (me->type == MOUSE_EVENT_LEAVE) {
visualStatus = TextFieldVisualStatus::NORMAL;
markFor(COMPONENT_REQUIREMENT_PAINT);
Cursor::set("default");
} else if (me->type == MOUSE_EVENT_PRESS) {
g_point p = me->position;
int clickCursor = viewToPosition(p);
if (me->clickCount > 2) {
marker = 0;
cursor = text.length();
} else if (me->clickCount == 2) {
marker = cursorMoveStrategy->calculateSkip(text, clickCursor, CursorDirection::LEFT);
cursor = cursorMoveStrategy->calculateSkip(text, clickCursor, CursorDirection::RIGHT);
} else {
cursor = clickCursor;
if (!shiftDown) {
marker = cursor;
}
}
markFor(COMPONENT_REQUIREMENT_PAINT);
} else if (me->type == MOUSE_EVENT_DRAG) {
g_point p = me->position;
cursor = viewToPosition(p);
markFor(COMPONENT_REQUIREMENT_PAINT);
}
return true;
}
return false;
}
bool UILabel::keyPress(SDL_KeyboardEvent *e, char c) {
if(!c) return false;
if(!editable) {
switch(c) {
case SDLK_RETURN:
if(submit()) return true;
break;
}
return false;
}
// copy / paste clipboard
if(e->keysym.sym == SDLK_v || e->keysym.sym == SDLK_c) {
Uint8* keystate = SDL_GetKeyState(0);
if(keystate[SDLK_LCTRL]) {
if(e->keysym.sym == SDLK_c) {
if(!this->text.empty()) {
SDLApp::setClipboardText(this->text);
return true;
}
} else if(e->keysym.sym == SDLK_v) {
std::string text;
if(SDLApp::getClipboardText(text)) {
setText(this->text + text);
return true;
}
}
return false;
}
}
switch(c) {
#ifdef __APPLE__
case SDLK_DELETE:
#else
case SDLK_BACKSPACE:
#endif
backspace();
break;
case SDLK_TAB:
tab();
break;
case SDLK_RETURN:
submit();
break;
default:
text += c;
break;
}
text_changed = true;
return true;
}
bool read_input(input_state* inp, char* buf) {
char c = 0;
int len, cursor;
int i;
int hislen;
int hispos = 0;
cursor = inp->cursor;
len = strlen(buf);
while (true) {
if (!read(0, &c, 1)) {
inp->cursor = cursor;
return false;
}
switch(c) {
case '\n':
return true;
case '\b':
case DEL:
backspace(buf, &cursor, &len);
break;
case ESC: /* escape char */
if (!read(0, &c, 1)) {
inp->cursor = cursor;
return false;
}
if (c == '[') {
if (!read(0, &c, 1)) {
inp->cursor = cursor;
return false;
}
switch(c) {
case 'A': /* up */
hislen = history_travel(inp, buf, cursor, hispos, false);
if (hislen) {
++hispos;
cursor = len = hislen;
}
break;
case 'B': /* down */
hislen = history_travel(inp, buf, cursor, hispos, true);
if (hislen) {
--hispos;
cursor = len = hislen;
}
break;
case 'C': /* right */
if (cursor < len) {
++cursor;
fputs("\033[C", stdout);
fflush(stdout);
}
break;
case 'D': /* left */
if (cursor > 0) {
--cursor;
fputs("\033[D", stdout);
fflush(stdout);
}
break;
case '1': /* Ctrl-A */
break;
case '4': /* Ctrl-E */
break;
}
}
break;
default:
if (!isprint(c)) /* skip non-printables */
break;
/* leave room for null terminator */
if (len >= (BUFFER_MAX_LENGTH - 1))
break;
if (cursor == len) { /* EOL, append */
buf[cursor] = c;
} else { /* insert */
memmove(&buf[cursor + 1], &buf[cursor], len - cursor);
buf[cursor] = c;
/* write the changed rest of the line */
for (i = cursor; i <= len; ++i)
putc(buf[i], stdout);
for (; i > cursor; --i) /* move cursor back to original pos */
fputs("\033[D", stdout);
}
++cursor;
++len;
putc(c, stdout);
fflush(stdout);
break;
}
}
}
/* keyboard_handler()
An Interrupt Handler that is Called When
Key is Pressed on Keyboard
Input : i -- interrupt vector
Output : None
Side Effect : Handle keypress functions
Prints keys Pressed to Screen accordingly
Issue EOI(End Of Interrupt) to unmask keyboard interrupt
*/
void keyboard_handler(int i)
{
/* Grab Key Pressed*/
uint8_t keycode;
keycode = kbd_read_input();
/* Indicate a key has been pressed */
key_press = 1;
int32_t display_terminal= get_displayed_terminal();
/* Print Only Keys Pressed, NOT Key Release
* No Print for CTRL/SHIFT/Backspace/Caps
* Carries out Functionality Instead */
if(keycode <= KEY_RELEASE_VALUE){
/* Condition Key Press */
if (keycode == ALT)
alt_press += 1;
else if(keycode == L_SHIFT || keycode == R_SHIFT)
shift_press += 1;
else if (keycode == CTRL)
ctrl_press += 1;
else if (keycode == CAPS_LOCK)
caps_on = !caps_on;
/* CTRL-L Clear Screen */
else if(keycode == L && ctrl_press > 0)
reset_screen();
/* Backspace */
else if (keycode == BACKSPACE){
/* Don't backspace when reading and at start of buffer*/
if(read_on[display_terminal] == 0 || (index[display_terminal] != 0 && read_on[display_terminal] == 1))
backspace();
update_terminal_buf(BACK,keycode);
}
/* Return Press During Read */
else if (read_on[display_terminal] == 1 && keycode == RETURN){
printf("\n"); // New Line for Return Press
read_return[display_terminal] = 1;
update_terminal_buf(KEYS,keycode);
}
/* ALT-Function Press */
else if(alt_press > 0 && (keycode == F1 || keycode == F2 || keycode == F3)){
switch(keycode){
case F1:
change_terminal(TERMINAL_1);
break;
case F2:
change_terminal(TERMINAL_2);
break;
case F3:
change_terminal(TERMINAL_3);
default:
break;
}
}
/* Caps On */
else if (caps_on == 1){
caps_on_handler(keycode);
}
/* Shift Press */
else if (shift_press > 0){
printf("%c", shift_keys[keycode - 1]);
update_terminal_buf(SHIFT_KEYS, keycode);
}
/* Normal Press */
else{
printf("%c", keys[keycode - 1]);
update_terminal_buf(KEYS, keycode);
}
}
/* Condition Key Releases */
else if (keycode == (ALT + KEY_RELEASE_VALUE))
alt_press -= 1;
else if(keycode == (L_SHIFT + KEY_RELEASE_VALUE) || keycode == (R_SHIFT + KEY_RELEASE_VALUE))
shift_press -= 1;
else if (keycode == (CTRL + KEY_RELEASE_VALUE))
ctrl_press -= 1;
/* Key Press Serviced */
key_press = 0;
send_eoi(KEYBOARD_IRQ);
}
int
trans_string(char *ptr)
{
register int count = 0;
int number;
register int i;
register int ch;
while ((ch = next_char()) != ',' && ch != EOF && !first_column) {
if (ch == '^') {
ch = next_char();
if (ch == EOF)
err_abort("Premature EOF");
if (!isascii(ch) || ! isprint(ch)) {
warning("Illegal ^ character - '%c'", ch);
}
if (ch == '@')
*(ptr++) = 0200;
else
*(ptr++) = ch & 037;
} else if (ch == '\\') {
ch = next_char();
if (ch == EOF)
err_abort("Premature EOF");
if (ch >= '0' && ch <= '7') {
number = ch - '0';
for (i = 0; i < 2; i++) {
ch = next_char();
if (ch == EOF)
err_abort("Premature EOF");
if (ch < '0' || ch > '7') {
backspace();
break;
}
number = number * 8 + ch - '0';
}
if (number == 0)
number = 0200;
*(ptr++) = (char)number;
} else {
switch (ch) {
case 'E':
case 'e': *(ptr++) = '\033'; break;
case 'l':
case 'n': *(ptr++) = '\n'; break;
case 'r': *(ptr++) = '\r'; break;
case 'b': *(ptr++) = '\010'; break;
case 's': *(ptr++) = ' '; break;
case 'f': *(ptr++) = '\014'; break;
case 't': *(ptr++) = '\t'; break;
case '\\': *(ptr++) = '\\'; break;
case '^': *(ptr++) = '^'; break;
case ',': *(ptr++) = ','; break;
case ':': *(ptr++) = ':'; break;
default:
warning("Illegal character in \\ sequence - '%c'",
ch);
*(ptr++) = ch;
} /* endswitch (ch) */
} /* endelse (ch < '0' || ch > '7') */
} /* end else if (ch == '\\') */
else {
if (ch != '\n') *(ptr++) = ch;
}
count ++;
if (count > 1000)
warning("Very long string found. Missing comma?");
} /* end while */
if (ch == EOF)
warning("Premature EOF - missing comma?");
/* start of new description */
else if (first_column) {
backspace();
warning("Missing comma?");
/* pretend we did get a comma */
ch = ',';
}
*ptr = '\0';
if (count == 0)
return (NULL);
return (ch);
}
/**
* checks if the key is a valid command
* @return true if a command was completed and executed, false otherwise
*/
bool KateViReplaceMode::handleKeypress( const QKeyEvent *e )
{
// backspace should work even if the shift key is down
if (e->modifiers() != Qt::ControlModifier && e->key() == Qt::Key_Backspace ) {
backspace();
return true;
}
KTextEditor::Cursor c( m_view->cursorPosition() );
if ( e->modifiers() == Qt::NoModifier ) {
switch ( e->key() ) {
case Qt::Key_Escape:
m_overwritten.clear();
startNormalMode();
return true;
break;
case Qt::Key_Left:
m_overwritten.clear();
m_view->cursorLeft();
return true;
case Qt::Key_Right:
m_overwritten.clear();
m_view->cursorRight();
return true;
case Qt::Key_Up:
m_overwritten.clear();
m_view->up();
return true;
case Qt::Key_Down:
m_overwritten.clear();
m_view->down();
return true;
case Qt::Key_Home:
m_overwritten.clear();
m_view->home();
return true;
case Qt::Key_End:
m_overwritten.clear();
m_view->end();
return true;
case Qt::Key_PageUp:
m_overwritten.clear();
m_view->pageUp();
return true;
case Qt::Key_PageDown:
m_overwritten.clear();
m_view->pageDown();
return true;
case Qt::Key_Delete:
m_view->keyDelete();
return true;
case Qt::Key_Insert:
startInsertMode();
return true;
default:
return false;
break;
}
} else if ( e->modifiers() == Qt::ControlModifier ) {
switch( e->key() ) {
case Qt::Key_BracketLeft:
case Qt::Key_C:
startNormalMode();
return true;
break;
case Qt::Key_E:
commandInsertFromLine( 1 );
return true;
break;
case Qt::Key_Y:
commandInsertFromLine( -1 );
return true;
break;
case Qt::Key_Left:
m_overwritten.clear();
commandMoveOneWordLeft();
return true;
break;
case Qt::Key_Right:
m_overwritten.clear();
commandMoveOneWordRight();
return true;
break;
default:
return false;
}
}
return false;
}
static void TermCompletionOnAll(char *lineBeforeCaret, char *lineAfterCaret, char *defaultPattern, char **wk_buf, unsigned int *cursor,
unsigned int *cursor_max)
{
if (defaultPattern)
{
int numberWordFound = 0;
char **completionDictionaryFunctions = NULL;
int sizecompletionDictionaryFunctions = 0;
char **completionDictionaryCommandWords = NULL;
int sizecompletionDictionaryCommandWords = 0;
char **completionDictionaryMacros = NULL;
int sizecompletionDictionaryMacros = 0;
char **completionDictionaryVariables = NULL;
int sizecompletionDictionaryVariables = 0;
char **completionDictionaryHandleGraphicsProperties = NULL;
int sizecompletionDictionaryHandleGraphicsProperties = 0;
char **completionDictionaryFields = NULL;
int sizecompletionDictionaryFields = 0;
completionDictionaryFields = completionOnFields(lineBeforeCaret, defaultPattern, &sizecompletionDictionaryFields);
if (!completionDictionaryFields && strcmp(defaultPattern, ""))
{
completionDictionaryFunctions = completionOnFunctions(defaultPattern, &sizecompletionDictionaryFunctions);
completionDictionaryCommandWords = completionOnCommandWords(defaultPattern, &sizecompletionDictionaryCommandWords);
completionDictionaryMacros = completionOnMacros(defaultPattern, &sizecompletionDictionaryMacros);
completionDictionaryVariables = completionOnVariablesWithoutMacros(defaultPattern, &sizecompletionDictionaryVariables);
completionDictionaryHandleGraphicsProperties =
completionOnHandleGraphicsProperties(defaultPattern, &sizecompletionDictionaryHandleGraphicsProperties);
}
numberWordFound = sizecompletionDictionaryFunctions + sizecompletionDictionaryCommandWords +
sizecompletionDictionaryMacros + sizecompletionDictionaryVariables +
sizecompletionDictionaryHandleGraphicsProperties + sizecompletionDictionaryFields;
if (numberWordFound > 0)
{
if (numberWordFound == 1)
{
char **completionDictionary = NULL;
char *new_line = NULL;
if (completionDictionaryFields)
{
completionDictionary = completionDictionaryFields;
}
if (completionDictionaryFunctions)
{
completionDictionary = completionDictionaryFunctions;
}
if (completionDictionaryCommandWords)
{
completionDictionary = completionDictionaryCommandWords;
}
if (completionDictionaryMacros)
{
completionDictionary = completionDictionaryMacros;
}
if (completionDictionaryVariables)
{
completionDictionary = completionDictionaryVariables;
}
if (completionDictionaryHandleGraphicsProperties)
{
completionDictionary = completionDictionaryHandleGraphicsProperties;
}
new_line = completeLine(lineBeforeCaret, completionDictionary[0], NULL, defaultPattern, FALSE, lineAfterCaret);
if (new_line)
{
char buflinetmp[WK_BUF_SIZE + 1];
strcpy(buflinetmp, new_line);
FREE(new_line);
backspace(*cursor);
erase_nchar(*cursor_max);
*cursor = *cursor_max = 0;
CopyLineAtPrompt(wk_buf, buflinetmp, cursor, cursor_max);
}
freeArrayOfString(completionDictionary, 1);
}
else
{
char *commonAll = NULL;
if (completionDictionaryFields)
{
commonAll = getCommonPart(completionDictionaryFields, sizecompletionDictionaryFields);
displayCompletionDictionary(completionDictionaryFields, sizecompletionDictionaryFields, (char *)_("Scilab Fields"));
freeArrayOfString(completionDictionaryFields, sizecompletionDictionaryFields);
}
else
{
char *commonFunctions = getCommonPart(completionDictionaryFunctions, sizecompletionDictionaryFunctions);
char *commonCommandWords = getCommonPart(completionDictionaryCommandWords, sizecompletionDictionaryCommandWords);
char *commonMacros = getCommonPart(completionDictionaryMacros, sizecompletionDictionaryMacros);
char *commonVariables = getCommonPart(completionDictionaryVariables, sizecompletionDictionaryVariables);
char *commonHandleGraphicsProperties =
getCommonPart(completionDictionaryHandleGraphicsProperties, sizecompletionDictionaryHandleGraphicsProperties);
int sizecommonsDictionary = 0;
char **commonsDictionary = concatenateStrings(&sizecommonsDictionary, commonFunctions,
commonMacros, commonCommandWords, commonVariables, commonHandleGraphicsProperties);
if (sizecommonsDictionary > 0)
{
if (sizecommonsDictionary == 1)
{
commonAll = strdup(commonsDictionary[0]);
}
else
{
commonAll = getCommonPart(commonsDictionary, sizecommonsDictionary);
}
freeArrayOfString(commonsDictionary, sizecommonsDictionary);
}
displayCompletionDictionary(completionDictionaryFunctions, sizecompletionDictionaryFunctions, (char *)_("Scilab Function"));
displayCompletionDictionary(completionDictionaryCommandWords, sizecompletionDictionaryCommandWords, (char *)_("Scilab Command"));
displayCompletionDictionary(completionDictionaryMacros, sizecompletionDictionaryMacros, (char *)_("Scilab Macro"));
displayCompletionDictionary(completionDictionaryVariables, sizecompletionDictionaryVariables, (char *)_("Scilab Variable"));
displayCompletionDictionary(completionDictionaryHandleGraphicsProperties, sizecompletionDictionaryHandleGraphicsProperties,
(char *)_("Graphics handle field"));
freeArrayOfString(completionDictionaryFunctions, sizecompletionDictionaryFunctions);
freeArrayOfString(completionDictionaryCommandWords, sizecompletionDictionaryCommandWords);
freeArrayOfString(completionDictionaryMacros, sizecompletionDictionaryMacros);
freeArrayOfString(completionDictionaryVariables, sizecompletionDictionaryVariables);
freeArrayOfString(completionDictionaryHandleGraphicsProperties, sizecompletionDictionaryHandleGraphicsProperties);
}
printf("\n");
backspace(*cursor);
erase_nchar(*cursor_max);
*cursor = *cursor_max = 0;
printPrompt(WRITE_PROMPT);
if (commonAll)
{
char *new_line = NULL;
new_line = completeLine(lineBeforeCaret, commonAll, NULL, defaultPattern, FALSE, lineAfterCaret);
if (new_line)
{
char buflinetmp[WK_BUF_SIZE + 1];
strcpy(buflinetmp, new_line);
FREE(new_line);
CopyLineAtPrompt(wk_buf, buflinetmp, cursor, cursor_max);
}
FREE(commonAll);
commonAll = NULL;
}
}
}
}
}
void check_char(char* feed)
{
int i;
char* output;
switch (feed[0])
{
case 1:
// my_str("Ctrl+A pressed.\n");
ctrlA();
break;
case 3:
// my_str("Ctrl+C pressed.\n");
ctrlC();
break;
case 5:
// my_str("Ctrl+E pressed.\n");
ctrlE();
break;
case 11:
// my_str("Ctrl+K pressed.\n");
ctrlK();
break;
case 12:
// my_str("Ctrl+L pressed.\n");
ctrlL();
break;
case 25:
// my_str("Ctrl+Y pressed.\n");
ctrlY();
break;
case 27:
switch (feed[2])
{
case 'B':
// my_str("Down arrow pressed.\n");
down();
break;
case 'A':
// my_str("Up arrow pressed.\n");
up();
break;
case 'D':
// my_str("Left arrow pressed.\n");
left();
break;
case 'C':
// my_str("Right arrow pressed.\n");
right();
break;
} break;
case 8:
// my_str("Backspace pressed.\n");
backspace();
break;
case 10:
// my_str("Enter pressed.\n");
enter();
break;
case 127:
// my_str("Delete pressed.\n");
backspace();
break;
default:
my_char(feed[0]);
gl_env.cmd[gl_env.cmdlength++] = feed[0];
gl_env.x++;
break;
}
}
int main(int argc, char *argv[])
{
int c,x,y;
FILE *fp;
// If file name is not given close the program
if(argc!=2)
{
printf("file name missing \n");
exit(1);
}
// Start curses mode
if (initscr() == NULL)
{
fprintf(stderr, "Could not initialize screen\n");
exit(EXIT_FAILURE);
}
keypad(stdscr, TRUE); // raw mode ON
noecho(); // echo mode OFF
cbreak(); //Line buffering disabled, every character enabled
scrollok(stdscr, TRUE); // scrolling mode ON
refresh();
fp=fopen(argv[1],"r+");
if(!fp)//if the file does not exist, create it
{
fp=fopen(argv[1],"w+");
if(fp==NULL)
{
printw("Error opening file");
refresh();
exit(1);
endwin();
}
}
else
{
long map;
long end;
read_file(fp);
/*map and end coincides when we read the file*/
map=ftell(fp);
end=ftell(fp);
while((c=getch())!= KEY_ESC)
{
switch(c)
{
case KEY_F(1): //undo insert tab
break;
case KEY_F(2):
break;
case KEY_F(3):
break;
case KEY_F(4):
break;
case KEY_F(5):
break;
case KEY_F(6):
break;
case KEY_F(7):
break;
case KEY_F(8):
break;
case KEY_F(9):
break;
case KEY_F(10):
break;
case KEY_EOS:
fp=fopen(argv[1],"w+");
read_file(fp);
break;
case KEY_HOME://It will bring to the beginning of the file
nocbreak();
noecho();
getyx(stdscr,y,x);
move(y,0);
cbreak();
refresh();
fseek(fp,0,SEEK_SET);
break;
case KEY_UP:
nocbreak();
noecho();
getyx(stdscr,y,x);
move(y-1,x);
cbreak();
refresh();
break;
case KEY_PPAGE:
break;
case KEY_IC:
overtype_mode=true;
break;
case KEY_EIC:
overtype_mode=false;
map=0;
break;
case KEY_LEFT:
refresh();
nocbreak();
noecho();
getyx(stdscr,y,x);
move(y,x-1);
cbreak();
refresh();
fseek(fp,-1,SEEK_CUR);
map=ftell(fp);
break;
case KEY_RIGHT:
nocbreak();
noecho();
getyx(stdscr,y,x);
move(y,x+1);
cbreak();
refresh();
fseek(fp,+1,SEEK_CUR);
map=ftell(fp);
break;
case KEY_DOWN:
nocbreak();
noecho();
getyx(stdscr,y,x);
move(y+1,x);
cbreak();
refresh();
break;
case KEY_NPAGE:
getbegyx(stdscr,y,x);
move(y+1,x);
erase();
refresh();
read_file(fp);
erase();
printw("wordcount: %d \t",ftell(fp));
refresh();
break;
case KEY_BACKSPACE: //backspace function implemented instead
fseek(fp,0,SEEK_CUR);
map=ftell(fp);
fseek(fp,0,SEEK_END);
end=ftell(fp);
backspace(fp,argv[1],map,end);
fseek(fp,map-1,SEEK_SET);
break;
default: // write to the file
fseek(fp,0,SEEK_CUR);
map=ftell(fp);
fseek(fp,0,SEEK_END);
end=ftell(fp);
write_file(fp,overtype_mode,c,map,end);
}
}
refresh();
fclose(fp);
fp=NULL;
endwin();
}
return 0;
}
static void
my_homegrown_redisplay(int hide_passwords)
{
static int line_start = 0; /* at which position of prompt_plus_line does the printed line start? */
static int line_extends_right = 0;
static int line_extends_left = 0;
static char *previous_line = NULL;
int width = winsize.ws_col;
int skip = max(1, min(width / 5, 10)); /* jumpscroll this many positions when cursor reaches edge of terminal */
char *prompt_without_ignore_markers;
int colourless_promptlen = colourless_strlen(rl_prompt, &prompt_without_ignore_markers);
int promptlen = strlen(prompt_without_ignore_markers);
int invisible_chars_in_prompt = promptlen - colourless_promptlen;
char *prompt_plus_line = add2strings(prompt_without_ignore_markers, rl_line_buffer);
char *new_line;
int total_length = strlen(prompt_plus_line);
int curpos = promptlen + rl_point; /* cursor position within prompt_plus_line */
int i, printed_length,
new_curpos, /* cursor position on screen */
keep_old_line, vlinestart, printwidth, last_column;
DPRINTF3(DEBUG_AD_HOC,"rl_prompt: <%s>, prompt_without_ignore_markers: <%s>, prompt_plus_line: <%s>", rl_prompt, prompt_without_ignore_markers, prompt_plus_line);
/* In order to handle prompt with colour we either print the whole prompt, or start past it:
starting in the middle is too difficult (i.e. I am too lazy) to get it right.
We use a "virtual line start" vlinestart, which is the number of invisible chars in prompt in the former case, or
linestart in the latter (which then must be >= strlen(prompt))
At all times (before redisplay and after) the following is true:
- the cursor is at column (curpos - vlinestart) (may be < 0 or > width)
- the character under the cursor is prompt_plus_line[curpos]
- the character at column 0 is prompt_plus_line[linestart]
- the last column is at <number of printed visible or invisible chars> - vlinestart
the goal of this function is to display (part of) prompt_plus_line such
that the cursor is visible again */
if (hide_passwords)
for (i = promptlen; i < total_length; i++)
prompt_plus_line[i] = '*'; /* hide a pasword by making user input unreadable */
if (rl_point == 0) /* (re)set at program start and after accept_line (where rl_point is zeroed) */
line_start = 0;
assert(line_start == 0 || line_start >= promptlen); /* the line *never* starts in the middle of the prompt (too complicated to handle)*/
vlinestart = (line_start > promptlen ? line_start : invisible_chars_in_prompt);
if (curpos - vlinestart > width - line_extends_right) /* cursor falls off right edge ? */
vlinestart = (curpos - width + line_extends_right) + skip; /* jumpscroll left */
else if (curpos < vlinestart + line_extends_left) { /* cursor falls off left edge ? */
if (curpos == total_length) /* .. but still at end of line? */
vlinestart = max(0, total_length - width); /* .. try to display entire line */
else /* in not at end of line .. */
vlinestart = curpos - line_extends_left - skip; /* ... jumpscroll right .. */
}
if (vlinestart <= invisible_chars_in_prompt) {
line_start = 0; /* ... but not past start of line! */
vlinestart = invisible_chars_in_prompt;
} else if (vlinestart > invisible_chars_in_prompt && vlinestart <= promptlen) {
line_start = vlinestart = promptlen;
} else {
line_start = vlinestart;
}
printwidth = (line_start > 0 ? width : width + invisible_chars_in_prompt);
printed_length = min(printwidth, total_length - line_start); /* never print more than width */
last_column = printed_length - vlinestart;
/* some invariants : 0 <= line_start <= curpos <= line_start + printed_length <= total_length */
/* these are interesting: ^ ^ */
assert(0 <= line_start);
assert(line_start <= curpos);
assert(curpos <= line_start + printed_length); /* <=, rather than <, as cursor may be past eol */
assert(line_start + printed_length <= total_length);
new_line = prompt_plus_line + line_start;
new_line[printed_length] = '\0';
new_curpos = curpos - vlinestart;
/* indicate whether line extends past right or left edge (i.e. whether the "interesting
inequalities marked ^ above are really unequal) */
line_extends_left = (line_start > 0 ? 1 : 0);
line_extends_right = (total_length - vlinestart > width ? 1 : 0);
if (line_extends_left)
new_line[0] = '<';
if (line_extends_right)
new_line[printwidth - 1] = '>';
DPRINTF0(DEBUG_AD_HOC, "In the middle...");
keep_old_line = FALSE;
if (term_cursor_hpos) {
if (previous_line && strcmp(new_line, previous_line) == 0) {
keep_old_line = TRUE;
} else {
if (previous_line)
free(previous_line);
previous_line = mysavestring(new_line);
}
}
if (!keep_old_line) {
clear_line();
cr();
write_patiently(STDOUT_FILENO, new_line, printed_length, "to stdout");
}
assert(term_cursor_hpos || !keep_old_line); /* if we cannot position cursor, we must have reprinted ... */
if (term_cursor_hpos)
cursor_hpos(new_curpos);
else /* ... so we know we're 1 past last position on line */
backspace(last_column - new_curpos);
free(prompt_plus_line);
free(prompt_without_ignore_markers);
}
static size_t console_write(struct file *f, const char *buf, size_t count)
{
struct console_file *console_file = (struct console_file *)f;
console_lock();
console_retrieve_state();
#define OUTPUT() \
if (last != -1) \
{ \
write_normal(buf + last, i - last); \
last = -1; \
}
size_t last = -1;
size_t i;
for (i = 0; i < count; i++)
{
char ch = buf[i];
if (ch == 0x1B) /* Escape */
{
OUTPUT();
console->processor = control_escape;
}
else if (ch == '\t')
{
OUTPUT();
int x = (console->x + 8) & ~7;
if (x < console->width)
set_pos(x, console->y);
else
set_pos(console->width - 1, console->y);
}
else if (ch == '\b')
{
OUTPUT();
backspace(FALSE);
}
else if (ch == '\r')
{
OUTPUT();
if (console->termios.c_oflag & OCRNL)
nl();
else
cr();
}
else if (ch == '\n' || ch == '\v' || ch == '\f')
{
OUTPUT();
if (console->termios.c_oflag & ONLCR)
crnl();
else
nl();
}
else if (ch == 0x0E || ch == 0x0F)
{
/* Shift In and Shift Out */
OUTPUT();
}
else if (console->processor)
console->processor(ch);
else if (ch < 0x20)
{
OUTPUT();
log_error("Unhandled control character '\\x%x'\n", ch);
}
else if (last == -1)
last = i;
}
OUTPUT();
/* This will make the caret immediately visible */
set_pos(console->x, console->y);
console_unlock();
#if 0
char str[4096];
memcpy(str, buf, count);
str[count] = '\n';
str[count + 1] = 0;
log_debug(str);
#endif
return count;
}
void KLineEdit::keyPressEvent( QKeyEvent *e )
{
KKey key( e );
if ( KStdAccel::copy().contains( key ) )
{
copy();
return;
}
else if ( KStdAccel::paste().contains( key ) )
{
paste();
return;
}
else if ( KStdAccel::pasteSelection().contains( key ) )
{
QString text = QApplication::clipboard()->text( QClipboard::Selection);
insert( text );
deselect();
return;
}
else if ( KStdAccel::cut().contains( key ) )
{
cut();
return;
}
else if ( KStdAccel::undo().contains( key ) )
{
undo();
return;
}
else if ( KStdAccel::redo().contains( key ) )
{
redo();
return;
}
else if ( KStdAccel::deleteWordBack().contains( key ) )
{
cursorWordBackward(true);
if ( hasSelectedText() )
del();
e->accept();
return;
}
else if ( KStdAccel::deleteWordForward().contains( key ) )
{
// Workaround for QT bug where
cursorWordForward(true);
if ( hasSelectedText() )
del();
e->accept();
return;
}
else if ( KStdAccel::backwardWord().contains( key ) )
{
cursorWordBackward(false);
e->accept();
return;
}
else if ( KStdAccel::forwardWord().contains( key ) )
{
cursorWordForward(false);
e->accept();
return;
}
else if ( KStdAccel::beginningOfLine().contains( key ) )
{
home(false);
e->accept();
return;
}
else if ( KStdAccel::endOfLine().contains( key ) )
{
end(false);
e->accept();
return;
}
// Filter key-events if EchoMode is normal and
// completion mode is not set to CompletionNone
if ( echoMode() == QLineEdit::Normal &&
completionMode() != KGlobalSettings::CompletionNone )
{
KeyBindingMap keys = getKeyBindings();
KGlobalSettings::Completion mode = completionMode();
bool noModifier = (e->state() == NoButton ||
e->state() == ShiftButton ||
e->state() == Keypad);
if ( (mode == KGlobalSettings::CompletionAuto ||
mode == KGlobalSettings::CompletionPopupAuto ||
mode == KGlobalSettings::CompletionMan) && noModifier )
{
if ( !d->userSelection && hasSelectedText() &&
( e->key() == Key_Right || e->key() == Key_Left ) &&
e->state()==NoButton )
{
QString old_txt = text();
d->disableRestoreSelection = true;
int start,end;
getSelection(&start, &end);
deselect();
QLineEdit::keyPressEvent ( e );
int cPosition=cursorPosition();
if (e->key() ==Key_Right && cPosition > start )
validateAndSet(old_txt, cPosition, cPosition, old_txt.length());
else
validateAndSet(old_txt, cPosition, start, old_txt.length());
d->disableRestoreSelection = false;
return;
}
if ( e->key() == Key_Escape )
{
if (hasSelectedText() && !d->userSelection )
{
del();
setUserSelection(true);
}
// Don't swallow the Escape press event for the case
// of dialogs, which have Escape associated to Cancel
e->ignore();
return;
}
}
if ( (mode == KGlobalSettings::CompletionAuto ||
mode == KGlobalSettings::CompletionMan) && noModifier )
{
QString keycode = e->text();
if ( !keycode.isEmpty() && (keycode.unicode()->isPrint() ||
e->key() == Key_Backspace || e->key() == Key_Delete ) )
{
bool hasUserSelection=d->userSelection;
bool hadSelection=hasSelectedText();
bool cursorNotAtEnd=false;
int start,end;
getSelection(&start, &end);
int cPos = cursorPosition();
// When moving the cursor, we want to keep the autocompletion as an
// autocompletion, so we want to process events at the cursor position
// as if there was no selection. After processing the key event, we
// can set the new autocompletion again.
if ( hadSelection && !hasUserSelection && start>cPos )
{
del();
setCursorPosition(cPos);
cursorNotAtEnd=true;
}
d->disableRestoreSelection = true;
QLineEdit::keyPressEvent ( e );
d->disableRestoreSelection = false;
QString txt = text();
int len = txt.length();
if ( !hasSelectedText() && len /*&& cursorPosition() == len */)
{
if ( e->key() == Key_Backspace )
{
if ( hadSelection && !hasUserSelection && !cursorNotAtEnd )
{
backspace();
txt = text();
len = txt.length();
}
if ( !d->backspacePerformsCompletion || !len )
d->autoSuggest = false;
}
if (e->key() == Key_Delete )
d->autoSuggest=false;
if ( emitSignals() )
emit completion( txt );
if ( handleSignals() )
makeCompletion( txt );
if( (e->key() == Key_Backspace || e->key() == Key_Delete) )
d->autoSuggest=true;
e->accept();
}
return;
}
}
else if (( mode == KGlobalSettings::CompletionPopup ||
mode == KGlobalSettings::CompletionPopupAuto ) &&
noModifier && !e->text().isEmpty() )
{
QString old_txt = text();
bool hasUserSelection=d->userSelection;
bool hadSelection=hasSelectedText();
bool cursorNotAtEnd=false;
int start,end;
getSelection(&start, &end);
int cPos = cursorPosition();
QString keycode = e->text();
// When moving the cursor, we want to keep the autocompletion as an
// autocompletion, so we want to process events at the cursor position
// as if there was no selection. After processing the key event, we
// can set the new autocompletion again.
if (hadSelection && !hasUserSelection && start>cPos &&
( (!keycode.isEmpty() && keycode.unicode()->isPrint()) ||
e->key() == Key_Backspace || e->key() == Key_Delete ) )
{
del();
setCursorPosition(cPos);
cursorNotAtEnd=true;
}
uint selectedLength=selectedText().length();
d->disableRestoreSelection = true;
QLineEdit::keyPressEvent ( e );
d->disableRestoreSelection = false;
if (( selectedLength != selectedText().length() ) && !hasUserSelection )
slotRestoreSelectionColors(); // and set userSelection to true
QString txt = text();
int len = txt.length();
if ( txt != old_txt && len/* && ( cursorPosition() == len || force )*/ &&
( (!keycode.isEmpty() && keycode.unicode()->isPrint()) ||
e->key() == Key_Backspace || e->key() == Key_Delete) )
{
if ( e->key() == Key_Backspace )
{
if ( hadSelection && !hasUserSelection && !cursorNotAtEnd )
{
backspace();
txt = text();
len = txt.length();
}
if ( !d->backspacePerformsCompletion )
d->autoSuggest = false;
}
if (e->key() == Key_Delete )
d->autoSuggest=false;
if ( d->completionBox )
d->completionBox->setCancelledText( txt );
if ( emitSignals() )
emit completion( txt ); // emit when requested...
if ( handleSignals() ) {
makeCompletion( txt ); // handle when requested...
}
if ( (e->key() == Key_Backspace || e->key() == Key_Delete ) &&
mode == KGlobalSettings::CompletionPopupAuto )
d->autoSuggest=true;
e->accept();
}
else if (!len && d->completionBox && d->completionBox->isVisible())
d->completionBox->hide();
return;
}
else if ( mode == KGlobalSettings::CompletionShell )
{
// Handles completion.
KShortcut cut;
if ( keys[TextCompletion].isNull() )
cut = KStdAccel::shortcut(KStdAccel::TextCompletion);
else
cut = keys[TextCompletion];
if ( cut.contains( key ) )
{
// Emit completion if the completion mode is CompletionShell
// and the cursor is at the end of the string.
QString txt = text();
int len = txt.length();
if ( cursorPosition() == len && len != 0 )
{
if ( emitSignals() )
emit completion( txt );
if ( handleSignals() )
makeCompletion( txt );
return;
}
}
else if ( d->completionBox )
d->completionBox->hide();
}
// handle rotation
if ( mode != KGlobalSettings::CompletionNone )
{
// Handles previous match
KShortcut cut;
if ( keys[PrevCompletionMatch].isNull() )
cut = KStdAccel::shortcut(KStdAccel::PrevCompletion);
else
cut = keys[PrevCompletionMatch];
if ( cut.contains( key ) )
{
if ( emitSignals() )
emit textRotation( KCompletionBase::PrevCompletionMatch );
if ( handleSignals() )
rotateText( KCompletionBase::PrevCompletionMatch );
return;
}
// Handles next match
if ( keys[NextCompletionMatch].isNull() )
cut = KStdAccel::shortcut(KStdAccel::NextCompletion);
else
cut = keys[NextCompletionMatch];
if ( cut.contains( key ) )
{
if ( emitSignals() )
emit textRotation( KCompletionBase::NextCompletionMatch );
if ( handleSignals() )
rotateText( KCompletionBase::NextCompletionMatch );
return;
}
}
// substring completion
if ( compObj() )
{
KShortcut cut;
if ( keys[SubstringCompletion].isNull() )
cut = KStdAccel::shortcut(KStdAccel::SubstringCompletion);
else
cut = keys[SubstringCompletion];
if ( cut.contains( key ) )
{
if ( emitSignals() )
emit substringCompletion( text() );
if ( handleSignals() )
{
setCompletedItems( compObj()->substringCompletion(text()));
e->accept();
}
return;
}
}
}
uint selectedLength = selectedText().length();
// Let QLineEdit handle any other keys events.
QLineEdit::keyPressEvent ( e );
if ( selectedLength != selectedText().length() )
slotRestoreSelectionColors(); // and set userSelection to true
}
/*
* Input a line with some basic editing.
*/
char * read_line() {
// save terminal settings
struct termios orig_attr;
tcgetattr(0, &orig_attr);
// Set terminal in raw mode
tty_raw_mode();
line_length = 0;
line_pos = 0;
// reset the line buffer
int t = 0;
for (t = 0; t < MAX_BUFFER_LINE; t++) {
line_buffer[t] = '\0';
}
// Read one line until enter is typed
while (1) {
// init history if necessary
if (history == NULL) {
init_hist();
}
// Read one character in raw mode.
char ch;
read(0, &ch, 1);
if (ch>=32 && ch < 127) {
// It is a printable character.
if (line_pos == line_length) {
// we're at the end of the line
// Do echo
write(1,&ch,1);
// If max number of character reached return.
if (line_length==MAX_BUFFER_LINE-2) break;
// add char to buffer.
line_buffer[line_pos]=ch;
line_length++;
line_pos++;
} else {
// in the middle of the line somewhere
char * temp = (char*)malloc(MAX_BUFFER_LINE * sizeof(char));
int i;
// copy all the characters after where we're at
for ( i = 0; i < MAX_BUFFER_LINE; i++) {
if (line_buffer[line_pos + i] == '\0' ) {
// if we see the null char, we've gotten it all
break;
}
temp[i] = line_buffer[line_pos + i];
}
// write the character we want to add
write (1, &ch, 1);
// If max number of character reached return.
if (line_length==MAX_BUFFER_LINE-2) break;
// add char to buffer.
line_buffer[line_pos]=ch;
line_length++;
line_pos++;
// print all the rest of the characters afterwards
int chars_added = 0;
for (i = 0; i < MAX_BUFFER_LINE; i++) {
chars_added+=1;
write(1, &temp[i], 1);
if (line_buffer[line_pos + i] == '\0' ) {
// if we see the null char, we've gotten it all
break;
}
}
// go back to where we were
backspace(chars_added);
}
}
else if (ch==10) {
// <Enter> was typed. Return line
// add line to history linked list if it's not empty
if ( strlen(line_buffer) != 0 ) {
add_hist_line(line_buffer);
}
// Print newline
write(1,&ch,1);
break;
}
else if (ch == 31) {
// ctrl-?
read_line_print_usage();
line_buffer[0]=0;
break;
}
else if (ch == 127) {
// <backspace> was typed. Remove previous character read.
// don't do anything if we're already at the beginning
if (line_pos <= 0) {
continue;
}
// Go back one character
backspace(1);
// Write a space to erase the last character read
ch = ' ';
write(1,&ch,1);
// Go back one character
backspace(1);
// Remove one character from buffer
line_buffer[ line_pos ] = '\0';
line_length--;
line_pos--;
}
else if (ch==27) {
// Escape sequence. Read two chars more
//
// HINT: Use the program "keyboard-example" to
// see the ascii code for the different chars typed.
//
char ch1;
char ch2;
read(0, &ch1, 1);
read(0, &ch2, 1);
if (ch1==91 && ch2==65) {
// Up arrow. Print next line in history.
// Erase old line
// Print backspaces
int i = 0;
for (i =0; i < line_length; i++) {
ch = 8;
write(1,&ch,1);
}
// Print spaces on top
for (i =0; i < line_length; i++) {
ch = ' ';
write(1,&ch,1);
}
// Print backspaces
for (i =0; i < line_length; i++) {
ch = 8;
write(1,&ch,1);
}
// if history is uninitialized, do nothing
// Copy line from history
history_index -= 1;
if (history_index <= 0) {
// loop back to the most recent command
history_index = history_length - 1;
}
if (history[history_index] == NULL) {
const char * empty = "";
strcpy(line_buffer, empty);
} else {
strcpy(line_buffer, history[history_index]);
}
line_length = strlen(line_buffer);
// echo line
write(1, line_buffer, line_length);
}
else if (ch1 == 91 && ch2 == 66) {
// down arrow. print previous line in history
// Erase old line
// Print backspaces
backspace( line_length );
// Print spaces on top
int i = 0;
for (i =0; i < line_length; i++) {
ch = ' ';
write(1,&ch,1);
}
// Print backspaces
backspace( line_length );
// increment index accordingly
if (history_index <= 0) {
// stay at 0
history_index = 0;
} else {
history_index += 1;
if (history_index >= history_length ) {
history_index = 0;
}
}
// Copy line from history
if (history[history_index] == NULL) {
const char * empty = "";
strcpy(line_buffer, empty);
} else {
strcpy(line_buffer, history[history_index]);
}
line_length = strlen(line_buffer);
// echo line
write(1, line_buffer, line_length);
}
else if (ch1 == 91 && ch2 == 68) {
// left arrow
if (line_pos > 0) {
line_pos--;
backspace(1);
}
}
else if (ch1 == 91 && ch2 == 67) {
// right arrow
if (line_pos < line_length) {
// grab current char
char c = line_buffer[line_pos];
// print grabbed char
write( 1, &c, 1);
line_pos++;
}
}
}
}
// Add eol and null char at the end of string
line_buffer[line_length]=10;
line_length++;
line_buffer[line_length]=0;
// set the terminal back to orig settings
tcsetattr(0, TCSANOW, &orig_attr);
return line_buffer;
}
// Processes an output message, depending on its type
void handleOutput(OutputData odMessage)
{
char* szFile, * szTopic, * szError, * szTemp;
bool bPartialMatch;
// If there's a prompt on screen, remove it.
if ( bPromptOnScreen )
{
backspace(nPromptLength);
bPromptOnScreen = false;
}
switch ( odMessage.nType )
{
// Standard text output
case OP_NORMAL:
local(odMessage.szMessage, odMessage.nColor, 0);
break;
// New prompt for a hotkey
case OP_HOTKEY_PROMPT:
bPromptOnScreen = false;
bCommandMode = false;
if ( strlen(odMessage.szMessage) >= 60 )
odMessage.szMessage[59] = '\0';
odPromptInfo = odMessage;
break;
// New prompt for a command string
case OP_COMMAND_PROMPT:
bPromptOnScreen = false;
bCommandMode = true;
if ( strlen(odMessage.szMessage) >= 60 )
odMessage.szMessage[59] = '\0';
odPromptInfo = odMessage;
break;
// Pause
case OP_FORCE_PAUSE:
pausePrompt();
break;
// Exit
case OP_EXIT_NODE:
exitDoor(0);
break;
// Clear Screen
case OP_CLEAR_SCREEN:
clearScreen();
break;
// Display text, centered
case OP_CENTER_TEXT:
center(odMessage.szMessage, odMessage.nColor, 0);
break;
// Display a file (adds .ANS or .ASC as appropriate)
case OP_DISPLAY_ANSI:
if ( hasAnsi() )
strcat(odMessage.szMessage, ".ans");
else
strcat(odMessage.szMessage, ".asc");
showAnsi(odMessage.szMessage);
break;
// Display an entry in an HLP file
case OP_DISPLAY_HLP:
szFile = strtok(odMessage.szMessage, "&");
szTopic = strtok(NULL, "&");
szError = strtok(NULL, "&");
szTemp = strtok(NULL, "");
if ( szTemp[0] == 'y' )
bPartialMatch = true;
else
bPartialMatch = false;
displayHelp( szFile, szTopic, szError, bPartialMatch );
break;
}
// If current prompt is a blank prompt, and new message is not a prompt-change,
// update the current prompt's HP/SP/MF/etc values using data in the new message.
if ( odMessage.nType != OP_HOTKEY_PROMPT && odMessage.nType != OP_COMMAND_PROMPT && strlen(odPromptInfo.szMessage) <= 0 )
{
short nOldType = odPromptInfo.nType;
odPromptInfo = odMessage;
odPromptInfo.nType = nOldType;
odPromptInfo.szMessage[0] = '\0';
}
}
