int main (void) {

  PINSEL10 = 0;                             /* Disable ETM interface */
  FIO2DIR = LEDMSK;                         /* LEDs, port 2, bit 0~7 output only */

  lcd_init();
  lcd_clear();
  lcd_print ("MCB2300 HID Demo");
  set_cursor (0, 1);
  lcd_print ("  www.keil.com  ");

  	Nr = 128;
	Nk = Nr / 32;
	Nr = Nk + 6;
	KeyExpansion(Key, Nk, Nr);

  USB_Init();                               /* USB Initialization */
  USB_Connect(TRUE);                        /* USB Connect */

  while (1);                                /* Loop forever */
}

void
line_drawing_selected(void)
{
    canvas_kbd_proc = (FCallBack)null_proc;
    canvas_locmove_proc = null_proc;
    canvas_leftbut_proc = (FCallBack)init_line_drawing;
    canvas_middlebut_proc = (FCallBack)init_line_freehand_drawing;
    set_cursor(crosshair_cursor);
    reset_action_on();
    if (cur_mode == F_POLYGON) {
	set_mousefun("first point", "freehand", "", "", "", "");
	min_num_points = 3;
	canvas_rightbut_proc = (FCallBack)null_proc;
    } else {
	set_mousefun("first point", "freehand", "single point", "dimension line", "", "");
	min_num_points = 1;
	num_point = 0;
	fix_x = fix_y = -1;
	canvas_rightbut_proc = (FCallBack)create_lineobject;
    }
}

// 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);
}

void XAbstractGui::toggle_mouse_capture()
{
    XTextProperty titleProperty;
    Display       *dpy;
    const char    *title;
    char          **list;

    dpy = getDisplay();
    cursor_type = (cursor_type == FLX_DEFAULT_CURSOR) ?
                  FLX_INVISIBLE_CURSOR : FLX_DEFAULT_CURSOR;
    title = get_title();
    list  = const_cast<char **>(&title);

    if (XStringListToTextProperty(list, 1, &titleProperty) != 0)
    {
        XSetWMName(dpy, getWindow(FLX_MAIN), &titleProperty);
        XFree(titleProperty.value);
    }

    if (cursor_type == FLX_DEFAULT_CURSOR)
    {
        XUngrabPointer(dpy, CurrentTime);
    }
    else
    {
        unsigned int event_mask;

        event_mask = ButtonPressMask | ButtonReleaseMask |
                     EnterWindowMask | LeaveWindowMask | PointerMotionMask |
                     PointerMotionHintMask | Button1MotionMask |
                     Button2MotionMask | Button3MotionMask |
                     Button4MotionMask | Button5MotionMask |
                     ButtonMotionMask | KeymapStateMask;
        XGrabPointer(dpy, getWindow(), True, event_mask,
                     GrabModeAsync, GrabModeAsync, getWindow(),
                     None, CurrentTime);
    }

    set_cursor(cursor_type);
}

int main (void) {
  int i;
  

  Init_Timer1( );
  init_serial();                               /* Init UART                   */
  uart_init_0 ( );
  lcd_init();
  lcd_clear();
  lcd_print ("HSM AO Compare");
  set_cursor (0, 1);
  lcd_print ("EventDrivenSystem");

  for (i = 0; i < 10000; i++);       /* Wait for initial display           */
 

  comp_main();

 
 

}

/**
 * BrewStrengthMenu state handler
 **/
static QState MenuAO_BrewStrengthMenu(MenuAO *me, QEvent const *e)
{
    switch ( e->sig )
    {
    case Q_INIT_SIG:
    {
        return Q_HANDLED();
    }

    case Q_ENTRY_SIG:
    {
        // display brew strength menu (1st row of LCD)
        sprintf(output, "2: Strength %d", 2*me->brewStrength+2);
        lcd_clear();
        set_cursor(0, 0);
        lcd_print((unsigned char*)output);

        return Q_HANDLED();
    }

    case BUTTON_SHORTPRESS_SIG:
    {
        // short press > proceed to next submenu
        return Q_TRAN(&MenuAO_AlarmMenu);
    }

    case BUTTON_LONGPRESS_SIG:
    {
        return Q_TRAN(&MenuAO_ChangeBrewStrength);
    }

    case Q_EXIT_SIG:
    {
        return Q_HANDLED();
    }
    }

    return Q_SUPER(&MenuAO_Idle);
}

void
List::remove_local(uint32_t position)
{
	vector<ListItem *>::iterator iter;

	assert(position >= 0);
	assert(position < size());

	iter = items.begin() + position;
	assert(iter != items.end());
	assert(*iter);

	(*iter)->set_selected(false);
	delete *iter;
	items.erase(iter);

	if (cursor_position >= size()) {
		set_cursor(size() - 1);
	}

	set_selection_cache_valid(false);
}

