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

int main(void){   SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ);   Kentec320x240x16_SSD2119Init();   GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);   ClrScreen();   GrImageDraw(&sContext, g_pui8Image, 0, 0);   GrFlush(&sContext);   SysCtlDelay(SysCtlClockGet());   // Later lab steps go between here   ClrScreen();   sRect.i16XMin = 1;   sRect.i16YMin = 1;   sRect.i16XMax = 318;   sRect.i16YMax = 238;   GrContextForegroundSet(&sContext, ClrRed);   GrContextFontSet(&sContext, &g_sFontCmss30b);   GrStringDraw(&sContext, "Texas", -1, 110, 2, 0);   GrStringDraw(&sContext, "Instruments", -1, 80, 32, 0);   GrStringDraw(&sContext, "Graphics", -1, 100, 62, 0);   GrStringDraw(&sContext, "Lab", -1, 135, 92, 0);   GrContextForegroundSet(&sContext, ClrWhite);   GrRectDraw(&sContext, &sRect);   GrFlush(&sContext);   SysCtlDelay(SysCtlClockGet());   GrContextForegroundSet(&sContext, ClrYellow);   GrCircleFill(&sContext, 80, 182, 50);   sRect.i16XMin = 160;   sRect.i16YMin = 132;   sRect.i16XMax = 312;   sRect.i16YMax = 232;   GrContextForegroundSet(&sContext, ClrGreen);   GrRectDraw(&sContext, &sRect);   SysCtlDelay(SysCtlClockGet());   // and here   ClrScreen();   while(1)   {   }}

/*******************************************************************************																			  ** /brief Draw a horizontal meter at a given position on the display and fill  **         fill it with green.                                                 **                                                                             ** /param psContext is a pointer to the graphics context representing the      **        display.                                                             **                                                                             ** /param lX    X - Cordinate.                                                 **                                                                             ** /param lY    Y - Cordinate.                                                 **																		      ** /return none.                                                               **                                                                             *******************************************************************************/void DrawBufferMeter(tContext *psContext, int lX, int lY){    tRectangle sRect;    int lCorrectedY;        /* Correct the Y coordinate so that the meter is centered on the same line       as the text caption to its left.    */    lCorrectedY = lY - (BUFFER_METER_HEIGHT - TEXT_HEIGHT) ;    /* Determine the bounding rectangle of the meter. */        sRect.sXMin = lX;    sRect.sXMax = lX + BUFFER_METER_WIDTH - 1;    sRect.sYMin = lCorrectedY;    sRect.sYMax = lCorrectedY + BUFFER_METER_HEIGHT - 1;    /* Fill the meter with green to indicate empty */        GrContextForegroundSet(psContext, ClrGreen);    GrRectFill(psContext, &sRect);    /* Put a white box around the meter. */        GrContextForegroundSet(psContext, ClrWhite);    GrRectDraw(psContext, &sRect);}

//*****************************************************************************//// Draw the whole menu onto the display.////*****************************************************************************static tBooleanMenuDisplay(tMenu *psMenu){    unsigned long ulLoop;    tRectangle rectMenu;    //    // Erase the rectangle of the display that will contain the menu.    //    rectMenu.sXMin = MENU_LEFT;    rectMenu.sXMax = MENU_RIGHT;    rectMenu.sYMin = MENU_TOP;    rectMenu.sYMax = MENU_BOTTOM(psMenu->ucNumGroups);    GrContextForegroundSet(&g_sContext, MENU_BACKGROUND_COLOR);    GrRectFill(&g_sContext, &rectMenu);    GrContextForegroundSet(&g_sContext, MENU_BORDER_COLOR);    GrRectDraw(&g_sContext, &rectMenu);    //    // Draw a rectangle around the edge of the menu area.    //    //    // Draw each of the buttons corresponding to the groups.    //    for(ulLoop = 0; ulLoop < psMenu->ucNumGroups; ulLoop++)    {        MenuDrawGroupButton(psMenu, ulLoop,         (ulLoop == psMenu->ucFocusGroup) ? &g_psFocusColors : &g_psBtnColors);    }    return(true);}

//*****************************************************************************//// Draw a horizontal meter at a given position on the display and fill it// with green.////*****************************************************************************voidDrawBufferMeter(tContext *psContext, int32_t i32X, int32_t i32Y){    tRectangle sRect;    int32_t i32CorrectedY;    //    // Correct the Y coordinate so that the meter is centered on the same line    // as the text caption to its left.    //    i32CorrectedY = i32Y - ((BUFFER_METER_HEIGHT - TEXT_HEIGHT) / 2);    //    // Determine the bounding rectangle of the meter.    //    sRect.i16XMin = i32X;    sRect.i16XMax = i32X + BUFFER_METER_WIDTH - 1;    sRect.i16YMin = i32CorrectedY;    sRect.i16YMax = i32CorrectedY + BUFFER_METER_HEIGHT - 1;    //    // Fill the meter with green to indicate empty    //    GrContextForegroundSet(psContext, ClrGreen);    GrRectFill(psContext, &sRect);    //    // Put a white box around the meter.    //    GrContextForegroundSet(psContext, ClrWhite);    GrRectDraw(psContext, &sRect);}

//*****************************************************************************//// This function will update the small mouse button indicators in the status// bar area of the screen.  This can be called on its own or it will be called// whenever UpdateStatus() is called as well.////*****************************************************************************voidUpdateButtons(void){    tRectangle sRect, sRectInner;    int iButton;    //    // Initialize the button indicator position.    //    sRect.i16XMin = GrContextDpyWidthGet(&g_sContext) - 36;    sRect.i16YMin = GrContextDpyHeightGet(&g_sContext) - 18;    sRect.i16XMax = sRect.i16XMin + 6;    sRect.i16YMax = sRect.i16YMin + 8;    sRectInner.i16XMin = sRect.i16XMin + 1;    sRectInner.i16YMin = sRect.i16YMin + 1;    sRectInner.i16XMax = sRect.i16XMax - 1;    sRectInner.i16YMax = sRect.i16YMax - 1;    //    // Check all three buttons.    //    for(iButton = 0; iButton < 3; iButton++)    {        //        // Draw the button indicator red if pressed and black if not pressed.        //        if(g_ui32Buttons & (1 << iButton))        {            GrContextForegroundSet(&g_sContext, ClrRed);        }        else        {            GrContextForegroundSet(&g_sContext, ClrBlack);        }        //        // Draw the back of the  button indicator.        //        GrRectFill(&g_sContext, &sRectInner);        //        // Draw the border on the button indicator.        //        GrContextForegroundSet(&g_sContext, ClrWhite);        GrRectDraw(&g_sContext, &sRect);        //        // Move to the next button indicator position.        //        sRect.i16XMin += 8;        sRect.i16XMax += 8;        sRectInner.i16XMin += 8;        sRectInner.i16XMax += 8;    }}

