/** * keyboard_read() will invoke this routine after having recognized a key press. * * @param tty The key press is for whom. * @param key The integer key with metadata. *****************************************************************************/ PUBLIC void in_process(TTY* tty, u32 key) { if (!(key & FLAG_EXT)) { put_key(tty, key); } else { int raw_code = key & MASK_RAW; switch(raw_code) { case ENTER: put_key(tty, '\n'); break; case BACKSPACE: put_key(tty, '\b'); break; case UP: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { /* Shift + Up */ scroll_screen(tty->console, SCR_DN); } break; case DOWN: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { /* Shift + Down */ scroll_screen(tty->console, SCR_UP); } break; case RIGHT: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { /* Shift + Right */ select_console(current_console+1); } break; case LEFT: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { /* Shift + Left */ select_console(current_console-1); } break; case F1: case F2: case F3: case F4: case F5: case F6: case F7: case F8: case F9: case F10: case F11: case F12: if ((key & FLAG_ALT_L) || (key & FLAG_ALT_R)) { /* Alt + F1~F12 */ select_console(raw_code - F1); } break; default: break; } } }
/*======================================================================* in_process *======================================================================*/ PUBLIC void in_process(TTY* p_tty, t_32 key) { if (!(key & FLAG_EXT)) { put_key(p_tty, key); } else { int raw_code = key & MASK_RAW; switch(raw_code) { case ENTER: put_key(p_tty, '\n'); break; case BACKSPACE: put_key(p_tty, '\b'); break; case UP: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { /* Shift + Up */ scroll_screen(p_tty->p_console, SCROLL_SCREEN_UP); } break; case DOWN: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { /* Shift + Down */ scroll_screen(p_tty->p_console, SCROLL_SCREEN_DOWN); } break; case F1: case F2: case F3: case F4: case F5: case F6: case F7: case F8: case F9: case F10: case F11: if ((key & FLAG_ALT_L) || (key & FLAG_ALT_R)) { /* Alt + F1~F11 */ select_console(raw_code - F1); } break; case F12: if ((key & FLAG_ALT_L) || (key & FLAG_ALT_R)) { if (schedule != sched0) { schedule = sched0; } else { schedule = (xmodfunc)XModPhyAddr; } } break; default: break; } } }
/*======================================================================* in_process *======================================================================*/ PUBLIC void in_process(TTY* p_tty, u32 key) { if (!(key & FLAG_EXT)) { put_key(p_tty, key); } else { int raw_code = key & MASK_RAW; switch(raw_code) { case ENTER: put_key(p_tty, '\n'); break; case BACKSPACE: put_key(p_tty, '\b'); break; case UP: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { scroll_screen(p_tty->p_console, SCR_DN); } break; case DOWN: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { scroll_screen(p_tty->p_console, SCR_UP); } break; case F1: case F2: case F3: case F4: case F5: case F6: case F7: case F8: case F9: case F10: case F11: case F12: /* Alt + F1~F12 */ if ((key & FLAG_CTRL_L) || (key & FLAG_CTRL_R)) { select_console(raw_code - F1); } else { if (raw_code == F12) { disable_int(); dump_proc(proc_table + 4); for(;;); } } break; default: break; } } }
/*======================================================================* in_process *======================================================================*/ PUBLIC void in_process(TTY* p_tty, t_32 key) { if (!(key & FLAG_EXT)) { put_key(p_tty, key); out_char(p_tty->p_console, key); } else { int raw_code = key & MASK_RAW; switch(raw_code) { case ENTER: put_key(p_tty, '\n'); handle_command(p_tty); break; case BACKSPACE: if(p_tty->inbuf_count>0){ out_char(p_tty->p_console, '\b'); } put_key(p_tty, '\b'); break; case UP: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { /* Shift + Up */ scroll_screen(p_tty->p_console, SCROLL_SCREEN_UP); } break; case DOWN: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { /* Shift + Down */ scroll_screen(p_tty->p_console, SCROLL_SCREEN_DOWN); } break; case F1: case F2: case F3: case F4: case F5: case F6: case F7: case F8: case F9: case F10: case F11: case F12: if (1) { /* Alt + F1~F12 */ select_console(raw_code - F1); } break; default: break; } } }
/*======================================================================* in_process *======================================================================*/ PUBLIC void in_process(TTY* p_tty, t_32 key) { if (!(key & FLAG_EXT)) { if (p_tty->startScanf==0) return ; put_key(p_tty, key); putToTemp(p_tty,key); } else { int raw_code = key & MASK_RAW; switch(raw_code) { case ENTER: put_key(p_tty, '\n'); putToStr(p_tty); break; case BACKSPACE: if (p_tty->tmpLen) { put_key(p_tty, '\b'); p_tty->tmpLen--; } break; case UP: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { /* Shift + Up */ scroll_screen(p_tty->p_console, SCROLL_SCREEN_UP); } break; case DOWN: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { /* Shift + Down */ scroll_screen(p_tty->p_console, SCROLL_SCREEN_DOWN); } break; case F1: case F2: case F3: case F4: case F5: case F6: case F7: case F8: case F9: case F10: case F11: case F12: if ((key & FLAG_ALT_L) || (key & FLAG_ALT_R)) { /* Alt + F1~F12 */ select_console(raw_code - F1); } break; default: break; } } }
/*======================================================================* in_process *======================================================================*/ PUBLIC void in_process(TTY* p_tty, u32 key) { char output[2] = {'\0', '\0'}; if (p_tty->disable_output) { sys_char = key; return; } if (!(key & FLAG_EXT)) { if (p_tty->inbuf_count < TTY_IN_BYTES) { *(p_tty->p_inbuf_head) = key; p_tty->p_inbuf_head++; if (p_tty->p_inbuf_head == p_tty->in_buf + TTY_IN_BYTES) { p_tty->p_inbuf_head = p_tty->in_buf; } p_tty->inbuf_count++; } } else { int raw_code = key & MASK_RAW; switch(raw_code) { case UP: if ((key & SHIFT_L) || (key & SHIFT_R)) { scroll_screen(p_tty->p_console, SCR_UP); } break; case DOWN: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { scroll_screen(p_tty->p_console, SCR_DN); } break; case F1: case F2: case F3: if ((key & FLAG_ALT_L) || (key & FLAG_ALT_R)) { select_console(raw_code - F1); } break; case ENTER: out_string(p_tty->p_console, "\n> ", Blue); out_string(p_tty->p_console, "$ ", Light_Green); break; case BACKSPACE: out_char(p_tty->p_console, '\b', White); break; default: break; } } }
/*======================================================================* in_process *======================================================================*/ PUBLIC void in_process(TTY* p_tty, u32 key) { char output[2] = {'\0', '\0'}; if (!(key & FLAG_EXT)) { put_key(p_tty, key); } else { int raw_code = key & MASK_RAW; switch(raw_code) { case ENTER: put_key(p_tty, '\n'); break; case BACKSPACE: put_key(p_tty, '\b'); break; case UP: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { scroll_screen(p_tty->p_console, SCR_DN); } break; case DOWN: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { scroll_screen(p_tty->p_console, SCR_UP); } break; case F1: case F2: case F3: case F4: case F5: case F6: case F7: case F8: case F9: case F10: case F11: case F12: /* Alt + F1~F12 */ if ((key & FLAG_ALT_L) || (key & FLAG_ALT_R)) { select_console(raw_code - F1); } break; default: break; } } }
void print_char(char ch) { u16_t block = (white_on_black << 8) + ch; switch (ch) { case '\r': g_screen_cursor = (u16_t*)(((u32_t)(void*)g_screen_cursor - screen_init_cursor - 1) / (2 * screen_width) * 2 * screen_width + screen_init_cursor); break; case '\n': g_screen_cursor += screen_width; break; case 0: break; default: *g_screen_cursor = block; g_screen_cursor++; break; } if (g_screen_cursor >= (u16_t*)screen_end_cursor) { //clear_screen(); scroll_screen(); } update_cursor(); }
void update() { int x, y, z; current_view = (current_view == left_view) ? right_view : left_view; // draw complete background rectfill(current_view, 0, 0, 639, 479, BACKGROUND_COLOR); draw_sprite(current_view, new_game, NEW_GAME_BUTTON_X1, BUTTON_YOFF); draw_sprite(current_view, undo, UNDO_BUTTON_X1, BUTTON_YOFF); draw_sprite(current_view, help, HELP_BUTTON_X1, BUTTON_YOFF); draw_sprite(current_view, quit, QUIT_BUTTON_X1, BUTTON_YOFF); if(editing) { textprintf(current_view, font, 200, 2, SELECTED, "Editing: '%s' (%s)", layout_title, get_filename(editing)); textprintf(current_view, font, 200, 12, SELECTED, "%3i pieces left", n_pieces_left); } for(z = 0; z < 3; z++) for(y = 0; y < 9; y++) for(x = 0; x < 16; x++) if(board[x][y][z].value < EMPTY || editing) drawPiece(current_view, &board[x][y][z]); scroll_screen((current_view == left_view) ? 0 : SCREEN_WIDTH, 0); show_mouse(current_view); }
void print(char ch) { switch (ch) { case '\n': ++_row; _column = 0; break; case '\t': _column += core::Log::TAB_NR_SPACES - (_column % core::Log::TAB_NR_SPACES); break; default: size_t position = 2 * ((_row * _gfx->columns) + _column); _gfx->start[position] = ch; _gfx->start[position + 1] = _color_code; ++_column; break; } if (_column >= _gfx->columns) { _column = 0; ++_row; } if (_row >= _gfx->rows) { --_row; scroll_screen(); } }
/** * Write a string on screen * * \param str String */ void kprint(char *str) { unsigned int i = 0; char c; while((c = str[i]) != '\0') { switch(c) { case '\n': if(py <= VIDEO_ROWS) { py++; if(py >= VIDEO_ROWS) { scroll_screen(); py = VIDEO_ROWS-1; } } px = 0; break; case '\r': if(px > 0) px--; break; case '\b': if(px > 0) px--; writechar(' ', c_attr); px--; break; default: writechar(str[i], c_attr); } i++; } return; }
/*======================================================================* out_char *======================================================================*/ PUBLIC void out_char(CONSOLE* p_con, char ch) { u8* p_vmem = (u8*)(V_MEM_BASE + p_con->cursor * 2); switch(ch) { case '\n': if (p_con->cursor < p_con->original_addr + p_con->v_mem_limit - SCREEN_WIDTH) { p_con->cursor = p_con->original_addr + SCREEN_WIDTH * ((p_con->cursor - p_con->original_addr) / SCREEN_WIDTH + 1); } break; case '\b': if (p_con->cursor > p_con->original_addr) { p_con->cursor--; *(p_vmem-2) = ' '; *(p_vmem-1) = DEFAULT_CHAR_COLOR; } break; case '\t': if (p_con->cursor < p_con->original_addr + p_con->v_mem_limit - 1){ int i=0; for (i=0;i<4;i++){ *p_vmem++=' '; *p_vmem++=DEFAULT_CHAR_COLOR; p_con->cursor++; } } break; default: if (p_con->cursor < p_con->original_addr + p_con->v_mem_limit - 1) { *p_vmem++ = ch; if (f1){ *p_vmem++ = RED; }else if(f2){ *p_vmem++ = BLUE; }else if(f3){ *p_vmem++ = GREEN; }else if(f4){ *p_vmem++ = CYAN; }else if(f5){ *p_vmem++ = BROWN; } p_con->cursor++; } break; } while (p_con->cursor >= p_con->current_start_addr + SCREEN_SIZE) { scroll_screen(p_con, SCR_DN); } flush(p_con); }
void in_process(struct Tty *p_tty, uint32_t key) { if (!(key & FLAG_EXT)) { put_key(p_tty, key); } else { int raw_code = key & MASK_RAW; switch(raw_code) { case ENTER: put_key(p_tty, 0x0a); break; case BACKSPACE: put_key(p_tty, '\b'); break; case UP: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) scroll_screen(p_tty->p_console, SCR_DN); break; case DOWN: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) scroll_screen(p_tty->p_console, SCR_UP); break; case F1: case F2: case F3: case F4: case F5: case F6: case F7: case F8: case F9: case F10: case F11: case F12: /* Alt + F1~F12 */ if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { select_console(raw_code - F1); } break; default: break; } } }
/** * Print a char in a certain console. * * @param con The console to which the char is printed. * @param ch The char to print. *****************************************************************************/ PUBLIC void out_char(CONSOLE* con, char ch) { disable_int(); u8* pch = (u8*)(V_MEM_BASE + con->cursor * 2); assert(con->cursor - con->orig < con->con_size); /* * calculate the coordinate of cursor in current console (not in * current screen) */ int cursor_x = (con->cursor - con->orig) % SCR_WIDTH; int cursor_y = (con->cursor - con->orig) / SCR_WIDTH; switch(ch) { case '\n': con->cursor = con->orig + SCR_WIDTH * (cursor_y + 1); break; case '\b': if (con->cursor > con->orig) { con->cursor--; *(pch - 2) = ' '; *(pch - 1) = DEFAULT_CHAR_COLOR; } break; default: *pch++ = ch; *pch++ = DEFAULT_CHAR_COLOR; con->cursor++; break; } if (con->cursor - con->orig >= con->con_size) { cursor_x = (con->cursor - con->orig) % SCR_WIDTH; cursor_y = (con->cursor - con->orig) / SCR_WIDTH; int cp_orig = con->orig + (cursor_y + 1) * SCR_WIDTH - SCR_SIZE; w_copy(con->orig, cp_orig, SCR_SIZE - SCR_WIDTH); con->crtc_start = con->orig; con->cursor = con->orig + (SCR_SIZE - SCR_WIDTH) + cursor_x; clear_screen(con->cursor, SCR_WIDTH); if (!con->is_full) con->is_full = 1; } assert(con->cursor - con->orig < con->con_size); while (con->cursor >= con->crtc_start + SCR_SIZE || con->cursor < con->crtc_start) { scroll_screen(con, SCR_UP); clear_screen(con->cursor, SCR_WIDTH); } flush(con); enable_int(); }
/*======================================================================* in_process *======================================================================*/ PUBLIC void in_process(TTY* p_tty, u32 key) { char output[2] = {'\0', '\0'}; if (!(key & FLAG_EXT)) { put_key(p_tty, key); } else { int raw_code = key & MASK_RAW; switch(raw_code) { case ENTER: put_key(p_tty, '\n'); break; case BACKSPACE: put_key(p_tty, '\b'); break; case TAB: put_key(p_tty,' '); put_key(p_tty,' '); put_key(p_tty,' '); put_key(p_tty,' '); break; case UP: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { scroll_screen(p_tty->p_console, SCR_DN); } else { changeColor(); } break; case DOWN: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { scroll_screen(p_tty->p_console, SCR_UP); } else { changeColor(); } break; default: break; } } }
/* show_video_bitmap: * Page flipping function: swaps to display the specified video memory * bitmap object (this must be the same size as the physical screen). */ int show_video_bitmap(BITMAP *bitmap) { if ((!is_video_bitmap(bitmap)) || (bitmap->w != SCREEN_W) || (bitmap->h != SCREEN_H) || (_dispsw_status)) return -1; if (gfx_driver->show_video_bitmap) return gfx_driver->show_video_bitmap(bitmap); return scroll_screen(bitmap->x_ofs, bitmap->y_ofs); }
PUBLIC void out_char(CONSOLE *p_con, char ch) { u8* p_vmem = (u8*)(V_MEM_BASE + p_con -> cursor * 2); switch(ch) { case '\n': /* 回车键 */ if (p_con -> cursor < p_con -> original_addr + p_con -> v_mem_limit - SCREEN_WIDTH) { int line = (p_con -> cursor - p_con -> original_addr) / SCREEN_WIDTH + 1; p_con -> cursor = p_con -> original_addr + SCREEN_WIDTH * line; } break; case '\b': /* Backspace */ if (p_con -> cursor > p_con -> original_addr) { p_con -> cursor--; *(p_vmem-2) = ' ' ; *(p_vmem-1) = DEFAULT_COLOR; } break; default: if (p_con -> cursor < p_con -> original_addr + p_con -> v_mem_limit - 1) { *p_vmem++ = ch; *p_vmem++ = DEFAULT_COLOR; p_con -> cursor++; } } while (p_con -> cursor >= p_con -> current_start_addr + SCREEN_SIZE) { scroll_screen(p_con, SCR_DN); } while (p_con -> cursor < p_con -> current_start_addr) { /* 向上卷 */ scroll_screen(p_con, SCR_UP); } flush(p_con); }
/*======================================================================* out_char *======================================================================*/ PUBLIC void out_char(CONSOLE* p_con, char ch, int color) { int row, column; u8* p_vmem = (u8*)(V_MEM_BASE + p_con->cursor * 2); switch(ch) { case '\n': if (p_con->cursor < p_con->original_addr + p_con->v_mem_limit - SCREEN_WIDTH) { p_con->cursor = p_con->original_addr + SCREEN_WIDTH * ((p_con->cursor - p_con->original_addr) / SCREEN_WIDTH + 1); } break; case '\b': row = (p_con->cursor - p_con->original_addr) / SCREEN_WIDTH; column = p_con->cursor - row * SCREEN_WIDTH; if (column > 4) { p_con->cursor--; *(p_vmem - 2) = ' '; *(p_vmem - 1) = White; } break; case '\t': out_string(p_con, " ", color); break; default: if (p_con->cursor < p_con->original_addr + p_con->v_mem_limit - 1) { *p_vmem++ = ch; *p_vmem++ = color; p_con->cursor++; } break; } while (p_con->cursor >= p_con->current_start_addr + SCREEN_SIZE) { scroll_screen(p_con, SCR_DN); } if (p_con == console_table + nr_current_console){ flush(p_con); } }
/* Be carefull: * You can not use printf or other function thant invoke out_char before the tty is inittied, * for the cursor_location is an invalid location, which whill result in Page Fault! * */ void out_char(CONSOLE * p_con,char ch) { disp_pos=0; t_8 *vmem_p=(t_8 *)(V_MEM_BASE + p_con->cursor_location*2); switch(ch){ case '\n': if(p_con->cursor_location + SCREEN_WIDETH < p_con->begin_adr+p_con->vmem_limit ){ int line=(p_con->cursor_location - p_con->begin_adr)/SCREEN_WIDETH+1; p_con->cursor_location=line*SCREEN_WIDETH + p_con->begin_adr; } break; case '\b': if(p_con->cursor_location > p_con->begin_adr){ p_con->cursor_location--; *(vmem_p-2)=' '; *(vmem_p-1)=COLOR; } break; default: if(p_con->cursor_location < p_con->begin_adr+p_con->vmem_limit){ *vmem_p = ch; vmem_p++; *vmem_p = COLOR; vmem_p++; p_con->cursor_location++; } else{ p_con->cursor_location=p_con->begin_adr; vmem_p=(t_8 *)(V_MEM_BASE + p_con->cursor_location*2); *vmem_p = ch; vmem_p++; *vmem_p = COLOR; vmem_p++; } } while(p_con->cursor_location >= p_con->current_start_addr + SCREEN_SIZE){ scroll_screen(p_con,SCROLL_DOWN); } set_cursor(p_con->cursor_location);//display position }
/* request_scroll: * Attempts to initiate a triple buffered hardware scroll, which will * take place during the next retrace. Returns 0 on success. */ int request_scroll(int x, int y) { int ret = 0; int h; /* can driver handle triple buffering? */ if ((!gfx_driver->request_scroll) || (_dispsw_status)) { scroll_screen(x, y); return -1; } /* clip x */ if (x < 0) { x = 0; ret = -1; } else if (x > (VIRTUAL_W - SCREEN_W)) { x = VIRTUAL_W - SCREEN_W; ret = -1; } /* clip y */ if (y < 0) { y = 0; ret = -1; } else { h = (_screen_split_position > 0) ? _screen_split_position : SCREEN_H; if (y > (VIRTUAL_H - h)) { y = VIRTUAL_H - h; ret = -1; } } /* scroll! */ if (gfx_driver->request_scroll(x, y) != 0) ret = -1; return ret; }
// 2 bytes are written: <color> then <character> void display_character(uint8_t c) { uint16_t attr = color << 8; // first byte is color uint16_t *loc = video_memory + (80*cursor_y + cursor_x); // backspace if (c == 0x08 && !(cursor_x==0 && cursor_y==8)) { if (cursor_x == 0) { cursor_x = 79; cursor_y --; } else cursor_x--; *(loc-1) = ' ' | attr; } // tab else if (c == 0x09) cursor_x = 8 * ((cursor_x+8)/8); // carriage return else if (c == '\r') cursor_x = 0; // new line else if (c == '\n') { cursor_x = 0; cursor_y++; } // other characters else if(c >= 32) { *loc = c | attr; cursor_x++; } // edge conditions if (cursor_x >= 80) { // goto next line cursor_x = 0; cursor_y++; } if (cursor_y >= 25) { // scroll screen up scroll_screen(); } set_cursor(cursor_x,cursor_y); }
static void vga_putc(int c) { bool new_row = false; switch ( c ) { case '\n': cursor_y++; cursor_x = 0; new_row = true; break; case '\r': cursor_x = 0; break; case '\t': cursor_x += 4; break; default: __putc(cursor_x, cursor_y, c); cursor_x++; break; } if ( cursor_x >= MAX_COLS ) { cursor_x %= MAX_COLS; cursor_y++; new_row = true; } if ( new_row ) { num_lines++; if ( cursor_y >= MAX_LINES ) { scroll_screen(); cursor_y--; } /* (optionally) pause after every screenful */ if ( (num_lines % (MAX_LINES - 1)) == 0 && g_vga_delay > 0 ) delay(g_vga_delay * 1000); } }
/** * Write a character on screen * * \param ch Character * \param attr Character attribute (color) */ void writechar(char ch, unsigned char attr) { unsigned int pos; pos = ((VIDEO_COLS * py) + px) * 2; /* Update cursor position */ if(px >= VIDEO_COLS) { px = 0; py++; if(py >= VIDEO_ROWS) { scroll_screen(); py = VIDEO_ROWS-1; } } else { px++; } videomem[pos] = ch; videomem[pos+1] = attr; }
/*======================================================================* out_char *======================================================================*/ PUBLIC void out_char(CONSOLE* p_con, char ch , char color) { u8* p_vmem = (u8*)(V_MEM_BASE + p_con->cursor * 2); switch(ch) { case '\n': if (p_con->cursor < p_con->original_addr + p_con->v_mem_limit - SCREEN_WIDTH) { p_con->cursor = p_con->original_addr + SCREEN_WIDTH * ((p_con->cursor - p_con->original_addr) / SCREEN_WIDTH + 1); } break; case '\b': if (p_con->cursor > p_con->original_addr) { p_con->cursor--; *(p_vmem-2) = ' '; *(p_vmem-1) = DEFAULT_CHAR_COLOR; } break; default: if (p_con->cursor < p_con->original_addr + p_con->v_mem_limit - 1) { *p_vmem++ = ch; *p_vmem++ = color; p_con->cursor++; } break; } while (p_con->cursor >= p_con->current_start_addr + SCREEN_SIZE) { scroll_screen(p_con, SCR_DN); } flush(p_con); }
int main(void) { BITMAP *scroller; RGB black = { 0, 0, 0, 0 }; int x = 0; int next_x; int h = 100; if (allegro_init() != 0) return 1; install_keyboard(); if (set_gfx_mode(GFX_AUTODETECT, 320, 240, 640, 240) != 0) { set_gfx_mode(GFX_TEXT, 0, 0, 0, 0); allegro_message("Unable to set a 320x240 mode with 640x240 " "virtual dimensions\n"); return 1; } /* the scrolling area is twice the width of the screen (640x240) */ scroller = create_sub_bitmap(screen, 0, 0, SCREEN_W*2, SCREEN_H); set_palette(desktop_palette); set_color(0, &black); rectfill(scroller, 0, 0, SCREEN_W, 100, 6); rectfill(scroller, 0, 100, SCREEN_W, SCREEN_H, 2); do { /* advance the scroller, wrapping every 320 pixels */ next_x = x + 1; if (next_x >= 320) next_x = 0; /* draw another column of the landscape */ acquire_bitmap(scroller); vline(scroller, next_x+SCREEN_W-1, 0, h, 6); vline(scroller, next_x+SCREEN_W-1, h+1, SCREEN_H, 2); release_bitmap(scroller); /* scroll the screen */ scroll_screen(next_x, 0); /* duplicate the landscape column so we can wrap the scroller */ if (next_x > 0) { acquire_bitmap(scroller); vline(scroller, x, 0, h, 6); vline(scroller, x, h+1, SCREEN_H, 2); release_bitmap(scroller); } /* randomly alter the landscape position */ if (AL_RAND()&1) { if (h > 5) h--; } else { if (h < 195) h++; } x = next_x; rest(0); } while (!keypressed()); destroy_bitmap(scroller); clear_keybuf(); return 0; }
int main(int argc, char *argv[]) { { int i; if((argc - 1) % 2) goto help; for(i = 1; i < argc - 1; i += 2) if(!editing && (!strcmp(argv[i], "-e") || !strcmp(argv[i], "--edit"))) editing = argv[i+1]; else if(!layout_title[0] && (!strcmp(argv[i], "-t") || !strcmp(argv[i], "--title"))) { bzero(layout_title, 55); strncpy(layout_title, argv[i+1], 54); } else { help: printf("usage: mahjong [--edit <layout> [--title <layout title>]]\n"); return 0; } } srand(time(NULL)); allegro_init(); { int x, y, z; for(x = 16; x--;) for(y = 9; y--;) for(z = 3; z--;) pieceInit(board[x][y][z], x, y, z); } set_color_depth(SCREEN_DEPTH); if(set_gfx_mode(GFX_AUTODETECT_WINDOWED, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*2, SCREEN_HEIGHT) < 0) { fprintf(stderr, "fatal: %s\n", allegro_error); exit(1); } #ifdef ALLEGRO_WINDOWS set_display_switch_callback(SWITCH_IN, update); #endif left_view = create_sub_bitmap(screen, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT); right_view = create_sub_bitmap(screen, SCREEN_WIDTH, 0, SCREEN_WIDTH, SCREEN_HEIGHT); // init colors BACKGROUND_COLOR = makecol32(0x2F, 0x5F, 0x2F); // soft green SELECTED_COLOR = makecol32(0x00, 0xDF, 0x00); // green OLD_SELECTED_COLOR = makecol32(0x00, 0xBF, 0xBF); // cyan // load data { DATAFILE *data = load_datafile("#"); new_game = data[NEW_GAME_BMP].dat; undo = data[UNDO_BMP].dat; help = data[HELP_BMP].dat; quit = data[QUIT_BMP].dat; tile = data[TILE_BMP].dat; number[ 0] = data[BLACK1_BMP].dat; number[ 2] = data[BLACK2_BMP].dat; number[ 4] = data[BLACK3_BMP].dat; number[ 6] = data[BLACK4_BMP].dat; number[ 8] = data[BLACK5_BMP].dat; number[10] = data[BLACK6_BMP].dat; number[12] = data[BLACK7_BMP].dat; number[14] = data[BLACK8_BMP].dat; number[16] = data[BLACK9_BMP].dat; number[ 1] = data[RED1_BMP].dat; number[ 3] = data[RED2_BMP].dat; number[ 5] = data[RED3_BMP].dat; number[ 7] = data[RED4_BMP].dat; number[ 9] = data[RED5_BMP].dat; number[11] = data[RED6_BMP].dat; number[13] = data[RED7_BMP].dat; number[15] = data[RED8_BMP].dat; number[17] = data[RED9_BMP].dat; suit[0] = data[SPADE_BMP].dat; suit[1] = data[CLUB_BMP].dat; suit[2] = data[DIAMOND_BMP].dat; suit[3] = data[HEART_BMP].dat; layouts[0] = data[BLOCK_LYT].dat; layouts[1] = data[FLAT_LYT].dat; layouts[2] = data[FROGGER_LYT].dat; layouts[3] = data[PRECIOUS_LYT].dat; layouts[4] = data[PTRAD_LYT].dat; layouts[5] = data[PYRAMID_LYT].dat; layouts[6] = data[STEPS_LYT].dat; layouts[7] = data[THETA_LYT].dat; } scroll_screen(SCREEN_WIDTH, 0); current_view = right_view; install_timer(); install_mouse(); install_keyboard(); show_mouse(current_view); text_mode(BACKGROUND_COLOR); if(!editing) { defaultLayout(); if(alert("Our Own Version of Mahjong Solitaire, v0.1.4", NULL, "Copyright (c) 2001 Eric Mulvaney, Michelle Bondy", "Play", "Edit", 0, 0) == 2 && file_select_ex("Please select layout file to edit:", path, "lyt", PATH_LENGTH-1, OLD_FILESEL_WIDTH, OLD_FILESEL_HEIGHT)) { int x, y, z; editing = path; for(x = 16; x--;) for(y = 9; y--;) for(z = 3; z--;) board[x][y][z].value = EMPTY; } } mouse_callback = editing ? mouse_handler_for_editing : mouse_handler; if(editing) { Layout data; FILE *file = fopen(editing, "r"); if(file) { if(fread(&data, sizeof(Layout), 1, file)) { int x, y, z; if(!layout_title[0]) memcpy(layout_title, data.title, 55); for(x = 16; x--;) for(y = 9; y--;) for(z = (data.board[x][y] > 3) ? 3 : data.board[x][y]; z--;) { board[x][y][z].value = BLANK; if(!--n_pieces_left) goto skip; } } skip: fclose(file); } update(); } click_ready = 0; while(1) // game loop { if(click_ready) { int x = click_x - (BOARD_XOFF - 2 * EDGE_WIDTH ); int y = click_y - (BOARD_YOFF - 2 * EDGE_HEIGHT); int z; for(z = 3; x > 0 && y > 0 && z--; x -= EDGE_WIDTH, y -= EDGE_HEIGHT) { int i = x / FACE_WIDTH; int j = y / FACE_HEIGHT; if(i >= 16 || j >= 9) continue; if(editing) { if(click_ready == 1 && board[i][j][z].value == EMPTY) { if((z == 0 || board[i][j][z-1].value != EMPTY) && n_pieces_left) { n_pieces_left--; board[i][j][z].value = BLANK; updatePiece(&board[i][j][z]); goto event_handled; } } else if(click_ready == 2 && board[i][j][z].value != EMPTY) { if(z == 2 || board[i][j][z+1].value == EMPTY) { board[i][j][z].value = EMPTY; n_pieces_left++; updatePiece(&board[i][j][z]); goto event_handled; } } } else if(selectPiece(&board[i][j][z])) { if(!n_pairs_remaining) { if(current_view != left_view) update(); if(alert("Congratulations! You won!", "Play another?", NULL, "Yes", "No", 0, 0) == 1) newGame(); else return 0; } goto event_handled; } } if(click_y < BUTTON_YOFF + BUTTON_HEIGHT && click_y > BUTTON_YOFF) { if(editing) { if(click_x > NEW_GAME_BUTTON_X1 && click_x < NEW_GAME_BUTTON_X2) { if(n_pieces_left == 144) goto event_handled; if(current_view != left_view) update(); if(alert("Are you sure you want to clear the current Layout?", NULL, NULL, "Yes", "No", 0, 0) == 1) { int x, y, z; for(x = 16; x--;) for(y = 9; y--;) for(z = 3; z--;) board[x][y][z].value = EMPTY; n_pieces_left = 144; update(); } } else if(click_x > QUIT_BUTTON_X1 && click_x < QUIT_BUTTON_X2) { int ync; if(current_view != left_view) update(); if(n_pieces_left) ync = alert3("WARNING: Layout is incomplete.", NULL, "Do you wish to save before exiting?", "Yes", "No", "Cancel", 0, 0, 0); else ync = alert3("Do you wish to save before exiting?", NULL, NULL, "Yes", "No", "Cancel", 0, 0, 0); if(ync == 2) return 0; else if(ync == 1) { Layout data; FILE *file; memcpy(data.title, layout_title, 55); data.complete = (n_pieces_left) ? 0 : 1; if((file = fopen(editing, "w"))) { for(x = 16; x--;) for(y = 9; y--;) { if (board[x][y][2].value == BLANK) data.board[x][y] = 3; else if(board[x][y][1].value == BLANK) data.board[x][y] = 2; else if(board[x][y][0].value == BLANK) data.board[x][y] = 1; else data.board[x][y] = 0; } if(fwrite(&data, sizeof(Layout), 1, file)) { fclose(file); return 0; } else fclose(file); } if(alert("WARNING: Save failed!", NULL, "Do you still wish to exit?", "Yes", "No", 0, 0) == 1) return 0; } } } else if(click_x > NEW_GAME_BUTTON_X1 && click_x < NEW_GAME_BUTTON_X2) newGame(); else if(click_x > UNDO_BUTTON_X1 && click_x < UNDO_BUTTON_X2) undoMove(); else if(click_x > HELP_BUTTON_X1 && click_x < HELP_BUTTON_X2) giveHelp(1); else if(click_x > QUIT_BUTTON_X1 && click_x < QUIT_BUTTON_X2) { if(current_view != left_view) update(); if(alert("Are you sure you want to quit?", NULL, NULL, "Yes", "No", 0, 0) == 1) return 0; } } event_handled: click_ready = 0; } else rest(100); } return 0; }
void scroll_text(char* s){ uint16_t i; for (i=0;s[i]!=0;i++) { scroll_screen(s[i]); } }
/** * Yes, it is an ugly function. * * @param tty Which TTY is reading the keyboard input. *****************************************************************************/ PUBLIC void keyboard_read(TTY* tty) { if (!is_current_console((CONSOLE *)tty->tty_dev)) return; u8 scan_code; /** * 1 : make * 0 : break */ int make; /** * We use a integer to record a key press. * For instance, if the key HOME is pressed, key will be evaluated to * `HOME' defined in keyboard.h. */ u32 key = 0; /** * This var points to a row in keymap[]. I don't use two-dimension * array because I don't like it. */ u32* keyrow; while (kb_in.count > 0) { code_with_E0 = 0; scan_code = get_byte_from_kb_buf(); /* parse the scan code below */ if (scan_code == 0xE1) { int i; u8 pausebreak_scan_code[] = {0xE1, 0x1D, 0x45, 0xE1, 0x9D, 0xC5}; int is_pausebreak = 1; for (i = 1; i < 6; i++) { if (get_byte_from_kb_buf() != pausebreak_scan_code[i]) { is_pausebreak = 0; break; } } if (is_pausebreak) { key = PAUSEBREAK; } } else if (scan_code == 0xE0) { code_with_E0 = 1; scan_code = get_byte_from_kb_buf(); /* PrintScreen is pressed */ if (scan_code == 0x2A) { code_with_E0 = 0; if ((scan_code = get_byte_from_kb_buf()) == 0xE0) { code_with_E0 = 1; if ((scan_code = get_byte_from_kb_buf()) == 0x37) { key = PRINTSCREEN; make = 1; } } } /* PrintScreen is released */ else if (scan_code == 0xB7) { code_with_E0 = 0; if ((scan_code = get_byte_from_kb_buf()) == 0xE0) { code_with_E0 = 1; if ((scan_code = get_byte_from_kb_buf()) == 0xAA) { key = PRINTSCREEN; make = 0; } } } } if ((key != PAUSEBREAK) && (key != PRINTSCREEN)) { int caps; /* make or break */ make = (scan_code & FLAG_BREAK ? 0 : 1); keyrow = &keymap[(scan_code & 0177) * MAP_COLS]; column = 0; caps = shift_l || shift_r; if (caps_lock && keyrow[0] >= 'a' && keyrow[0] <= 'z') caps = !caps; if (caps) column = 1; if (code_with_E0) column = 2; if (ctrl_l || ctrl_r) column = 3; key = keyrow[column]; switch(key) { case SHIFT_L: shift_l = make; break; case SHIFT_R: shift_r = make; break; case CTRL_L: ctrl_l = make; break; case CTRL_R: ctrl_r = make; break; case ALT_L: alt_l = make; break; case ALT_R: alt_l = make; break; case CAPS_LOCK: if (make) { caps_lock = !caps_lock; set_leds(); } break; case NUM_LOCK: if (make) { num_lock = !num_lock; set_leds(); } break; case SCROLL_LOCK: if (make) { scroll_lock = !scroll_lock; set_leds(); } break; default: break; } } if(make){ /* Break Code is ignored */ int pad = 0; /* deal with the numpad first */ if ((key >= PAD_SLASH) && (key <= PAD_9)) { pad = 1; switch(key) { /* '/', '*', '-', '+', * and 'Enter' in num pad */ case PAD_SLASH: key = '/'; break; case PAD_STAR: key = '*'; break; case PAD_MINUS: key = '-'; break; case PAD_PLUS: key = '+'; break; case PAD_ENTER: key = ENTER; break; default: /* the value of these keys * depends on the Numlock */ if (num_lock) { /* '0' ~ '9' and '.' in num pad */ if (key >= PAD_0 && key <= PAD_9) key = key - PAD_0 + '0'; else if (key == PAD_DOT) key = '.'; } else{ switch(key) { case PAD_HOME: key = HOME; break; case PAD_END: key = END; break; case PAD_PAGEUP: key = PAGEUP; break; case PAD_PAGEDOWN: key = PAGEDOWN; break; case PAD_INS: key = INSERT; break; case PAD_UP: key = UP; break; case PAD_DOWN: key = DOWN; break; case PAD_LEFT: key = LEFT; break; case PAD_RIGHT: key = RIGHT; break; case PAD_DOT: key = DELETE; break; default: break; } } break; } } key |= shift_l ? FLAG_SHIFT_L : 0; key |= shift_r ? FLAG_SHIFT_R : 0; key |= ctrl_l ? FLAG_CTRL_L : 0; key |= ctrl_r ? FLAG_CTRL_R : 0; key |= alt_l ? FLAG_ALT_L : 0; key |= alt_r ? FLAG_ALT_R : 0; key |= pad ? FLAG_PAD : 0; int raw_code = key & MASK_RAW; switch(raw_code) { case UP: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { /* Shift + Up */ scroll_screen((CONSOLE *)tty->tty_dev, SCR_DN); } break; case DOWN: if ((key & FLAG_SHIFT_L) || (key & FLAG_SHIFT_R)) { /* Shift + Down */ scroll_screen((CONSOLE *)tty->tty_dev, SCR_UP); } break; case F1: case F2: case F3: case F4: case F5: case F6: case F7: case F8: case F9: case F10: case F11: case F12: if ((key & FLAG_ALT_L) || (key & FLAG_ALT_R)) { /* Alt + F1~F12 */ select_console(raw_code - F1); } break; default: break; } in_process(tty, key); } } }
/*======================================================================* out_char *======================================================================*/ PUBLIC void out_char(CONSOLE* p_con, char ch) { /*if(clear){ p_con->cursor=p_con->original_addr; clear=0; }*/ u8* p_vmem = (u8*)(V_MEM_BASE + p_con->cursor * 2); // last_cursor[0]=p_con->original_addr; int i=0; for(i;i<count;i++){ if(last_cursor[i][0]==p_con->original_addr) break; } if(i==count){ int j=0; for(;j<100;j++){ last_cursor[i][j]=0; } size[i]=0; last_cursor[i][0]=p_con->original_addr; count++; } /* unsigned int current_start_addr; 当前显示到了什么位置 unsigned int original_addr; 当前控制台对应显存位置 unsigned int v_mem_limit; 当前控制台占的显存大小 unsigned int cursor; 当前光标位置 */ //last_cursor[i][++size[i]]=p_con->cursor; // disp_str(shit+'0'); // last_cursor[i][shit]=i; int j=0; switch(ch) { case '\n': if (p_con->cursor < p_con->original_addr + p_con->v_mem_limit - SCREEN_WIDTH) { last_cursor[i][++size[i]]=p_con->cursor; p_con->cursor = p_con->original_addr + SCREEN_WIDTH * ((p_con->cursor - p_con->original_addr) / SCREEN_WIDTH + 1); } break; case '\b': if (p_con->cursor > p_con->original_addr) { if(isTab(p_con)){ p_con->cursor=p_con->cursor-4; *(p_vmem-2) = ' '; *(p_vmem-1) = DEFAULT_CHAR_COLOR; tabSize--; } else{ if((p_con->cursor-p_con->original_addr)%SCREEN_WIDTH==0){ if(size[i]>=1&&size[i]<=99){ p_con->cursor=last_cursor[i][size[i]--]; }else p_con->cursor=last_cursor[i][0]; }else p_con->cursor--; *(p_vmem-2) = ' '; *(p_vmem-1) = DEFAULT_CHAR_COLOR; } } break; case '\t': p_con->cursor+=4; lastTab[tabSize]=p_con->cursor; tabSize++; break; default: if (p_con->cursor < p_con->original_addr + p_con->v_mem_limit - 1) { *p_vmem++ = ch; //*p_vmem++ = DEFAULT_CHAR_COLOR; if(color==2){ *p_vmem++ = F2_COLOR; }else if(color==3){ *p_vmem++ = F3_COLOR; //blue }else if(color==4){ *p_vmem++ = F4_COLOR; }else if(color==5){//green *p_vmem++ = F5_COLOR; }else *p_vmem++=DEFAULT_CHAR_COLOR; //last_cursor= p_con->cursor; p_con->cursor++; } break; } /* if(tab){ lastTab[tabSize]=p_con->cursor; tabSize++; tab=0; }*/ while (p_con->cursor >= p_con->current_start_addr + SCREEN_SIZE) { scroll_screen(p_con, SCR_DN); } flush(p_con); }
/** * Prints a character to the screen, is used * by kprintf and kputs * * @param c Character to print **/ void kputch(unsigned char c) { unsigned short *where; unsigned att = get_attribute() << 8; if(c == 0x08) { /// ! SELBER SCHREIBEN ! if(get_cursor_x() != 0) set_cursor_x(get_cursor_x() - 1); } // else if(c == 0x09) { int newx; /// ! SELBER SCHREIBEN ! newx = (get_cursor_x() + 8) & ~(8 - 1); set_cursor_x(newx); } // Carriage return? Set the cursor to the beginning of the current line else if(c == '\r') { /// ! SELBER SCHREIBEN ! set_cursor_x(0); } // Linefeed? Set the cursor to the next line else if(c == '\n') { /// ! SELBER SCHREIBEN ! set_cursor_x(0); set_cursor_y(get_cursor_y() + 1); } else if(c >= ' ') { /// ! SELBER SCHREIBEN ! //FIXME: get_textmemptr() doesn't work here (whyever...) where = (unsigned short*)0xB8000 + (get_cursor_y() * 80 + get_cursor_x()); *where = c | att; set_cursor_x(get_cursor_x() + 1); } /// ! SELBER SCHREIBEN ! // More than 80 lines? Scroll the screen if(get_cursor_x() >= 80) { set_cursor_x(0); set_cursor_y(get_cursor_y() + 1); } /// ! SELBER SCHREIBEN ! // Scroll the screen and move the cursor scroll_screen(); move_cursor(); }