/* --- Kernel entrypoint --- */
int
kernel_main()
{
    /*
     * Tell the kernel memory allocator which memory it can't use.
     * It already knows not to touch kernel image.
     */

    /* Everything above 16M */
    lmm_remove_free( &malloc_lmm, (void*)USER_MEM_START, -8 - USER_MEM_START );
    
    /* Everything below 1M */
    lmm_remove_free( &malloc_lmm, (void*)0, 0x100000 );

    if(handler_install() < 0) {
      return 0;
    }

    /*
     * initialize the PIC so that IRQs and
     * exception handlers don't overlap in the IDT.
     */
    pic_init( BASE_IRQ_MASTER_BASE, BASE_IRQ_SLAVE_BASE );

    clear_console();

    show_cursor();

    set_term_color(FGND_GREEN | BGND_BLACK);

    set_cursor(12, 34);

    putbytes("Hello World!\n", 13);

    while(1) {
    }

    return 0;
}

/*
 Print a char on the screen at col, row, or at cursor position
*/
void print_char(char nChar, int nCol, int nRow, char nAttribute)
{
	unsigned char * pVidMem = (unsigned char*) VIDEO_ADDRESS;

	if (!nAttribute)
	{
		nAttribute = WHITE_ON_BLACK;
	}

	int offset = 0;
	
//	if (nCol >= 0 && nRow >= 0)
//	{
//		offset = get_screen_offset(nCol, nRow);
//	}	
//	else
//	{
		offset = get_cursor();
//	}


	
	if (nChar == '\n')
	{
		int rows = offset / (2*MAX_COLS);
		offset = get_screen_offset(79, rows);
		offset += 2;
	}
	else
	{
		pVidMem[offset] = nChar;
		pVidMem[offset + 1] = nAttribute;
		offset += 2;		
	}
	
	offset = handle_scrolling(offset);
	
	set_cursor(offset);
}

/* Print a char on the screen at col , row , or at cursor position */
void print_char(const char character, int col, int row, char attribute_byte)
{
  /* Create a byte ( char ) pointer to the start of video memory */
  unsigned char volatile *vidmem = VIDEO_ADDRESS;
  /* If attribute byte is zero , assume the default style . */
  if (!attribute_byte) {
    attribute_byte = WHITE_ON_BLACK;
  }
  /* Get the video memory offset for the screen location */
  int offset;
  /* If col and row are non - negative , use them for offset . */
  if (col >= 0 && row >= 0) {
    offset = get_screen_offset(col, row);
    /* Otherwise , use the current cursor position . */
  } else {
    offset = get_cursor();
  }
  // If we see a newline character , set offset to the end of
  // current row , so it will be advanced to the first col
  // of the next row.
  if (character == '\n') {
    int rows = offset / (2 * MAX_COLS);
    offset = get_screen_offset(79, rows);
    // Otherwise , write the character and its attribute byte to
    // video memory at our calculated offset .
  } else {
    vidmem[offset] = character;
    vidmem[offset + 1] = attribute_byte;
  }
  // Update the offset to the next character cell , which is
  // two bytes ahead of the current cell .
  offset += 2;
  // Make scrolling adjustment , for when we reach the bottom
  // of the screen .
  offset = handle_scrolling(offset);
  // Update the cursor position on the screen device .
  set_cursor(offset);
}

int main( int argc, char *argv[] ){
    int x,y;
    int quit = 0;
    init_cursor();
    bClick = 0;
    if( SDL_Init( SDL_INIT_VIDEO ) < 0){
        exit( -1 );
    }

    if( !SDL_SetVideoMode( 320, 200, 0, 0 ) ){
        SDL_Quit();
        exit( -1 );
    }

    time(&last_mouse);
    SDL_EnableUNICODE( 1 );
    set_cursor(x, y);
    while( !quit ){
        check_time();
        while( SDL_PollEvent( &event ) ){
            switch( event.type ){
                case SDL_KEYDOWN:
                    PrintKeyInfo( &event.key );
                    break;
                case SDL_QUIT:
                    quit = 1;
                    break;
                default:
                    checkHold();
                    break;
            }
        }
        sleep(.05);

    }
    SDL_Quit();
    exit( 0 );
}

/**
 * Initialize the console of a certain tty.
 * 
 * @param tty  Whose console is to be initialized.
 *****************************************************************************/