//*****************************************************************************//// This function will update the mouse button indicators in the status// bar area of the screen.////*****************************************************************************static voidUpdateButtons(void){    tRectangle sRect, sRectInner;    int iButton;    //    // Initialize the button indicator position.    //    sRect.i16XMin = BUTTON_MIN_X;    sRect.i16YMin = STATUS_MIN_Y;    sRect.i16XMax = sRect.i16XMin + BUTTON_WIDTH;    sRect.i16YMax = sRect.i16YMin + BUTTON_HEIGHT ;    sRectInner.i16XMin = sRect.i16XMin + 1;    sRectInner.i16YMin = sRect.i16YMin + 1;    sRectInner.i16XMax = sRect.i16XMax - 1;    sRectInner.i16YMax = sRect.i16YMax - 1;    //    // Check all three buttons.    //    for(iButton = 0; iButton < 3; iButton++)    {        //        // Draw the button indicator red if pressed and black if not pressed.        //        if(g_sStatus.ui32Buttons & (1 << iButton))        {            GrContextForegroundSet(&g_sContext, ClrRed);        }        else        {            GrContextForegroundSet(&g_sContext, ClrBlack);        }        //        // Draw the back of the  button indicator.        //        GrRectFill(&g_sContext, &sRectInner);        //        // Draw the border on the button indicator.        //        GrContextForegroundSet(&g_sContext, ClrWhite);        GrRectDraw(&g_sContext, &sRect);        //        // Move to the next button indicator position.        //        sRect.i16XMin += BUTTON_WIDTH;        sRect.i16XMax += BUTTON_WIDTH;        sRectInner.i16XMin += BUTTON_WIDTH;        sRectInner.i16XMax += BUTTON_WIDTH;    }}

static void draw_usbmouse_slide(){    const tRectangle rect1 = {50, 48, 430, 228};    const tRectangle rect2 = {51, 49, 429, 227};        GrImageDraw(&sContextUsbMouse, iconHome, 0, 0);    GrImageDraw(&sContextUsbMouse, iconBack, 0, HEIGHT - 60);    GrImageDraw(&sContextUsbMouse, iconNext, WIDTH - 60, HEIGHT - 60);    /* draw special trackpad graphics instead of standard slide layout */    GrContextForegroundSet(&sContextUsbMouse, ClrDarkBlue);    GrRectDraw(&sContextUsbMouse, &rect1);    GrRectDraw(&sContextUsbMouse, &rect2);        GrContextForegroundSet(&sContextUsbMouse, ClrDarkGray);    GrContextFontSet(&sContextUsbMouse, &g_sFontCmss22b);    GrStringDrawCentered(&sContextUsbMouse, "Touch Pad", -1, 240, 140, 0);        GrImageDraw(&sContextUsbMouse, (unsigned char *)usbMouseButtons, 50, 238);}

