自学教程：C++ GrStringDrawCentered函数代码示例

//*****************************************************************************//// Display the interrupt state on the display.  The currently active and pending// interrupts are displayed.////*****************************************************************************voidDisplayIntStatus(void){    uint32_t ui32Temp;    char pcBuffer[6];    //    // Display the currently active interrupts.    //    ui32Temp = HWREG(NVIC_ACTIVE0);    pcBuffer[0] = ' ';    pcBuffer[1] = (ui32Temp & 1) ? '1' : ' ';    pcBuffer[2] = (ui32Temp & 2) ? '2' : ' ';    pcBuffer[3] = (ui32Temp & 4) ? '3' : ' ';    pcBuffer[4] = ' ';    pcBuffer[5] = '/0';    GrStringDrawCentered(&g_sContext, pcBuffer, -1, 130, 150, 1);    //    // Display the currently pending interrupts.    //    ui32Temp = HWREG(NVIC_PEND0);    pcBuffer[1] = (ui32Temp & 1) ? '1' : ' ';    pcBuffer[2] = (ui32Temp & 2) ? '2' : ' ';    pcBuffer[3] = (ui32Temp & 4) ? '3' : ' ';    GrStringDrawCentered(&g_sContext, pcBuffer, -1, 270, 150, 1);    //    // Flush the display.    //    GrFlush(&g_sContext);}

//*****************************************************************************//// The touch screen driver calls this function to report all state changes.////*****************************************************************************static longWatchdogTouchCallback(unsigned long ulMessage, long lX,  long lY){    //    // If the screen is tapped, we will receive a PTR_DOWN then a PTR_UP    // message. We pick one (pretty much at random) to use as the trigger to    // stop feeding the watchdog.    //    if(ulMessage == WIDGET_MSG_PTR_UP)    {        //        // Let the user know that the tap has been registered and that the        // watchdog is being starved.        //        GrContextFontSet(&g_sContext, g_pFontCmss20);        GrStringDrawCentered(&g_sContext, "Watchdog is not being fed!", -1,                             GrContextDpyWidthGet(&g_sContext) / 2 ,                             (GrContextDpyHeightGet(&g_sContext) / 2), 1);        GrContextFontSet(&g_sContext, g_pFontCmss14);        GrStringDrawCentered(&g_sContext,                             "           System will reset shortly.           ",                             -1, GrContextDpyWidthGet(&g_sContext) / 2 ,                             (GrContextDpyHeightGet(&g_sContext) / 2) + 20, 1);        //        // Set the flag that tells the interrupt handler not to clear the        // watchdog interrupt.        //        g_bFeedWatchdog = false;    }    return(0);}

static void drawGridTime(tContext *pContext){  char buf[20];  uint8_t time[3];  time[0] = workout_time % 60;  time[1] = (workout_time / 60 ) % 60;  time[2] = workout_time / 3600;  GrContextForegroundSet(pContext, ClrBlack);  switch(window_readconfig()->sports_grid)  {  case GRID_3:    GrContextFontSet(pContext, (tFont*)&g_sFontExIcon16);    GrStringDraw(pContext, "i", 1, 10, 15, 0);    GrContextFontSet(pContext, &g_sFontGothic18);    GrStringDraw(pContext, datapoints[0].name, -1, 28, 15, 0);    GrContextFontSet(pContext, &g_sFontGothic28b);    sprintf(buf, "%02d:%02d:%02d", time[2], time[1], time[0]);    GrStringDrawCentered(pContext, buf, -1, LCD_WIDTH/2, 50, 0);    break;  case GRID_4:  case GRID_5:    GrContextFontSet(pContext, &g_sFontGothic28b);    sprintf(buf, "%02d:%02d:%02d", time[2], time[1], time[0]);    GrStringDrawCentered(pContext, buf, -1, LCD_WIDTH/2, 18, 0);    break;  }}

//*****************************************************************************//// This function is called when the select button is pressed.////*****************************************************************************static int32_tSelectButtonPressed(void){    //    // Find the X center of the display    //    int32_t i32CenterX = GrContextDpyWidthGet(&g_sContext) / 2;    //    // Let the user know that the button has been pressed and that the    // watchdog is being starved.    //    GrStringDrawCentered(&g_sContext, "Starving", -1, i32CenterX, 14, 1);    GrStringDrawCentered(&g_sContext, "Watchdog", -1, i32CenterX, 24, 1);    GrStringDrawCentered(&g_sContext, "System", -1, i32CenterX, 36, 1);    GrStringDrawCentered(&g_sContext, "   will   ", -1, i32CenterX, 46, 1);    GrStringDrawCentered(&g_sContext, "reset ...", -1, i32CenterX, 56, 1);    //    // Set the flag that tells the interrupt handler not to clear the    // watchdog interrupt.    //    g_bFeedWatchdog = false;    return(0);}