PUBLIC void init_screen(TTY* tty)
{
	int nr_tty = tty - tty_table;
	CONSOLE * con = console_table + nr_tty;
	con->con_tty = tty;
	tty->tty_devwrite = cons_write;
	tty->tty_echo = out_char;
	kb_init(tty);
	/* 
	 * NOTE:
	 *   variables related to `position' and `size' below are
	 *   in WORDs, but not in BYTEs.
	 */
	int v_mem_size = V_MEM_SIZE >> 1; /* size of Video Memory */
	int size_per_con = v_mem_size / NR_CONSOLES;
	con->orig = nr_tty * size_per_con;
	con->con_size = size_per_con / SCR_WIDTH * SCR_WIDTH;
	con->cursor = con->crtc_start = con->orig;
	con->is_full = 0;

	tty->tty_dev = con;
	if (nr_tty == 0) {
		((CONSOLE *)tty->tty_dev)->cursor = disp_pos / 2;
		disp_pos = 0;
	}
	/*else {*/
		/* 
		 * `?' in this string will be replaced with 0, 1, 2, ...
		 */
	/*	const char prompt[] = "[tty #?]\n";

		const char * p = prompt;
		for (; *p; p++)
			out_char(tty, *p == '?' ? nr_tty + '0' : *p);
	}*/

	set_cursor(((CONSOLE *)tty->tty_dev)->cursor);
}

void ttext_box::handle_mouse_selection(tpoint mouse, const bool start_selection)
{
	mouse.x -= get_x();
	mouse.y -= get_y();
	// FIXME we don't test for overflow in width
	if(mouse.x < static_cast<int>(text_x_offset_)
	   || mouse.y < static_cast<int>(text_y_offset_)
	   || mouse.y >= static_cast<int>(text_y_offset_ + text_height_)) {
		return;
	}

	int offset = get_column_line(tpoint(mouse.x - text_x_offset_, mouse.y - text_y_offset_)).x;

	if(offset < 0) {
		return;
	}


	set_cursor(offset, !start_selection);
	update_canvas();
	set_is_dirty(true);
	dragging_ |= start_selection;
}

	/**
	 * @brief   Get the color of a particular pixel.
	 * @note    Optional.
	 * @note    If x,y is off the screen, the result is undefined.
	 *
	 * @param[in] x, y     The start of the text
	 *
	 * @notapi
	 */
	color_t GDISP_LLD(getpixelcolor)(coord_t x, coord_t y) {
		/* This routine is marked "DO NOT USE" in the original
		 *  GLCD driver. We just keep our GDISP_HARDWARE_READPIXEL
		 *  turned off for now.
		 */
		color_t color;

		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
			if (x < 0 || x >= GDISP.Width || y < 0 || y >= GDISP.Height) return 0;
		#endif

		aquire_bus();
		set_cursor(x, y);
		stream_start();

		color = lld_lcdReadData();
		color = lld_lcdReadData();

		stream_stop();
		release_bus();

		return color;
	}

void
cancel_place_lib_obj(int x, int y, int shift)
{
    /* if shift right-button, actually do a place in original position */
    if (shift) {
	place_lib_object_orig(x, y, shift);
	return;
    }
    reset_action_on();
    canvas_leftbut_proc = null_proc;
    canvas_middlebut_proc = null_proc;
    canvas_rightbut_proc = null_proc;
    canvas_locmove_proc = null_proc;
    canvas_ref_proc = null_proc;
    canvas_kbd_proc = null_proc;
    clear_mousefun();
    set_mousefun("","","", "", "", "");
    turn_off_current();
    set_cursor(arrow_cursor);
    put_draw(ERASE);
    /* remove it from the depths */
    remove_compound_depth(new_c);
}

static void
scroll (p_state *state)
{
  int x, y;

  for (x = 0; x < state->grid_width; x++)
    {
      p_cell *from = 0, *to = 0;
      for (y = 1; y < state->grid_height; y++)
        {
          from = &state->cells[state->grid_width * y     + x];
          to   = &state->cells[state->grid_width * (y-1) + x];

          if ((from->state == FLARE || from->state == NORMAL) &&
              !from->p_char->blank_p)
            {
              *to = *from;
              to->state = NORMAL;  /* should be FLARE?  Looks bad... */
            }
          else
            {
              if (to->state == FLARE || to->state == NORMAL)
                to->state = FADE;
            }

          to->changed = True;
        }

      to = from;
      if (to && (to->state == FLARE || to->state == NORMAL))
        {
          to->state = FADE;
          to->changed = True;
        }
    }
  set_cursor (state, True);
}