void window_volume(tContext *pContext, long lX, long lY, int total, int current){  for (int i = 0; i <= total; i++)  {    tRectangle rect = {lX + i * 10, lY - 3 - i * 3, lX + 7 + i * 10, lY};    if (i <= current)    {      // solid      GrRectFill(pContext, &rect);    }    else    {      GrRectDraw(pContext, &rect);    }  }}

//*****************************************************************************//// This function updates the status area of the screen.  It uses the current// state of the application to print the status bar.////*****************************************************************************voidUpdateStatus(char *pcString, tBoolean bClrBackground){    tRectangle sRect;    //    // Fill the bottom rows of the screen with blue to create the status area.    //    sRect.sXMin = 0;    sRect.sYMin = GrContextDpyHeightGet(&g_sContext) -                  DISPLAY_BANNER_HEIGHT - 1;    sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.sYMax = sRect.sYMin + DISPLAY_BANNER_HEIGHT;    //    //    //    GrContextBackgroundSet(&g_sContext, DISPLAY_BANNER_BG);    if(bClrBackground)    {        //        // Draw the background of the banner.        //        GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG);        GrRectFill(&g_sContext, &sRect);        //        // Put a white box around the banner.        //        GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_FG);        GrRectDraw(&g_sContext, &sRect);    }    //    // Write the current state to the left of the status area.    //    GrContextFontSet(&g_sContext, g_pFontFixed6x8);    //    // Update the status on the screen.    //    if(pcString != 0)    {        GrStringDraw(&g_sContext, pcString, -1, 4, sRect.sYMin + 4, 1);    }}

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

//*****************************************************************************//// Set up the OLED Graphical Display////*****************************************************************************voidInitGraphics(void){    tRectangle sRect;    //    // Initialize the display driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context.    //    GrContextInit(&g_sContext, &g_sCFAL96x64x16);    //    // Fill the top 24 rows 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);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_psFontFixed6x8);    GrStringDrawCentered(&g_sContext, "CAN Example", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 4, 0);    //    // Flush any cached drawing operations.    //    GrFlush(&g_sContext);}

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

/** * Show the Text for the Bootscreen */void vShowBootText(char* text){	/* Header Rectangle */	tRectangle sRect;	if (g_sContext.pDisplay == 0)	{		GrContextInit(&g_sContext, DISPLAY_DRIVER);	}	//	// Fill the top 24 rows of the screen with blue to create the banner.	//	sRect.sXMin = 0;	sRect.sYMin = 0;	sRect.sXMax = GrContextDpyWidthGet(&g_sContext);	sRect.sYMax = GrContextDpyHeightGet(&g_sContext);	GrContextForegroundSet(&g_sContext, DISPLAY_BOOT_SCREEN_BACKGROUND_COLOR);	GrContextBackgroundSet(&g_sContext, DISPLAY_BOOT_SCREEN_BACKGROUND_COLOR);	GrRectFill(&g_sContext, &sRect);	//	// Put a white box around the banner.	//	GrRectDraw(&g_sContext, &sRect);	GrContextForegroundSet(&g_sContext, DISPLAY_BOOT_SCREEN_COLOR);	//	// Put the application name in the middle of the banner.	//	GrContextFontSet(&g_sContext, DISPLAY_BOOT_SCREEN_FONT);	GrStringDrawCentered(&g_sContext, text, -1,			GrContextDpyWidthGet(&g_sContext) / 2, GrContextDpyHeightGet(&g_sContext) / 2, 0);}

//*****************************************************************************//// Draw a string of text centered within an outlined rectangle.//// /param pszText is a pointer to the zero-terminated ASCII string which will// be displayed within the given rectangle.// /param prectOutline points to the rectangle within which the test is to be// displayed.// /param psColors points to a structure defining the colors to be used for// the background, outline and text.//// This function draws a text string centered within a given rectangle.  The// rectangle is filled with a given color and outlined in another color prior// to drawing the text.//// /return None.////*****************************************************************************voidDrawTextBox(const char *pszText, tRectangle *prectOutline,            tOutlineTextColors *psColors){    //    // Set the clipping region to guard against text strings that are too    // long for the supplied rectangle.    //    GrContextClipRegionSet(&g_sContext, prectOutline);    //    // Draw the background area    //    GrContextForegroundSet(&g_sContext, psColors->ulBackground);    GrRectFill(&g_sContext, prectOutline);    //    // Draw the border    //    GrContextForegroundSet(&g_sContext, psColors->ulBorder);    GrRectDraw(&g_sContext, prectOutline);    //    // Draw the text    //    GrContextForegroundSet(&g_sContext, psColors->ulText);    GrStringDrawCentered(&g_sContext, (char *)pszText, strlen(pszText),                         (prectOutline->sXMax + prectOutline->sXMin) / 2,                         (prectOutline->sYMax + prectOutline->sYMin) / 2,                         false);    //    // Remove our clipping area.    //    GrContextClipRegionSet(&g_sContext, &g_sRectDisplay);}

//*****************************************************************************//// This is the main application entry function.////*****************************************************************************intmain(void){    uint32_t ui32TxCount, ui32RxCount, ui32Fullness, ui32SysClock, ui32PLLRate;    tRectangle sRect;    char pcBuffer[16];#ifdef USE_ULPI    uint32_t ui32Setting;#endif    //    // Set the system clock to run at 120MHz from the PLL.    //    ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |                                           SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |                                           SYSCTL_CFG_VCO_480), 120000000);    //    // Configure the device pins.    //    PinoutSet();#ifdef USE_ULPI    //    // Switch the USB ULPI Pins over.    //    USBULPIPinoutSet();    //    // Enable USB ULPI with high speed support.    //    ui32Setting = USBLIB_FEATURE_ULPI_HS;    USBOTGFeatureSet(0, USBLIB_FEATURE_USBULPI, &ui32Setting);    //    // Setting the PLL frequency to zero tells the USB library to use the    // external USB clock.    //    ui32PLLRate = 0;#else    //    // Save the PLL rate used by this application.    //    ui32PLLRate = 480000000;#endif    //    // Enable the system tick.    //    ROM_SysTickPeriodSet(ui32SysClock / TICKS_PER_SECOND);    ROM_SysTickIntEnable();    ROM_SysTickEnable();    //    // Not configured initially.    //    g_ui32Flags = 0;    //    // Initialize the display driver.    //    Kentec320x240x16_SSD2119Init(ui32SysClock);    //    // Initialize the graphics context.    //    GrContextInit(&g_sContext, &g_sKentec320x240x16_SSD2119);    //    // Draw the application frame.    //    FrameDraw(&g_sContext, "usb-dev-serial");    //    // Fill the top 15 rows of the screen with blue to create the banner.    //    sRect.i16XMin = 0;    sRect.i16YMin = 0;    sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.i16YMax = 23;    GrContextForegroundSet(&g_sContext, ClrDarkBlue);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Show the various static text elements on the color STN display.    //    GrContextFontSet(&g_sContext, TEXT_FONT);    GrStringDraw(&g_sContext, "Tx bytes:", -1, 8, 80, false);    GrStringDraw(&g_sContext, "Tx buffer:", -1, 8, 105, false);//.........这里部分代码省略.........

//*****************************************************************************//// Handles paint requests for the primitives canvas widget.////*****************************************************************************voidOnPrimitivePaint(tWidget *pWidget, tContext *pContext){    unsigned int ulIdx;    tRectangle sRect;    //    // Draw a vertical sweep of lines from red to green.    //    for(ulIdx = 0; ulIdx <= 8; ulIdx++)    {        GrContextForegroundSet(pContext,                               (((((10 - ulIdx) * 255) / 10) << ClrRedShift) |                                (((ulIdx * 255) / 10) << ClrGreenShift)));        GrLineDraw(pContext, 115+X_OFFSET, 120+Y_OFFSET, 5+X_OFFSET, 120+Y_OFFSET - (11 * ulIdx));    }    //    // Draw a horizontal sweep of lines from green to blue.    //    for(ulIdx = 1; ulIdx <= 10; ulIdx++)    {        GrContextForegroundSet(pContext,                               (((((10 - ulIdx) * 255) / 10) <<                                 ClrGreenShift) |                                (((ulIdx * 255) / 10) << ClrBlueShift)));        GrLineDraw(pContext, 115+X_OFFSET, 120+Y_OFFSET, 5 + (ulIdx * 11)+X_OFFSET, 29+Y_OFFSET);    }    //    // Draw a filled circle with an overlapping circle.    //    GrContextForegroundSet(pContext, ClrBrown);    GrCircleFill(pContext, 185+X_OFFSET, 69+Y_OFFSET, 40);    GrContextForegroundSet(pContext, ClrSkyBlue);    GrCircleDraw(pContext, 205+X_OFFSET, 99+Y_OFFSET, 30);    //    // Draw a filled rectangle with an overlapping rectangle.    //    GrContextForegroundSet(pContext, ClrSlateGray);    sRect.sXMin = 20+X_OFFSET;    sRect.sYMin = 100+Y_OFFSET;    sRect.sXMax = 75+X_OFFSET;    sRect.sYMax = 160+Y_OFFSET;    GrRectFill(pContext, &sRect);    GrContextForegroundSet(pContext, ClrSlateBlue);    sRect.sXMin += 40;    sRect.sYMin += 40;    sRect.sXMax += 30;    sRect.sYMax += 28;    GrRectDraw(pContext, &sRect);    //    // Draw a piece of text in fonts of increasing size.    //    GrContextForegroundSet(pContext, ClrSilver);    GrContextFontSet(pContext, &g_sFontCm14);    GrStringDraw(pContext, "Strings", -1, 125+X_OFFSET, 110+Y_OFFSET, 0);    GrContextFontSet(pContext, &g_sFontCm18);    GrStringDraw(pContext, "Strings", -1, 145+X_OFFSET, 124+Y_OFFSET, 0);    GrContextFontSet(pContext, &g_sFontCm22);    GrStringDraw(pContext, "Strings", -1, 165+X_OFFSET, 142+Y_OFFSET, 0);    GrContextFontSet(pContext, &g_sFontCm24);    GrStringDraw(pContext, "Strings", -1, 185+X_OFFSET, 162+Y_OFFSET, 0);    //    // Draw an image.    //    GrImageDraw(pContext, g_TILogo, 240+X_OFFSET, 60+Y_OFFSET);}

//*****************************************************************************//// This is the main application entry function.////*****************************************************************************intmain(void){    unsigned long ulTxCount;    unsigned long ulRxCount;    tRectangle sRect;    char pcBuffer[16];    //    // Set the clocking to run from the PLL at 50MHz    //    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |                       SYSCTL_XTAL_8MHZ);#ifdef DEBUG    //    // Configure the relevant pins such that UART0 owns them.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);    ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);    //    // Open UART0 for debug output.    //    UARTStdioInit(0);#endif    //    // Not configured initially.    //    g_bUSBConfigured = false;    //    // Initialize the display driver.    //    Formike128x128x16Init();    //    // Turn on the backlight.    //    Formike128x128x16BacklightOn();    //    // Initialize the graphics context.    //    GrContextInit(&g_sContext, &g_sFormike128x128x16);    //    // Fill the top 15 rows of the screen with blue to create the banner.    //    sRect.sXMin = 0;    sRect.sYMin = 0;    sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.sYMax = 14;    GrContextForegroundSet(&g_sContext, ClrDarkBlue);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_pFontFixed6x8);    GrStringDrawCentered(&g_sContext, "usb_dev_bulk", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 7, 0);    //    // Show the various static text elements on the color STN display.    //    GrContextFontSet(&g_sContext, TEXT_FONT);    GrStringDraw(&g_sContext, "Tx bytes:", -1, 8, 70, false);    GrStringDraw(&g_sContext, "Rx bytes:", -1, 8, 90, false);    //    // Configure the USB mux on the board to put us in device mode.  We pull    // the relevant pin high to do this.    //    ROM_SysCtlPeripheralEnable(USB_MUX_GPIO_PERIPH);    ROM_GPIOPinTypeGPIOOutput(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN);    ROM_GPIOPinWrite(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN, USB_MUX_SEL_DEVICE);    //    // Enable the system tick.    //    ROM_SysTickPeriodSet(SysCtlClockGet() / SYSTICKS_PER_SECOND);    ROM_SysTickIntEnable();    ROM_SysTickEnable();    //    // Show the application name on the display and UART output.    ////.........这里部分代码省略.........

void main(void){    // Stop WDT    WDTCTL = WDTPW + WDTHOLD;    // Initialize the boards    boardInit();    clockInit();    timerInit();    flashInit();    __bis_SR_register(GIE);    // Set up the LCD    LCDInit();    GrContextInit(&g_sContext, &g_sharp96x96LCD);    GrContextForegroundSet(&g_sContext, ClrBlack);    GrContextBackgroundSet(&g_sContext, ClrWhite);    GrContextFontSet(&g_sContext, &g_sFontFixed6x8);    GrClearDisplay(&g_sContext);    GrFlush(&g_sContext);    // Intro Screen    GrStringDrawCentered(&g_sContext,                          "How to use",                          AUTO_STRING_LENGTH,                          48,                          15,                          TRANSPARENT_TEXT);    GrStringDrawCentered(&g_sContext,                          "the MSP430",                          AUTO_STRING_LENGTH,                          48,                          35,                          TRANSPARENT_TEXT);    GrStringDraw(&g_sContext,                  "Graphics Library",                  AUTO_STRING_LENGTH,                  1,                  51,                  TRANSPARENT_TEXT);    GrStringDrawCentered(&g_sContext,                          "Primitives",                          AUTO_STRING_LENGTH,                          48,                          75,                          TRANSPARENT_TEXT);    GrFlush(&g_sContext);    Delay_long();    GrClearDisplay(&g_sContext);    // Draw pixels and lines on the display    GrStringDrawCentered(&g_sContext,                          "Draw Pixels",                          AUTO_STRING_LENGTH,                          48,                          5,                          TRANSPARENT_TEXT);    GrStringDrawCentered(&g_sContext,                          "& Lines",                          AUTO_STRING_LENGTH,                          48,                          15,                          TRANSPARENT_TEXT);    GrPixelDraw(&g_sContext, 30, 30);    GrPixelDraw(&g_sContext, 30, 32);    GrPixelDraw(&g_sContext, 32, 32);    GrPixelDraw(&g_sContext, 32, 30);    GrLineDraw(&g_sContext, 35, 35, 90, 90);    GrLineDraw(&g_sContext, 5, 80, 80, 20);    GrLineDraw(&g_sContext,                0,                GrContextDpyHeightGet(&g_sContext) - 1,                GrContextDpyWidthGet(&g_sContext) - 1,                GrContextDpyHeightGet(&g_sContext) - 1);    GrFlush(&g_sContext);    Delay_long();    GrClearDisplay(&g_sContext);    // Draw circles on the display    GrStringDraw(&g_sContext,                  "Draw Circles",                  AUTO_STRING_LENGTH,                  10,                  5,                  TRANSPARENT_TEXT);    GrCircleDraw(&g_sContext, 30, 70, 20);    GrCircleFill(&g_sContext, 60, 50, 30);    GrFlush(&g_sContext);    Delay_long();    GrClearDisplay(&g_sContext);    // Draw rectangles on the display    GrStringDrawCentered(&g_sContext,                          "Draw Rectangles",                          AUTO_STRING_LENGTH,                          48,                          5,                          TRANSPARENT_TEXT);    GrRectDraw(&g_sContext, &myRectangle1);//.........这里部分代码省略.........

//*****************************************************************************//// This is the main application entry function.////*****************************************************************************intmain(void){    uint32_t ui32TxCount;    uint32_t ui32RxCount;    tRectangle sRect;    char pcBuffer[16];    uint32_t ui32Fullness;    //    // Enable lazy stacking for interrupt handlers.  This allows floating-point    // instructions to be used within interrupt handlers, but at the expense of    // extra stack usage.    //    ROM_FPULazyStackingEnable();    //    // Set the clocking to run from the PLL at 50MHz    //    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |                       SYSCTL_XTAL_16MHZ);    //    // Configure the required pins for USB operation.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);    ROM_GPIOPinConfigure(GPIO_PG4_USB0EPEN);    ROM_GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4);    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);    ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7);    ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);    //    // Erratum workaround for silicon revision A1.  VBUS must have pull-down.    //    if(CLASS_IS_BLIZZARD && REVISION_IS_A1)    {        HWREG(GPIO_PORTB_BASE + GPIO_O_PDR) |= GPIO_PIN_1;    }    //    // Not configured initially.    //    g_bUSBConfigured = false;    //    // Initialize the display driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context.    //    GrContextInit(&g_sContext, &g_sCFAL96x64x16);    //    // Fill the top 15 rows 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);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_psFontFixed6x8);    GrStringDrawCentered(&g_sContext, "usb-dev-serial", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 4, 0);    //    // Show the various static text elements on the color STN display.    //    GrStringDraw(&g_sContext, "Tx #",-1, 0, 12, false);    GrStringDraw(&g_sContext, "Tx buf", -1, 0, 22, false);    GrStringDraw(&g_sContext, "Rx #", -1, 0, 32, false);    GrStringDraw(&g_sContext, "Rx buf", -1, 0, 42, false);    DrawBufferMeter(&g_sContext, 40, 22);    DrawBufferMeter(&g_sContext, 40, 42);    //    // Enable the UART that we will be redirecting.    //    ROM_SysCtlPeripheralEnable(USB_UART_PERIPH);    ////.........这里部分代码省略.........

//*****************************************************************************////! Draws a radio button widget.//!//! /param psWidget is a pointer to the radio button widget to be drawn.//! /param bClick is a boolean that is /b true if the paint request is a result//! of a pointer click and /b false if not.//!//! This function draws a radio button widget on the display.  This is called//! in response to a /b #WIDGET_MSG_PAINT message.//!//! /return None.////*****************************************************************************static voidRadioButtonPaint(tWidget *psWidget, uint32_t bClick){    tRadioButtonWidget *pRadio;    tContext sCtx;    int32_t i32X, i32Y;    //    // Check the arguments.    //    ASSERT(psWidget);    //    // Convert the generic widget pointer into a radio button widget pointer.    //    pRadio = (tRadioButtonWidget *)psWidget;    //    // Initialize a drawing context.    //    GrContextInit(&sCtx, psWidget->psDisplay);    //    // Initialize the clipping region based on the extents of this radio    // button.    //    GrContextClipRegionSet(&sCtx, &(psWidget->sPosition));    //    // See if the radio button fill style is selected.    //    if((pRadio->ui16Style & RB_STYLE_FILL) && !bClick)    {        //        // Fill the radio button with the fill color.        //        GrContextForegroundSet(&sCtx, pRadio->ui32FillColor);        GrRectFill(&sCtx, &(psWidget->sPosition));    }    //    // See if the radio button outline style is selected.    //    if((pRadio->ui16Style & RB_STYLE_OUTLINE) && !bClick)    {        //        // Outline the radio button with the outline color.        //        GrContextForegroundSet(&sCtx, pRadio->ui32OutlineColor);        GrRectDraw(&sCtx, &(psWidget->sPosition));    }    //    // Draw the radio button.    //    i32X = psWidget->sPosition.i16XMin + (pRadio->ui16CircleSize / 2) + 2;    i32Y = (psWidget->sPosition.i16YMin +            ((psWidget->sPosition.i16YMax - psWidget->sPosition.i16YMin) / 2));    if(!bClick)    {        GrContextForegroundSet(&sCtx, pRadio->ui32OutlineColor);        GrCircleDraw(&sCtx, i32X, i32Y, pRadio->ui16CircleSize / 2);    }    //    // Select the foreground color based on whether or not the radio button is    // selected.    //    if(pRadio->ui16Style & RB_STYLE_SELECTED)    {        GrContextForegroundSet(&sCtx, pRadio->ui32OutlineColor);    }    else    {        GrContextForegroundSet(&sCtx, pRadio->ui32FillColor);    }    //    // Fill in the radio button.    //    GrCircleFill(&sCtx, i32X, i32Y, (pRadio->ui16CircleSize / 2) - 2);    //    // See if the radio button text or image style is selected.    //    if((pRadio->ui16Style & (RB_STYLE_TEXT | RB_STYLE_IMG)) && !bClick)//.........这里部分代码省略.........

//*****************************************************************************////! Paints the clock set widget on the display.//!//! /param psWidget is a pointer to the clock setting widget to be drawn.//!//! This function draws the date and time fields of the clock setting widget//! onto the display.  One of the fields can be highlighted.  This is//! called in response to a /b WIDGET_MSG_PAINT message.//!//! /return None.////*****************************************************************************static voidClockSetPaint(tWidget *psWidget){    tClockSetWidget *psClockWidget;    tContext sContext;    tRectangle sRect, sRectSel;    struct tm *psTime;    char pcBuf[8];    int32_t i32X, i32Y, i32Width, i32Height;    uint32_t ui32Idx, ui32FontHeight, ui32FontWidth, ui32SelWidth;    //    // Check the arguments.    //    ASSERT(psWidget);    ASSERT(psWidget->psDisplay);    //    // Convert the generic widget pointer into a clock set widget pointer.    //    psClockWidget = (tClockSetWidget *)psWidget;    ASSERT(psClockWidget->psTime);    //    // Get pointer to the time structure    //    psTime = psClockWidget->psTime;    //    // Initialize a drawing context.    //    GrContextInit(&sContext, psWidget->psDisplay);    //    // Initialize the clipping region based on the extents of this widget.    //    GrContextClipRegionSet(&sContext, &(psWidget->sPosition));    //    // Set the font for the context, and get font height and width - they    // are used a lot later.    //    GrContextFontSet(&sContext, psClockWidget->psFont);    ui32FontHeight = GrFontHeightGet(psClockWidget->psFont);    ui32FontWidth = GrFontMaxWidthGet(psClockWidget->psFont);    //    // Fill the widget with the background color.    //    GrContextForegroundSet(&sContext, psClockWidget->ui32BackgroundColor);    GrRectFill(&sContext, &sContext.sClipRegion);    //    // Draw a border around the widget    //    GrContextForegroundSet(&sContext, psClockWidget->ui32ForegroundColor);    GrContextBackgroundSet(&sContext, psClockWidget->ui32BackgroundColor);    GrRectDraw(&sContext, &sContext.sClipRegion);    //    // Compute a rectangle for the screen title.  Put it at the top of    // the widget display, and sized to be the height of the font, plus    // a few pixels of space.    //    sRect.i16XMin = sContext.sClipRegion.i16XMin;    sRect.i16XMax = sContext.sClipRegion.i16XMax;    sRect.i16YMin = sContext.sClipRegion.i16YMin;    sRect.i16YMax = ui32FontHeight * 2;    GrRectDraw(&sContext, &sRect);    //    // Print a title for the widget    //    GrContextFontSet(&sContext, psClockWidget->psFont);    GrStringDrawCentered(&sContext, "CLOCK SET", -1,                         (1 + sRect.i16XMax - sRect.i16XMin) / 2,                         (1 + sRect.i16YMax - sRect.i16YMin) / 2, 1);    //    // Reset the rectangle to cover the non-title area of the display    //    sRect.i16YMin = sRect.i16YMax + 1;    sRect.i16YMax = sContext.sClipRegion.i16YMax;    //    // Compute the width and height of the area remaining for showing the    // clock fields.//.........这里部分代码省略.........

//*****************************************************************************//// Demonstrate the use of the USB stick update example.////*****************************************************************************intmain(void){    unsigned long ulCount;    tContext sContext;    tRectangle sRect;    //    // Enable lazy stacking for interrupt handlers.  This allows floating-point    // instructions to be used within interrupt handlers, but at the expense of    // extra stack usage.    //    ROM_FPULazyStackingEnable();    //    // Set the system clock to run at 50MHz from the PLL.    //    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |                       SYSCTL_XTAL_16MHZ);    //    // Initialize the display driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context.    //    GrContextInit(&sContext, &g_sCFAL96x64x16);    //    // 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 = 9;    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_pFontFixed6x8);    GrStringDrawCentered(&sContext, "usb-stick-demo", -1,                         GrContextDpyWidthGet(&sContext) / 2, 4, 0);    //    // Indicate what is happening.    //    GrStringDrawCentered(&sContext, "Press the", -1,                         GrContextDpyWidthGet(&sContext) / 2, 20, 0);    GrStringDrawCentered(&sContext, "select button to", -1,                         GrContextDpyWidthGet(&sContext) / 2, 30, 0);    GrStringDrawCentered(&sContext, "start the USB", -1,                         GrContextDpyWidthGet(&sContext) / 2, 40, 0);    GrStringDrawCentered(&sContext, "stick updater.", -1,                         GrContextDpyWidthGet(&sContext) / 2, 50, 0);    //    // Flush any cached drawing operations.    //    GrFlush(&sContext);    //    // Enable the GPIO module which the select button is attached to.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOM);    //    // Enable the GPIO pin to read the user button.    //    ROM_GPIODirModeSet(GPIO_PORTM_BASE, GPIO_PIN_4, GPIO_DIR_MODE_IN);    ROM_GPIOPadConfigSet(GPIO_PORTM_BASE, GPIO_PIN_4, GPIO_STRENGTH_2MA,                         GPIO_PIN_TYPE_STD_WPU);    //    // Wait for the pullup to take effect or the next loop will exist too soon.    //    SysCtlDelay(1000);    //    // Wait until the select button has been pressed for ~40ms (in order to    // debounce the press).    //    ulCount = 0;    while(1)    {        ////.........这里部分代码省略.........

//*****************************************************************************//// This is the main loop that runs the application.////*****************************************************************************intmain(void){    tRectangle sRect;    //    // Set the clocking to run directly from the crystal.    //    SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |                   SYSCTL_XTAL_8MHZ);    //    // Enable the peripherals used by this example.    //    SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);    //    // Configure the relevant pins such that UART0 owns them.    //    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);    GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);    //    // Open UART0 for debug output.    //    UARTStdioInit(0);    //    // Enable the USB mux GPIO.    //    SysCtlPeripheralEnable(USB_MUX_GPIO_PERIPH);    //    // The LM3S3748 board uses a USB mux that must be switched to use the    // host connector and not the device connector.    //    GPIOPinTypeGPIOOutput(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN);    GPIOPinWrite(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN, USB_MUX_SEL_HOST);    //    // Configure the power pins for host controller.    //    GPIOPinTypeUSBDigital(GPIO_PORTH_BASE, GPIO_PIN_3 | GPIO_PIN_4);    //    // Initialize the display driver.    //    Formike128x128x16Init();    //    // Turn on the backlight.    //    Formike128x128x16BacklightOn();    //    // Initialize the graphics context.    //    GrContextInit(&g_sContext, &g_sFormike128x128x16);    //    // Fill the top 15 rows of the screen with blue to create the banner.    //    sRect.sXMin = 0;    sRect.sYMin = 0;    sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.sYMax = DISPLAY_BANNER_HEIGHT;    GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_pFontFixed6x8);    GrStringDrawCentered(&g_sContext, "usb_host_keyboard", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 7, 0);    //    // Calculate the number of characters that will fit on a line.    // Make sure to leave a small border for the text box.    //    g_ulCharsPerLine = (GrContextDpyWidthGet(&g_sContext) - 4) /                        GrFontMaxWidthGet(g_pFontFixed6x8);    //    // Calculate the number of lines per usable text screen.  This requires    // taking off space for the top and bottom banners and adding a small bit    // for a border.    ////.........这里部分代码省略.........

//*****************************************************************************//// This is the main loop that runs the application.////*****************************************************************************intmain(void){    tRectangle sRect;    uint_fast32_t ui32Retcode;    //    // Set the system clock to run at 50MHz from the PLL.    //    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |                       SYSCTL_XTAL_16MHZ);    //    // Configure SysTick for a 100Hz interrupt.  The FatFs driver wants a 10 ms    // tick.    //    ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 100);    ROM_SysTickEnable();    ROM_SysTickIntEnable();    //    // Configure and enable uDMA    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);    SysCtlDelay(10);    ROM_uDMAControlBaseSet(&sDMAControlTable[0]);    ROM_uDMAEnable();    //    // Initialize the display driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context.    //    GrContextInit(&g_sContext, &g_sCFAL96x64x16);    //    // Fill the top 15 rows of the screen with blue to create the banner.    //    sRect.i16XMin = 0;    sRect.i16YMin = 0;    sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.i16YMax = DISPLAY_BANNER_HEIGHT - 1;    GrContextForegroundSet(&g_sContext, ClrDarkBlue);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_psFontFixed6x8);    GrStringDrawCentered(&g_sContext, "usb-dev-msc", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 5, 0);    //    // Initialize the idle timeout and reset all flags.    //    g_ui32IdleTimeout = 0;    g_ui32Flags = 0;    //    // Initialize the state to idle.    //    g_eMSCState = MSC_DEV_DISCONNECTED;    //    // Draw the status bar and set it to idle.    //    UpdateStatus("Disconnected", 1);    //    // Enable the USB controller.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);    //    // Set the USB pins to be controlled by the USB controller.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);    ROM_GPIOPinConfigure(GPIO_PG4_USB0EPEN);    ROM_GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4);    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);    ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7);    ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);    //    // Set the USB stack mode to Device mode with VBUS monitoring.//.........这里部分代码省略.........

//*****************************************************************************//// This function updates the status area of the screen.  It uses the current// state of the application to print the status bar.////*****************************************************************************voidUpdateStatus(void){    tRectangle sRect;    //    // Fill the bottom rows of the screen with blue to create the status area.    //    sRect.sXMin = 0;    sRect.sYMin = GrContextDpyHeightGet(&g_sContext) -                  DISPLAY_BANNER_HEIGHT - 1;    sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.sYMax = sRect.sYMin + DISPLAY_BANNER_HEIGHT;    GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_pFontFixed6x8);    //    // Update the status on the screen.    //    if(g_eUSBState == STATE_NO_DEVICE)    {        //        // Keyboard is currently disconnected.        //        GrStringDrawCentered(&g_sContext, "no device", -1,                              GrContextDpyWidthGet(&g_sContext) / 2,                              sRect.sYMin + 5, 0);    }    else if(g_eUSBState == STATE_UNKNOWN_DEVICE)    {        //        // Unknown device is currently connected.        //        GrStringDrawCentered(&g_sContext, "unknown device", -1,                              GrContextDpyWidthGet(&g_sContext) / 2,                              sRect.sYMin + 5, 0);    }    else if(g_eUSBState == STATE_POWER_FAULT)    {        //        // Something caused a power fault.        //        GrStringDrawCentered(&g_sContext, "power fault", -1,                              GrContextDpyWidthGet(&g_sContext) / 2,                              sRect.sYMin + 5, 0);    }    else if((g_eUSBState == STATE_KEYBOARD_CONNECTED) ||            (g_eUSBState == STATE_KEYBOARD_UPDATE))    {        //        // Keyboard is connected.        //        GrStringDrawCentered(&g_sContext, "connected", -1,                              GrContextDpyWidthGet(&g_sContext) / 2,                              sRect.sYMin + 5, 0);        //        // Update the CAPS Lock status.        //        if(g_ulModifiers & HID_KEYB_CAPS_LOCK)        {            GrStringDrawCentered(&g_sContext, "C",                                  GrContextDpyWidthGet(&g_sContext) / 2,                                  sRect.sXMax - 10,                                 sRect.sYMin + 5, 0);        }    }}

//*****************************************************************************////! Draws a check box widget.//!//! /param pWidget is a pointer to the check box widget to be drawn.//! /param bClick is a boolean that is /b true if the paint request is a result//! of a pointer click and /b false if not.//!//! This function draws a check box widget on the display.  This is called in//! response to a /b #WIDGET_MSG_PAINT message.//!//! /return None.////*****************************************************************************static voidCheckBoxPaint(tWidget *pWidget, unsigned long bClick){    tCheckBoxWidget *pCheck;    tRectangle sRect;    tContext sCtx;    long lY;    //    // Check the arguments.    //    ASSERT(pWidget);    //    // Convert the generic widget pointer into a check box widget pointer.    //    pCheck = (tCheckBoxWidget *)pWidget;    //    // Initialize a drawing context.    //    GrContextInit(&sCtx, pWidget->pDisplay);    //    // Initialize the clipping region based on the extents of this check box.    //    GrContextClipRegionSet(&sCtx, &(pWidget->sPosition));    //    // See if the check box fill style is selected.    //    if((pCheck->usStyle & CB_STYLE_FILL) && !bClick)    {        //        // Fill the check box with the fill color.        //        GrContextForegroundSet(&sCtx, pCheck->ulFillColor);        GrRectFill(&sCtx, &(pWidget->sPosition));    }    //    // See if the check box outline style is selected.    //    if((pCheck->usStyle & CB_STYLE_OUTLINE) && !bClick)    {        //        // Outline the check box with the outline color.        //        GrContextForegroundSet(&sCtx, pCheck->ulOutlineColor);        GrRectDraw(&sCtx, &(pWidget->sPosition));    }    //    // Draw the check box.    //    sRect.sXMin = pWidget->sPosition.sXMin + 2;    sRect.sYMin = (pWidget->sPosition.sYMin +                   ((pWidget->sPosition.sYMax - pWidget->sPosition.sYMin -                     pCheck->usBoxSize + 1) / 2));    sRect.sXMax = sRect.sXMin + pCheck->usBoxSize - 1;    sRect.sYMax = sRect.sYMin + pCheck->usBoxSize - 1;    if(!bClick)    {        GrContextForegroundSet(&sCtx, pCheck->ulOutlineColor);        GrRectDraw(&sCtx, &sRect);    }    //    // Select the foreground color based on whether or not the check box is    // selected.    //    if(pCheck->usStyle & CB_STYLE_SELECTED)    {        GrContextForegroundSet(&sCtx, pCheck->ulOutlineColor);    }    else    {        GrContextForegroundSet(&sCtx, pCheck->ulFillColor);    }    //    // Draw an "X" in the check box.    //    GrLineDraw(&sCtx, sRect.sXMin + 1, sRect.sYMin + 1, sRect.sXMax - 1,               sRect.sYMax - 1);    GrLineDraw(&sCtx, sRect.sXMin + 1, sRect.sYMax - 1, sRect.sXMax - 1,//.........这里部分代码省略.........

//.........这里部分代码省略.........    //    // See if the container fill style is selected.    //    if(pContainer->ulStyle & CTR_STYLE_FILL)    {        //        // Fill the container with the fill color.        //        GrContextForegroundSet(&sCtx, pContainer->ulFillColor);        GrRectFill(&sCtx, &(pWidget->sPosition));    }    //    // See if the container text style is selected.    //    if(pContainer->ulStyle & CTR_STYLE_TEXT)    {        //        // Set the font and colors used to draw the container text.        //        GrContextFontSet(&sCtx, pContainer->pFont);        GrContextForegroundSet(&sCtx, pContainer->ulTextColor);        GrContextBackgroundSet(&sCtx, pContainer->ulFillColor);        //        // Get the width of the container text.        //        lX2 = GrStringWidthGet(&sCtx, pContainer->pcText, -1);        //        // Determine the position of the text.  The position depends on the        // the width of the string and if centering is enabled.        //        if(pContainer->ulStyle & CTR_STYLE_TEXT_CENTER)        {            lX1 = (pWidget->sPosition.sXMin +                   ((pWidget->sPosition.sXMax - pWidget->sPosition.sXMin + 1 -                     lX2 - 8) / 2));        }        else        {            lX1 = pWidget->sPosition.sXMin + 4;        }        //        // Draw the container text.        //        GrStringDraw(&sCtx, pContainer->pcText, -1, lX1 + 4,                     pWidget->sPosition.sYMin,                     pContainer->ulStyle & CTR_STYLE_TEXT_OPAQUE);        //        // See if the container outline style is selected.        //        if(pContainer->ulStyle & CTR_STYLE_OUTLINE)        {            //            // Get the position of the right side of the string.            //            lX2 = lX1 + lX2 + 8;            //            // Get the position of the vertical center of the text.            //            lY = (pWidget->sPosition.sYMin +                  (GrFontBaselineGet(pContainer->pFont) / 2));            //            // Set the color to draw the outline.            //            GrContextForegroundSet(&sCtx, pContainer->ulOutlineColor);            //            // Draw the outline around the container widget, leaving a gap            // where the text reside across the top of the widget.            //            GrLineDraw(&sCtx, lX1, lY, pWidget->sPosition.sXMin, lY);            GrLineDraw(&sCtx, pWidget->sPosition.sXMin, lY,                       pWidget->sPosition.sXMin, pWidget->sPosition.sYMax);            GrLineDraw(&sCtx, pWidget->sPosition.sXMin,                       pWidget->sPosition.sYMax, pWidget->sPosition.sXMax,                       pWidget->sPosition.sYMax);            GrLineDraw(&sCtx, pWidget->sPosition.sXMax,                       pWidget->sPosition.sYMax, pWidget->sPosition.sXMax, lY);            GrLineDraw(&sCtx, pWidget->sPosition.sXMax, lY, lX2, lY);        }    }    //    // Otherwise, see if the container outline style is selected.    //    else if(pContainer->ulStyle & CTR_STYLE_OUTLINE)    {        //        // Outline the container with the outline color.        //        GrContextForegroundSet(&sCtx, pContainer->ulOutlineColor);        GrRectDraw(&sCtx, &(pWidget->sPosition));    }}

//*****************************************************************************//// Print "Hello World!" to the display.////*****************************************************************************intmain(void){    tContext sContext;    tRectangle sRect;    //    // Enable lazy stacking for interrupt handlers.  This allows floating-point    // instructions to be used within interrupt handlers, but at the expense of    // extra stack usage.    //    ROM_FPULazyStackingEnable();    //    // Set the clocking to run directly from the crystal.    //    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ |                       SYSCTL_OSC_MAIN);    //    // Initialize the UART.    //    ConfigureUART();    UARTprintf("Hello, world!/n");    //    // Initialize the display driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context.    //    GrContextInit(&sContext, &g_sCFAL96x64x16);    //    // Fill the top 24 rows of the screen with blue to create the banner.    //    sRect.i16XMin = 0;    sRect.i16YMin = 0;    sRect.i16XMax = GrContextDpyWidthGet(&sContext) - 1;    sRect.i16YMax = 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_psFontCm12);    GrStringDrawCentered(&sContext, "hello", -1,                         GrContextDpyWidthGet(&sContext) / 2, 10, 0);    //    // Say hello using the Computer Modern 40 point font.    //    GrContextFontSet(&sContext, g_psFontCm12/*g_psFontFixed6x8*/);    GrStringDrawCentered(&sContext, "Hello World!", -1,                         GrContextDpyWidthGet(&sContext) / 2,                         ((GrContextDpyHeightGet(&sContext) - 24) / 2) + 24,                         0);    //    // Flush any cached drawing operations.    //    GrFlush(&sContext);    //    // We are finished. Hang around doing nothing.    //    while(1) {    }}

//*****************************************************************************//// This example demonstrates how to use the uDMA controller to transfer data// between memory buffers and to and from a peripheral, in this case a UART.// The uDMA controller is configured to repeatedly transfer a block of data// from one memory buffer to another.  It is also set up to repeatedly copy a// block of data from a buffer to the UART output.  The UART data is looped// back so the same data is received, and the uDMA controlled is configured to// continuously receive the UART data using ping-pong buffers.//// The processor is put to sleep when it is not doing anything, and this allows// collection of CPU usage data to see how much CPU is being used while the// data transfers are ongoing.////*****************************************************************************intmain(void){    static unsigned long ulPrevSeconds;    static unsigned long ulPrevXferCount;    static unsigned long ulPrevUARTCount = 0;    static char cStrBuf[40];    tRectangle sRect;    unsigned long ulCenterX;    unsigned long ulXfersCompleted;    unsigned long ulBytesTransferred;    //    // Set the clocking to run from the PLL at 50 MHz.    //    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |                       SYSCTL_XTAL_16MHZ);    //    // Set the device pinout appropriately for this board.    //    PinoutSet();    //    // Enable peripherals to operate when CPU is in sleep.    //    ROM_SysCtlPeripheralClockGating(true);    //    // Initialize the display driver.    //    Kitronix320x240x16_SSD2119Init();    //    // Initialize the graphics context and find the middle X coordinate.    //    GrContextInit(&g_sContext, &g_sKitronix320x240x16_SSD2119);    //    // Get the center X coordinate of the screen, since it is used a lot.    //    ulCenterX = GrContextDpyWidthGet(&g_sContext) / 2;    //    // Fill the top 15 rows of the screen with blue to create the banner.    //    sRect.sXMin = 0;    sRect.sYMin = 0;    sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.sYMax = 23;    GrContextForegroundSet(&g_sContext, ClrDarkBlue);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_pFontCm20);    GrStringDrawCentered(&g_sContext, "udma-demo", -1, ulCenterX, 11, 0);    //    // Show the clock frequency on the display.    //    GrContextFontSet(&g_sContext, g_pFontCmss18b);    usnprintf(cStrBuf, sizeof(cStrBuf), "Stellaris @ %u MHz",              SysCtlClockGet() / 1000000);    GrStringDrawCentered(&g_sContext, cStrBuf, -1, ulCenterX, 40, 0);    //    // Show static text and field labels on the display.    //    GrStringDrawCentered(&g_sContext, "uDMA Mem Transfers", -1,                         ulCenterX, 62, 0);    GrStringDrawCentered(&g_sContext, "uDMA UART Transfers", -1,                         ulCenterX, 84, 0);    //    // Configure SysTick to occur 100 times per second, to use as a time    // reference.  Enable SysTick to generate interrupts.    ////.........这里部分代码省略.........

//*****************************************************************************//// This is the main application entry function.////*****************************************************************************intmain(void){    unsigned int ulTxCount;    unsigned int ulRxCount;	tRectangle sRect;	char pcBuffer[16];	unsigned int i;	unsigned char *src, *dest;	    MMUConfigAndEnable();			//	// USB module clock enable	//	USB0ModuleClkConfig();	//	//USB interrupt enable	//		USBInterruptEnable();	//	//LCD back light enable	//	LCDBackLightEnable();	// UPD Pin setup	//	//	UPDNPinControl();	//	//Delay timer setup	//	DelayTimerSetup();	//	//Configures raster to display image 	//	SetUpLCD();	    RasterDMAFBConfig(SOC_LCDC_0_REGS, 					  (unsigned int)(g_pucBuffer+PALETTE_OFFSET),					  (unsigned int)(g_pucBuffer+PALETTE_OFFSET) + sizeof(g_pucBuffer) - 2 -					  PALETTE_OFFSET, FRAME_BUFFER_0);	RasterDMAFBConfig(SOC_LCDC_0_REGS, 					  (unsigned int)(g_pucBuffer+PALETTE_OFFSET),					  (unsigned int)(g_pucBuffer+PALETTE_OFFSET) + sizeof(g_pucBuffer) - 2 - 					  PALETTE_OFFSET, FRAME_BUFFER_1);	src = (unsigned char *) palette_32b;	dest = (unsigned char *) (g_pucBuffer+PALETTE_OFFSET);	// Copy palette info into buffer	for( i = PALETTE_OFFSET; i < (PALETTE_SIZE+PALETTE_OFFSET); i++)	{		*dest++ = *src++;	}			GrOffScreen24BPPInit(&g_s35_800x480x24Display, g_pucBuffer, LCD_WIDTH, LCD_HEIGHT);		// Initialize a drawing context.	GrContextInit(&g_sContext, &g_s35_800x480x24Display);	/* enable End of frame interrupt */	RasterEndOfFrameIntEnable(SOC_LCDC_0_REGS);	/* enable raster */	RasterEnable(SOC_LCDC_0_REGS);		 //    // Fill the top 15 rows of the screen with blue to create the banner.    //  	sRect.sXMin = 0;    sRect.sYMin = 0;    sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.sYMax = 23;    GrContextForegroundSet(&g_sContext, ClrDarkBlue);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //  	GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, &g_sFontCm20);    GrStringDrawCentered(&g_sContext, "usb-dev-bulk", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 10, 0);//.........这里部分代码省略.........