void Timer1IntHandler(void){	//debugled(10);    ROM_TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT);    //debugled(3);    int angle=0;    if(max2>0 && max1>0 && abs(maxi1-maxi2)<PULSE_SAMPLE)    {    //float dt=abs(maxi1-maxi2)/SAMPLING_FREQUENCY;    //angle=asin(dt*lambda/distance)*180/3.1412;    angle=abs(maxi1-maxi2);    }    //debugled(3);    acount++;    //rcount=0;    //ROM_IntMasterDisable();	snprintf(text,sizeof(text),"%3ld,%3ld",rcount,g_ulADCCount);    GrContextForegroundSet(&sDisplayContext, ClrDarkBlue);    GrRectFill(&sDisplayContext, &sRect1);    GrContextForegroundSet(&sDisplayContext, ClrWhite);    //GrRectDraw(&sDisplayContext, &sRect1);    GrContextFontSet(&sDisplayContext, g_pFontCm12);    GrStringDrawCentered(&sDisplayContext,text, -1,                         GrContextDpyWidthGet(&sDisplayContext) / 2, 10, 0);    GrContextForegroundSet(&sDisplayContext, ClrDarkBlue);    GrRectFill(&sDisplayContext, &sRect2);    GrContextForegroundSet(&sDisplayContext, ClrWhite);    sprintf(text,"%4d,%4d",buffer_increment,rem);    GrContextFontSet(&sDisplayContext, g_pFontCm12/*g_pFontFixed6x8*/);    GrStringDrawCentered(&sDisplayContext, text, -1,                         GrContextDpyWidthGet(&sDisplayContext) / 2,                         ((GrContextDpyHeightGet(&sDisplayContext) - 24) / 2) + 24,                         0);//    GrFlush(&sDisplayContext);    max1=0;    max2=0;    res=0;    res1=0;    maxi1=0;    maxi2=0;    buffer_index=0;    for(i=0;i<buffer_size;i++)    {    	buffer[0][i]=0;    	buffer[1][i]=0;    }    i=0;    j=0;    ind2=buffer_index-buffer_increment+1;}

void PrintSettings_DateTime_NotAllowed(tContext *context) {    GrStringDrawCentered(context, "Cannot edit", AUTO_STRING_LENGTH, 47, 27, OPAQUE_TEXT);    GrStringDrawCentered(context, "while insulin", AUTO_STRING_LENGTH, 47, 38, OPAQUE_TEXT);    GrStringDrawCentered(context, "delivery is", AUTO_STRING_LENGTH, 47, 49, OPAQUE_TEXT);    GrStringDrawCentered(context, "in progress", AUTO_STRING_LENGTH, 47, 60, OPAQUE_TEXT);    LoadMiddleButton( context , "OK");}

//*****************************************************************************//// Draws a toggle button.////*****************************************************************************voidDrawToggle(const tButtonToggle *psButton, bool bOn){    tRectangle sRect;    int16_t i16X, i16Y;    //    // Copy the data out of the bounds of the button.    //    sRect = psButton->sRectButton;    GrContextForegroundSet(&g_sContext, ClrLightGrey);    GrRectFill(&g_sContext, &psButton->sRectContainer);    //    // Copy the data out of the bounds of the button.    //    sRect = psButton->sRectButton;    GrContextForegroundSet(&g_sContext, ClrDarkGray);    GrRectFill(&g_sContext, &psButton->sRectButton);    if(bOn) {        sRect.i16XMin += 2;        sRect.i16YMin += 2;        sRect.i16XMax -= 15;        sRect.i16YMax -= 2;    } else {        sRect.i16XMin += 15;        sRect.i16YMin += 2;        sRect.i16XMax -= 2;        sRect.i16YMax -= 2;    }    GrContextForegroundSet(&g_sContext, ClrLightGrey);    GrRectFill(&g_sContext, &sRect);    GrContextFontSet(&g_sContext, &g_sFontCm16);    GrContextForegroundSet(&g_sContext, ClrBlack);    GrContextBackgroundSet(&g_sContext, ClrLightGrey);    i16X = sRect.i16XMin + ((sRect.i16XMax - sRect.i16XMin) / 2);    i16Y = sRect.i16YMin + ((sRect.i16YMax - sRect.i16YMin) / 2);    if(bOn) {        GrStringDrawCentered(&g_sContext, psButton->pcOn, -1, i16X, i16Y,                             true);    } else {        GrStringDrawCentered(&g_sContext, psButton->pcOff, -1, i16X, i16Y,                             true);    }    if(psButton->pcLabel) {        GrStringDraw(&g_sContext, psButton->pcLabel, -1,                     psButton->sRectButton.i16XMax + 2,                     psButton->sRectButton.i16YMin + 6,                     true);    }}

//*****************************************************************************//// The touch screen driver calls this function to report all state changes.////*****************************************************************************static int32_tWatchdogTouchCallback(uint32_t ui32Message, int32_t i32X, int32_t i32Y){    //    // If the screen is tapped, we will receive a PTR_DOWN then a PTR_UP    // message.  Use PTR_UP as the trigger to stop feeding the watchdog.    //    if(ui32Message == WIDGET_MSG_PTR_UP)    {        //        // See if the left or right side of the screen was touched.        //        if(i32X <= (GrContextDpyWidthGet(&g_sContext) / 2))        {            //            // Let the user know that the tap has been registered and that the            // watchdog0 is being starved.            //            GrContextFontSet(&g_sContext, g_psFontCmss20);            GrContextForegroundSet(&g_sContext, ClrRed);            GrStringDrawCentered(&g_sContext,                                 "Watchdog 0 starved, reset shortly", -1,                                 GrContextDpyWidthGet(&g_sContext) / 2 ,                                 (GrContextDpyHeightGet(&g_sContext) / 2) + 40,                                 1);            GrContextForegroundSet(&g_sContext, ClrWhite);            //            // Set the flag that tells the interrupt handler not to clear the            // watchdog0 interrupt.            //            g_bFeedWatchdog0 = false;        }        else        {            //            // Let the user know that the tap has been registered and that the            // watchdog1 is being starved.            //            GrContextFontSet(&g_sContext, g_psFontCmss20);            GrContextForegroundSet(&g_sContext, ClrRed);            GrStringDrawCentered(&g_sContext,                                 "Watchdog 1 starved, reset shortly", -1,                                 GrContextDpyWidthGet(&g_sContext) / 2 ,                                 (GrContextDpyHeightGet(&g_sContext) / 2) + 60,                                 1);            GrContextForegroundSet(&g_sContext, ClrWhite);            //            // Set the flag that tells the interrupt handler not to clear the            // watchdog1 interrupt.            //            g_bFeedWatchdog1 = false;        }    }    return(0);}

//*****************************************************************************//// Draw a string with a white drop shadow at a give position on the display.////*****************************************************************************voidCenteredStringWithShadow(const tFont *pFont, char *pcString, short sX, short sY,                         tBoolean bOpaque){    GrContextFontSet(&g_sScreenContext, pFont);    GrContextForegroundSet(&g_sScreenContext, SHADOW_COLOR);    GrStringDrawCentered(&g_sScreenContext, pcString, -1, sX+1, sY+1, bOpaque);    GrContextForegroundSet(&g_sScreenContext, HIGHLIGHT_COLOR);    GrStringDrawCentered(&g_sScreenContext, pcString, -1, sX, sY, false);}

void PrintBolusCreateNotAllowed( tContext *context ){	 // Draw top and bottom banner and buttons	LoadLeftButton( context , "BACK");	// Menu options	GrStringDrawCentered(context, "Bolus Preset", AUTO_STRING_LENGTH, 47, 31, OPAQUE_TEXT);	GrStringDrawCentered(context, "Creation", AUTO_STRING_LENGTH, 47, 44, OPAQUE_TEXT);	GrStringDrawCentered(context, "not Allowed", AUTO_STRING_LENGTH, 47, 57, OPAQUE_TEXT);}

void PrintNoBasProf(tContext *context){    // Draw top and bottom banner and buttons	LoadLeftButton( context , "BACK");	//LoadMiddleButton("SEL");	//LoadRightButton("");	// Menu options	GrStringDrawCentered(context, "No Basal", AUTO_STRING_LENGTH, 47, 31, OPAQUE_TEXT);	GrStringDrawCentered(context, "Profile", AUTO_STRING_LENGTH, 47, 44, OPAQUE_TEXT);	GrStringDrawCentered(context, "Available", AUTO_STRING_LENGTH, 47, 57, OPAQUE_TEXT);}

//*****************************************************************************//// Initialize the file system.////*****************************************************************************voidfs_init(void){    FRESULT fresult;    DIR g_sDirObject;    //    // Initialze the flag to indicate that we are disabled.    //    g_bFatFsEnabled = false;    //    // Initialize and mount the Fat File System.    //    fresult = f_mount(0, &g_sFatFs);    if(fresult != FR_OK)    {        return;    }    //    // Open the root directory for access.    //    fresult = f_opendir(&g_sDirObject, "/");    //    // Flag and display which file system we are using.    //    GrStringDrawCentered(&g_sContext, "Web Server Using", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 180, false);    if(fresult == FR_OK)    {        //        // Indicate and display that we are using the SD file system.        //        g_bFatFsEnabled = true;        GrStringDrawCentered(&g_sContext, "SDCard File System", -1,                             GrContextDpyWidthGet(&g_sContext) / 2, 200,                             false);    }    else    {        //        // Indicate and display that we are using the internal file system.        //        g_bFatFsEnabled = false;        GrStringDrawCentered(&g_sContext, "Internal File System", -1,                             GrContextDpyWidthGet(&g_sContext) / 2, 200,                             false);    }}

//*****************************************************************************//// This hook is called by SafeRTOS when an error is detected.////*****************************************************************************static voidSafeRTOSErrorHook(xTaskHandle xHandleOfTaskWithError,                  signed portCHAR *pcNameOfTaskWithError,                  portBASE_TYPE xErrorCode){    tContext sContext;    //    // A fatal SafeRTOS error was detected, so display an error message.    //    GrContextInit(&sContext, &g_sKitronix320x240x16_SSD2119);    GrContextForegroundSet(&sContext, ClrRed);    GrContextBackgroundSet(&sContext, ClrBlack);    GrContextFontSet(&sContext, g_pFontCm20);    GrStringDrawCentered(&sContext, "Fatal SafeRTOS error!", -1,                         GrContextDpyWidthGet(&sContext) / 2,                         (((GrContextDpyHeightGet(&sContext) - 24) / 2) +                          24), 1);    //    // This function can not return, so loop forever.  Interrupts are disabled    // on entry to this function, so no processor interrupts will interrupt    // this loop.    //    while(1)    {    }}

/*******************************************************************************																			  ** /brief  Shows the status string on the color STN display.                   **																			  ** /param psContext is a pointer to the graphics context representing the      **        display.                                                             **																		      ** /param pcStatus is a pointer to the string to be shown.                     **																		      ** /return none.                                                               **                                                                             *******************************************************************************/void DisplayStatus(tContext *psContext, char *pcStatus){    tRectangle rectLine;    int lY;    /* Calculate the Y coordinate of the top left of the character cell       for our line of text.    */    lY = (GrContextDpyHeightGet(psContext) / 8) -         (GrFontHeightGet(TEXT_FONT) / 2);    /* Determine the bounding rectangle for this line of text. We add 4 pixels       to the height just to ensure that we clear a couple of pixels above and       below the line of text.    */    rectLine.sXMin = 0;    rectLine.sXMax = GrContextDpyWidthGet(psContext) - 1;    rectLine.sYMin = lY;    rectLine.sYMax = lY + GrFontHeightGet(TEXT_FONT) + 3;    /* Clear the line with black. */        GrContextForegroundSet(&g_sContext, ClrBlack);    GrRectFill(psContext, &rectLine);        /* Draw the new status string */        GrContextForegroundSet(&g_sContext, ClrWhite);    GrStringDrawCentered(psContext, pcStatus, -1,                         GrContextDpyWidthGet(psContext) / 2,                         GrContextDpyHeightGet(psContext) / 8 , false);}

//*****************************************************************************//// This hook is called by FreeRTOS when an stack overflow error is detected.////*****************************************************************************voidvApplicationStackOverflowHook(xTaskHandle *pxTask, signed char *pcTaskName){    tContext sContext;    //    // A fatal FreeRTOS error was detected, so display an error message.    //    GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);    GrContextForegroundSet(&sContext, ClrRed);    GrContextBackgroundSet(&sContext, ClrBlack);    GrContextFontSet(&sContext, g_psFontCm20);    GrStringDrawCentered(&sContext, "Fatal FreeRTOS error!", -1,                         GrContextDpyWidthGet(&sContext) / 2,                         (((GrContextDpyHeightGet(&sContext) - 24) / 2) +                          24), 1);    //    // This function can not return, so loop forever.  Interrupts are disabled    // on entry to this function, so no processor interrupts will interrupt    // this loop.    //    while(1)    {    }}

//*****************************************************************************//// Shows the status string on the color STN display.//// /param psContext is a pointer to the graphics context representing the// display.// /param pcStatus is a pointer to the string to be shown.//// This implementation assumes we are using a 6 pixel wide font, giving us// space for 16 characters across the display.////*****************************************************************************voidDisplayStatus(tContext *psContext, char *pcStatus){    tRectangle sRectLine;    //    // Determine the bounding rectangle for this line of text.    //    sRectLine.i16XMin = 0;    sRectLine.i16XMax = GrContextDpyWidthGet(psContext) - 1;    sRectLine.i16YMin = GrContextDpyHeightGet(psContext) - (TEXT_HEIGHT + 2);    sRectLine.i16YMax = sRectLine.i16YMin + GrFontHeightGet(TEXT_FONT) + 1;    //    // Clear the line with black.    //    GrContextForegroundSet(&g_sContext, ClrBlack);    GrRectFill(psContext, &sRectLine);    //    // Draw the new status string    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrStringDrawCentered(psContext, pcStatus, -1,                         GrContextDpyWidthGet(psContext) / 2,                         sRectLine.i16YMin + (TEXT_HEIGHT / 2), false);}

//*****************************************************************************//// Display a status string on the LCD and also transmit it via the serial port.////*****************************************************************************voidUpdateStatus(char *pcStatus){    tRectangle sRect;    //    // Dump that status string to the serial port.    //    UARTprintf("%s/n", pcStatus);    //    // Clear any previous status message.    //    sRect.i16XMin = 0;    sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.i16YMin = STATUS_Y - 16;    sRect.i16YMax = STATUS_Y + 16;    GrContextForegroundSet(&g_sContext, ClrBlack);    GrRectFill(&g_sContext, &sRect);    //    // Display the new status string.    //    GrContextFontSet(&g_sContext, g_psFontCmss20);    GrContextForegroundSet(&g_sContext, ClrWhite);    GrStringDrawCentered(&g_sContext, pcStatus, -1,                         GrContextDpyWidthGet(&g_sContext) / 2, STATUS_Y, 0);}

static void onDraw(tContext *pContext){  char buf[30];  GrContextForegroundSet(pContext, ClrBlack);#if defined(PRODUCT_W002) || defined(PRODUCT_W004)	GrRectFill(pContext, &client_clip);#else    GrRectFill(pContext, &fullscreen_clip);#endif  GrContextForegroundSet(pContext, ClrWhite);  if (state == WALK)  {#if defined(PRODUCT_W002) || defined(PRODUCT_W004)    sprintf(buf, "%d", ped_get_steps());    drawItem(pContext, 0, ICON_STEPS, "Step Taken", buf);        sprintf(buf, "%02d:%02d", ped_get_time() / 60, ped_get_time() % 60);    drawItem(pContext, 1, ICON_TIME, "Walk Time", buf);    uint16_t cals = ped_get_calorie() / 100 / 1000;    sprintf(buf, "%d", cals);    drawItem(pContext, 2, ICON_CALORIES, "Calories", buf);        uint16_t dist = ped_get_distance() / 100;    sprintf(buf, "%dm", dist);    drawItem(pContext, 3, ICON_DISTANCE, "Distance", buf);        #else  	    sprintf(buf, "%d", ped_get_steps());    drawItem(pContext, 0, ICON_STEPS, "Steps", buf);    uint16_t cals = ped_get_calorie() / 100 / 1000;    sprintf(buf, "%d", cals);    drawItem(pContext, 1, ICON_CALORIES, "Calories", buf);    uint16_t dist = ped_get_distance() / 100;    sprintf(buf, "%dm", dist);    drawItem(pContext, 2, ICON_DISTANCE, "Distance", buf);    sprintf(buf, "%02d:%02d", ped_get_time() / 60, ped_get_time() % 60);    drawItem(pContext, 3, ICON_TIME, "Active", buf);#endif    // draw progress#if defined(PRODUCT_W002) || defined(PRODUCT_W004)#else    uint16_t goal = window_readconfig()->goal_steps;    uint32_t steps = ped_get_steps();    if (steps < goal)      window_progress(pContext, 5 + 4 * LINEMARGIN, steps * 100 / goal);    else      window_progress(pContext, 5 + 4 * LINEMARGIN, 100);    sprintf(buf, "%d%% of %d", (uint16_t)(steps * 100 / goal), goal);    GrContextForegroundSet(pContext, ClrWhite);    GrStringDrawCentered(pContext, buf, -1, LCD_WIDTH/2, 148, 0);#endif      }}

//*****************************************************************************//// This function updates the status area of the screen.  It uses the current// state of the application to print the status area.////*****************************************************************************voidUpdateStatus(char *pcString){    //    // Write the current state to the bottom of screen.    //    GrStringDrawCentered(&g_sContext, pcString, -1, 160, 78, true);}

//*****************************************************************************//// Shows the status string on the display.//// /param psContext is a pointer to the graphics context representing the// display.// /param pi8Status is a pointer to the string to be shown.////*****************************************************************************voidDisplayStatus(tContext *psContext, char *pcStatus){    //    // Clear the line with black.    //    GrContextForegroundSet(&g_sContext, ClrBlack);    GrStringDrawCentered(psContext, "                ", -1,                         GrContextDpyWidthGet(psContext) / 2, 16, true);    //    // Draw the new status string    //    DEBUG_PRINT("%s/n", pcStatus);    GrContextForegroundSet(&g_sContext, ClrWhite);    GrStringDrawCentered(psContext, pcStatus, -1,                         GrContextDpyWidthGet(psContext) / 2, 16, true);}

void LoadLeftButton( tContext *context, const char * text){	GrRectFill( context, &myRectangleBotLeft);	GrContextForegroundSet( context, ClrWhite);	GrContextBackgroundSet( context, ClrBlack);	GrStringDrawCentered( context, text, AUTO_STRING_LENGTH, 14, 88, TRANSPARENT_TEXT);	GrContextForegroundSet( context, ClrBlack);	GrContextBackgroundSet( context, ClrWhite);}

static void DisplayGR(void){    tRectangle sRect;    // Fill the top 24 rows of the screen with blue to create the banner.    sRect.sXMin = 0;    sRect.sYMin = 0;    sRect.sXMax = GrContextDpyWidthGet(&sContext) - 1;    sRect.sYMax = 23;    GrContextForegroundSet(&sContext, ClrDarkBlue);    GrRectFill(&sContext, &sRect);    // Put a white box around the banner.    GrContextForegroundSet(&sContext, ClrWhite);    GrRectDraw(&sContext, &sRect);    // Put the application name in the middle of the banner.    GrContextFontSet(&sContext, &g_sFontCm20);    GrStringDrawCentered(&sContext, "grlib demo", -1,                         GrContextDpyWidthGet(&sContext) / 2, 8, 0);						 	GrStringDrawCentered(&sContext, "Touch here to proceed ", -1,                         GrContextDpyWidthGet(&sContext) / 2, 140, 0);						     // Initialize the sound driver.    // Add the title block and the previous and next buttons to the widget tree.    WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sPrevious);    WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sTitle);    WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sNext);    // Add the first panel to the widget tree.    g_ulPanel = 0;    WidgetAdd(WIDGET_ROOT, (tWidget *)g_psPanels);    CanvasTextSet(&g_sTitle, g_pcPanelNames[0]);    // Issue the initial paint request to the widgets.    //WidgetPaint(WIDGET_ROOT);	WidgetMessageQueueAdd(WIDGET_ROOT, WIDGET_MSG_PAINT, 0, 0, 0, 0);}

//*****************************************************************************//// Print "Hello World!" to the display on the Intelligent Display Module.////*****************************************************************************intmain(void){    tContext sContext;    uint32_t ui32SysClock;    //    // Run from the PLL at 120 MHz.    //    ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |                                           SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |                                           SYSCTL_CFG_VCO_480), 120000000);    //    // Configure the device pins.    //    PinoutSet();    //    // Initialize the display driver.    //    Kentec320x240x16_SSD2119Init(ui32SysClock);    //    // Initialize the graphics context.    //    GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);    //    // Draw the application frame.    //    FrameDraw(&sContext, "hello");    //    // Say hello using the Computer Modern 40 point font.    //    GrContextFontSet(&sContext, g_psFontCm40);    GrStringDrawCentered(&sContext, "Hello World!", -1,                         GrContextDpyWidthGet(&sContext) / 2,                         ((GrContextDpyHeightGet(&sContext) - 32) / 2) + 24,                         0);    //    // Flush any cached drawing operations.    //    GrFlush(&sContext);    //    // We are finished. Hang around doing nothing.    //    while(1)    {    }}

void main(void){    CAP_BUTTON keypressed_state;    int countdownCount;    State state = STATE_WELCOME;    // Stop WDT    WDTCTL = WDTPW | WDTHOLD;		// Stop watchdog timer    //Perform initializations (see peripherals.c)    configTouchPadLEDs();    configDisplay();    configCapButtons();    GrClearDisplay(&g_sContext);    GrStringDrawCentered(&g_sContext, "MSP430 H3R0", AUTO_STRING_LENGTH, 51, 32,                         TRANSPARENT_TEXT);    GrFlush(&g_sContext);    /* Monitor Capacitive Touch Pads in endless "forever" loop */    while(1)    {        switch(state)        {        case STATE_WELCOME:            if(checkButtons() & BUTTON1)            {                state = STATE_COUNTDOWN;            }            break;        case STATE_COUNTDOWN:            centerText("3");            configLED1_3(BIT3);            wait(COUNTDOWN_TIMER);            centerText("2");            configLED1_3(BIT2);            wait(COUNTDOWN_TIMER);            centerText("1");            configLED1_3(BIT1);            wait(COUNTDOWN_TIMER);            centerText("GO!");            configLED1_3(BIT3 | BIT2 | BIT1);            wait(COUNTDOWN_TIMER);            //TODO: next state            break;        }    }}

static void onDraw(tContext *pContext){  GrContextForegroundSet(pContext, ClrBlack);  GrRectFill(pContext, &client_clip);  GrContextForegroundSet(pContext, ClrWhite);    GrContextFontSet(pContext, &g_sFontGothic18b);  GrStringDrawCentered(pContext, "Firmware Upgrade", -1, 72, 60, 0);  if (progress == PROGRESS_FINISH)  	GrStringDrawCentered(pContext, "Done", -1, 72, 96, 0);  else if (progress == PROGRESS_TIMEOUT)  	GrStringDrawCentered(pContext, "Failed due to timeout", -1, 72, 96, 0);  else  	GrStringDrawCentered(pContext, "Don't do any operation", -1, 72, 96, 0);  if (progress == PROGRESS_FINISH)  	window_button(pContext, KEY_ENTER, "Reboot");  else if (progress == PROGRESS_TIMEOUT)  	window_button(pContext, KEY_ENTER, "Exit");  else	window_progress(pContext, 110, progress);}

/* * Bounder set */void Bounder_set(void){    // the whole boundler    sRect.i16XMin = 0;    sRect.i16YMin = 0;    sRect.i16XMax = GrContextDpyWidthGet(&context) - 1;    sRect.i16YMax = 239;    GrContextForegroundSet(&context, ClrSeashell);    GrRectFill(&context, &sRect);    int i,j;    for ( i = 0; i < 4; ++i) {        for ( j = 0; j < 4; ++j) {            sRect.i16XMin = 64+i*48 +1;//16            sRect.i16YMin = 24+j*48 +1;//64            sRect.i16XMax = 112+i*48 -1;            sRect.i16YMax = 72+j*48 -1;            GrContextForegroundSet(&context, ClrSkyBlue);            GrRectFill(&context, &sRect);        }    }    GrContextForegroundSet(&context, ClrSkyBlue);    GrContextFontSet(&context, &g_sFontCm20);    GrStringDrawCentered(&context, "Total  256", -1,                         GrContextDpyWidthGet(&context) / 2, 8, 0);    GrContextFontSet(&context, &g_sFontCm20);    GrStringDrawCentered(&context, "Project2 ^_^ Jack&Peter", -1,                         GrContextDpyWidthGet(&context) / 2, 225, 0);}

void window_button(tContext *pContext, uint8_t key, const char* text){  	long forecolor, backcolor;  	if (key & 0x80)  	{    		forecolor = ClrBlack;    		backcolor = ClrWhite;    		key &= ~(0x80);  	}  	else  	{    		forecolor = ClrWhite;    		backcolor = ClrBlack;  	}  	  	GrContextFontSet(pContext, &g_sFontGothic18);  // draw black box  	if (text)  	{    		const tRectangle *rect = &button_rect[key];    		GrContextForegroundSet(pContext, forecolor);    		GrRectFill(pContext, rect);    		// draw triagle    		for(int i = 0; i <= (rect->sYMax - rect->sYMin) /2 ; i++)    		{      			if (rect->sXMin < 20)      			{			        GrLineDrawH(pContext, rect->sXMin - i, rect->sXMin, rect->sYMin + i);			        GrLineDrawH(pContext, rect->sXMin - i, rect->sXMin, rect->sYMax - i);      			}      			else      			{        			GrLineDrawH(pContext, rect->sXMax, rect->sXMax + i, rect->sYMin + i);        			GrLineDrawH(pContext, rect->sXMax, rect->sXMax + i, rect->sYMax - i);      			}    		}    		GrContextForegroundSet(pContext, backcolor);    		GrStringDrawCentered(pContext, text, -1, (rect->sXMin + rect->sXMax) /2, (rect->sYMin + rect->sYMax) /2, 0);  	}  	else  	{    		GrContextForegroundSet(pContext, backcolor);    		GrRectFill(pContext, &button_rect[key]);  	}}

//*****************************************************************************//// The function that is called when the help text canvas is painted to the// screen.////*****************************************************************************static voidOnPaint(tWidget *pWidget, tContext *pContext){    unsigned long ulIdx;    tRectangle sRect;    //    // Prepare the drawing context.    //    GrContextForegroundSet(pContext, ClrWhite);    GrContextFontSet(pContext, g_pFontFixed6x8);    //    // Loop through the ten lines of the display.    //    for(ulIdx = 0; ulIdx < 10; ulIdx++)    {        //        // See if this line of help text is a heading.        //        if(g_ppcHelpText[g_ulDelta + ulIdx][0] == '/001')        {            //            // Draw a shaded rectangle across this entire line of the display.            //            sRect.sXMin = 0;            sRect.sYMin = (ulIdx * 8) + 16;            sRect.sXMax = 127;            sRect.sYMax = sRect.sYMin + 7;            GrContextForegroundSet(pContext, ClrSelected);            GrRectFill(pContext, &sRect);            //            // Draw this line of text centered on the display.            //            GrContextForegroundSet(pContext, ClrWhite);            GrStringDrawCentered(pContext,                                 g_ppcHelpText[g_ulDelta + ulIdx] + 1, -1, 63,                                 (ulIdx * 8) + 19, 0);        }        else        {            //            // Draw this line of text on the display.            //            GrStringDraw(pContext, g_ppcHelpText[g_ulDelta + ulIdx], -1, 0,                         (ulIdx * 8) + 16, 0);        }    }}

//*****************************************************************************//// Update one of the status boxes at the bottom of the screen.////*****************************************************************************static voidUpdateStatusBox(tRectangle *psRect, const char *pcString, bool bActive){    uint32_t ui32TextColor;    //    // Change the status box to green for active devices.    //    if(bActive)    {        GrContextForegroundSet(&g_sContext, ClrOrange);        ui32TextColor = ClrBlack;    }    else    {        GrContextForegroundSet(&g_sContext, ClrBlack);        ui32TextColor = ClrWhite;    }    //    // Draw the background box.    //    GrRectFill(&g_sContext, psRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    //    // Draw the box border.    //    GrRectDraw(&g_sContext, psRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ui32TextColor);    //    // Unknown device is currently connected.    //    GrStringDrawCentered(&g_sContext, pcString, -1,                         psRect->i16XMin + (BUTTON_WIDTH / 2),                         psRect->i16YMin + 8, false);}

//*****************************************************************************//// Initialize the display.  This function is specific to the  EK-LM4F232 board// and contains nothing directly relevant to the timer configuration or// operation.////*****************************************************************************voidInitDisplay(void){    tRectangle sRect;    //    // Initialize the display driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context and find the middle X coordinate.    //    GrContextInit(&g_sContext, &g_sCFAL96x64x16);    //    // Fill the top part of the screen with blue to create the banner.    //    sRect.i16XMin = 0;    sRect.i16YMin = 0;    sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.i16YMax = 9;    GrContextForegroundSet(&g_sContext, ClrDarkBlue);    GrRectFill(&g_sContext, &sRect);    //    // Change foreground for white text.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_psFontFixed6x8);    GrStringDrawCentered(&g_sContext, "edge-count", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 4, 0);    //    // Initialize timer status display.    //    GrContextFontSet(&g_sContext, g_psFontFixed6x8);    GrStringDraw(&g_sContext, "Countdown:", -1, 8, 26, 0);    GrStringDraw(&g_sContext, "Interrupts:", -1, 8, 36, 0);}