int
mail_eq (int argc, char **argv)
{
  msgset_t *list = NULL;
  size_t n;

  switch (argc)
    {
    case 1:
      n = get_cursor ();
      if (n == 0)
        mu_error (_("No applicable message"));
      else
        mu_printf ("%lu\n", (unsigned long) n);
      break;

    case 2:
      if (msgset_parse (argc, argv, MSG_NODELETED, &list) == 0)
	{
	  if (list->msg_part[0] <= total)
	    {
	      set_cursor (list->msg_part[0]);
	      mu_printf ("%lu\n",
				(unsigned long) list->msg_part[0]);
	    }
	  else
	    util_error_range (list->msg_part[0]);
	  msgset_free (list);
	}
      break;

    default:
      return 1;
    }
  
  return 0;
}

/**
 *******************************************************************************
 * @brief		time_display task		  
 * @param[in] 	pdata	A pointer to parameter passed to task.	 
 * @param[out] 	None  
 * @retval		None
 *		 
 * @details	    This task use to display time in LCD.
 *******************************************************************************
 */
void time_display(void *pdata)
{
	static unsigned char tim[3] = {0,0,0};
	static unsigned char *ptr;

	pdata = pdata;
	for (;;)
	{
		CoWaitForSingleFlag(time_display_flg,0);
		ptr = (unsigned char *)CoPendMail(mbox0,0,&errinfo[30]);

		CoEnterMutexSection(mut_lcd);
		if (tim[0] != *(ptr+0)) 
		{
			tim[0]   = *(ptr+0);
		   	chart[6] = tim[0]/10 + '0';
			chart[7] = tim[0]%10 + '0';			
		}
		if (tim[1] != *(ptr+1)) 
		{
			tim[1] 	 = *(ptr+1);
		   	chart[3] = tim[1]/10 + '0';
			chart[4] = tim[1]%10 + '0';
		}
		if (tim[2] != *(ptr+2)) 
		{
			tim[2] = *(ptr+2);
		   	chart[0] = tim[2]/10 + '0';
			chart[1] = tim[2]%10 + '0';
		}		

		set_cursor(7, 0);
		lcd_print (chart);

		CoLeaveMutexSection(mut_lcd);
	}		
}

static __inline void set_viewport(coord_t x, coord_t y, coord_t cx, coord_t cy) {
    /* HSA / HEA are 8 bit
     * VSA / VEA are 9 bit
     * use masks 0x00FF and 0x01FF to enforce this
     */

    switch(GDISP.Orientation) {
        case GDISP_ROTATE_0:
            write_reg(0x46, (((x + cx - 1) << 8) & 0xFF00 ) | 
                                      (x & 0x00FF));

            write_reg(0x48, y & 0x01FF);
            write_reg(0x47, (y + cy - 1) & 0x01FF);
            break;
        case GDISP_ROTATE_90:
            write_reg(0x46, (((y + cy - 1) << 8) & 0xFF00) |
                                      (y & 0x00FF));

            write_reg(0x48, x & 0x01FF);
            write_reg(0x47, (x + cx - 1) & 0x01FF);
            break;
        case GDISP_ROTATE_180:
            write_reg(0x46, (((GDISP_SCREEN_WIDTH - x - 1) & 0x00FF) << 8) |
                                      ((GDISP_SCREEN_WIDTH - (x + cx)) & 0x00FF));
            write_reg(0x48, (GDISP_SCREEN_HEIGHT - (y + cy)) & 0x01FF);
            write_reg(0x47, (GDISP_SCREEN_HEIGHT- y - 1) & 0x01FF);
            break;
        case GDISP_ROTATE_270:
            write_reg(0x46, (((GDISP_SCREEN_WIDTH - y - 1) & 0x00FF) << 8) |
                                      ((GDISP_SCREEN_WIDTH - (y + cy)) & 0x00FF));
            write_reg(0x48, (GDISP_SCREEN_HEIGHT - (x + cx)) & 0x01FF);
            write_reg(0x47, (GDISP_SCREEN_HEIGHT - x - 1) & 0x01FF);
            break;
    }   

    set_cursor(x, y);
}

static void flush_tty_out_cache(TTY * tty_p)
{
  char c;
  int line;
  while (tty_p->out_count > 0) {
    c = *(tty_p->out_tail_p);
    if (c == '\n') {
      line = tty_p->console_p->cursor / (80 * 2);
      tty_p->console_p->cursor = (line + 1) * (80 * 2);
    } else {
      xdisp_word_at(c|0x0F00, tty_p->console_p->cursor);
      tty_p->console_p->cursor += 2;
    }
    tty_p->out_tail_p ++ ;
    tty_p->out_count -- ;
    if (tty_p->out_tail_p == tty_p->tty_out_cache + TTY_CHAR_CACHE_SIZE)
      tty_p->out_tail_p = tty_p->tty_out_cache;


    if (is_current_console(tty_p->console_p))
      set_cursor(tty_p->console_p->cursor);
    
  }
}