//*****************************************************************************
//
// Handles paint requests for the canvas demonstration widget.
//
//*****************************************************************************
void
OnCanvasPaint(tWidget *psWidget, tContext *psContext)
{
uint32_t ui32Idx;
//
// Draw a set of radiating lines.
//
GrContextForegroundSet(psContext, ClrGoldenrod);
for(ui32Idx = 50; ui32Idx <= 180; ui32Idx += 10) {
GrLineDraw(psContext, 210, ui32Idx, 310, 230 - ui32Idx);
}
//
// Indicate that the contents of this canvas were drawn by the application.
//
GrContextFontSet(psContext, &g_sFontCm12);
GrStringDrawCentered(psContext, "App Drawn", -1, 260, 50, 1);
}
//*****************************************************************************
//
// Handles paint requests for the canvas demonstration widget.
//
//*****************************************************************************
void
OnCanvasPaint(tWidget *pWidget, tContext *pContext)
{
unsigned long ulIdx;
//
// Draw a set of radiating lines.
//
GrContextForegroundSet(pContext, ClrGoldenrod);
for(ulIdx = 10; ulIdx <= 230; ulIdx += 10)
{
GrLineDraw(pContext, ulIdx, 196, 240 - ulIdx, 261);
}
//
// Indicate that the contents of this canvas were drawn by the application.
//
GrContextFontSet(pContext, g_pFontCm12);
GrStringDraw(pContext, "App Drawn", -1, 10, 223, 1);
}
//*****************************************************************************
//
// Handles paint requests for the canvas demonstration widget.
//
//*****************************************************************************
void
OnCanvasPaint(tWidget *pWidget, tContext *pContext)
{
unsigned long ulIdx;
//
// Draw a set of radiating lines.
//
GrContextForegroundSet(pContext, ClrGoldenrod);
for(ulIdx = 50; ulIdx <= 180; ulIdx += 10)
{
GrLineDraw(pContext, 210, ulIdx, 310, 230 - ulIdx);
}
//
// Indicate that the contents of this canvas were drawn by the application.
//
GrContextFontSet(pContext, g_pFontFixed6x8);
GrStringDrawCentered(pContext, "App Drawn", -1, 260, 50, 1);
}
//*****************************************************************************
//
// Handles paint requests for the canvas demonstration widget.
//
//*****************************************************************************
void
OnCanvasPaint(tWidget *pWidget, tContext *pContext)
{
unsigned int ulIdx;
//
// Draw a set of radiating lines.
//
GrContextForegroundSet(pContext, ClrGoldenrod);
for(ulIdx = 50; ulIdx <= 180; ulIdx += 10)
{
GrLineDraw(pContext, 210+X_OFFSET, ulIdx+Y_OFFSET, 310+X_OFFSET, 230 - ulIdx+Y_OFFSET);
}
//
// Indicate that the contents of this canvas were drawn by the application.
//
GrContextFontSet(pContext, &g_sFontCm12);
GrStringDrawCentered(pContext, "App Drawn", -1, 260+X_OFFSET, 50+Y_OFFSET, 1);
}
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);
GrRectFill(&g_sContext, &myRectangle2);
GrFlush(&g_sContext);
Delay_long();
GrClearDisplay(&g_sContext);
// Combining Primitive screen
GrStringDrawCentered(&g_sContext,
"Combining",
AUTO_STRING_LENGTH,
48,
15,
TRANSPARENT_TEXT);
GrStringDrawCentered(&g_sContext,
"Primitives to",
AUTO_STRING_LENGTH,
48,
35,
TRANSPARENT_TEXT);
GrStringDrawCentered(&g_sContext,
"create menus",
AUTO_STRING_LENGTH,
48,
51,
TRANSPARENT_TEXT);
GrStringDrawCentered(&g_sContext,
"and animations",
AUTO_STRING_LENGTH,
48,
75,
TRANSPARENT_TEXT);
GrFlush(&g_sContext);
Delay_long();
GrClearDisplay(&g_sContext);
// Draw a Menu screen
GrStringDrawCentered(&g_sContext,
"Create a Menu",
AUTO_STRING_LENGTH,
48,
5,
TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangleOption1);
GrStringDraw(&g_sContext,"Option #1", 10,15,15,TRANSPARENT_TEXT);
GrRectFill(&g_sContext, &myRectangleOption2);
GrStringDraw(&g_sContext,"Option #2", 10,15,25,TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangleOption3);
GrStringDraw(&g_sContext,"Option #3", 10,15,35,TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangleOption4);
GrStringDraw(&g_sContext,"Option #4", 10,15,45,TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangleOption5);
GrStringDraw(&g_sContext,"Option #5", 10,15,55,TRANSPARENT_TEXT);
GrFlush(&g_sContext);
Delay_long();
GrClearDisplay(&g_sContext);
// Show progress bar screen
// The following animation consist on displaying a progress bar and
// updating the progress bar in increments of 25%.
GrStringDrawCentered(&g_sContext,
"Show progress",
AUTO_STRING_LENGTH,
48,
5,
TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangleFrame);
GrStringDrawCentered(&g_sContext,
"Processing...",
AUTO_STRING_LENGTH,
48,
75,
TRANSPARENT_TEXT);
GrFlush(&g_sContext);
Delay_short();
// Update display with 25 %. Initial value of "myRectangleProgress" are set
// to update bar with a 25 % increment.
GrRectFill(&g_sContext, &myRectangleProgress);
GrFlush(&g_sContext);
Delay_short();
// Set myRectangleProgress values to update progress bar with 50 %
myRectangleProgress.sXMin = 30;
myRectangleProgress.sYMin = 40;
myRectangleProgress.sXMax = 50;
myRectangleProgress.sYMax = 60;
GrRectFill(&g_sContext, &myRectangleProgress);
GrFlush(&g_sContext);
Delay_short();
// Set myRectangleProgress values to update progress bar with 75 %
myRectangleProgress.sXMin = 50;
myRectangleProgress.sYMin = 40;
myRectangleProgress.sXMax = 70;
myRectangleProgress.sYMax = 60;
GrRectFill(&g_sContext, &myRectangleProgress);
GrFlush(&g_sContext);
Delay_short();
// Set myRectangleProgress values to update progress bar with 100 %
myRectangleProgress.sXMin = 70;
myRectangleProgress.sYMin = 40;
myRectangleProgress.sXMax = 90;
myRectangleProgress.sYMax = 60;
GrRectFill(&g_sContext, &myRectangleProgress);
GrStringDrawCentered(&g_sContext,
"DONE!",
AUTO_STRING_LENGTH,
48,
85,
TRANSPARENT_TEXT);
GrFlush(&g_sContext);
Delay_long();
while(1);
}
//*****************************************************************************
//
// Handles paint requests for the primitives canvas widget.
//
//*****************************************************************************
void
OnPrimitivePaint(tWidget *psWidget, tContext *psContext)
{
uint32_t ui32Idx;
tRectangle sRect;
//
// Draw a vertical sweep of lines from red to green.
//
for(ui32Idx = 0; ui32Idx <= 8; ui32Idx++) {
GrContextForegroundSet(psContext,
(((((10 - ui32Idx) * 255) / 10) << ClrRedShift) |
(((ui32Idx * 255) / 10) << ClrGreenShift)));
GrLineDraw(psContext, 115, 120, 5, 120 - (11 * ui32Idx));
}
//
// Draw a horizontal sweep of lines from green to blue.
//
for(ui32Idx = 1; ui32Idx <= 10; ui32Idx++) {
GrContextForegroundSet(psContext,
(((((10 - ui32Idx) * 255) / 10) <<
ClrGreenShift) |
(((ui32Idx * 255) / 10) << ClrBlueShift)));
GrLineDraw(psContext, 115, 120, 5 + (ui32Idx * 11), 29);
}
//
// Draw a filled circle with an overlapping circle.
//
GrContextForegroundSet(psContext, ClrBrown);
GrCircleFill(psContext, 185, 69, 40);
GrContextForegroundSet(psContext, ClrSkyBlue);
GrCircleDraw(psContext, 205, 99, 30);
//
// Draw a filled rectangle with an overlapping rectangle.
//
GrContextForegroundSet(psContext, ClrSlateGray);
sRect.i16XMin = 20;
sRect.i16YMin = 100;
sRect.i16XMax = 75;
sRect.i16YMax = 160;
GrRectFill(psContext, &sRect);
GrContextForegroundSet(psContext, ClrSlateBlue);
sRect.i16XMin += 40;
sRect.i16YMin += 40;
sRect.i16XMax += 30;
sRect.i16YMax += 28;
GrRectDraw(psContext, &sRect);
//
// Draw a piece of text in fonts of increasing size.
//
GrContextForegroundSet(psContext, ClrSilver);
GrContextFontSet(psContext, &g_sFontCm14);
GrStringDraw(psContext, "Strings", -1, 125, 110, 0);
GrContextFontSet(psContext, &g_sFontCm18);
GrStringDraw(psContext, "Strings", -1, 145, 124, 0);
GrContextFontSet(psContext, &g_sFontCm22);
GrStringDraw(psContext, "Strings", -1, 165, 142, 0);
GrContextFontSet(psContext, &g_sFontCm24);
GrStringDraw(psContext, "Strings", -1, 185, 162, 0);
//
// Draw an image.
//
GrImageDraw(psContext, g_pui8Logo, 270, 80);
}
//*****************************************************************************
//
// A simple demonstration of the features of the Stellaris Graphics Library.
//
//*****************************************************************************
int
main(void)
{
unsigned long ulIdx;
tRectangle sRect;
//
// Set the clocking to run from the PLL.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
//
// 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_sFontFixed6x8);
GrStringDrawCentered(&g_sContext, "grlib_demo", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 7, 0);
//
// Draw a vertical sweep of lines from red to green.
//
for(ulIdx = 0; ulIdx <= 10; ulIdx++)
{
GrContextForegroundSet(&g_sContext,
(((((10 - ulIdx) * 255) / 10) << ClrRedShift) |
(((ulIdx * 255) / 10) << ClrGreenShift)));
GrLineDraw(&g_sContext, 62, 70, 2, 70 - (5 * ulIdx));
}
//
// Draw a horizontal sweep of lines from green to blue.
//
for(ulIdx = 1; ulIdx <= 10; ulIdx++)
{
GrContextForegroundSet(&g_sContext,
(((((10 - ulIdx) * 255) / 10) <<
ClrGreenShift) |
(((ulIdx * 255) / 10) << ClrBlueShift)));
GrLineDraw(&g_sContext, 62, 70, 2 + (ulIdx * 6), 20);
}
//
// Draw a filled circle with an overlapping circle.
//
GrContextForegroundSet(&g_sContext, ClrBrown);
GrCircleFill(&g_sContext, 88, 37, 17);
GrContextForegroundSet(&g_sContext, ClrSkyBlue);
GrCircleDraw(&g_sContext, 104, 45, 17);
//
// Draw a filled rectangle with an overlapping rectangle.
//
GrContextForegroundSet(&g_sContext, ClrSlateGray);
sRect.sXMin = 4;
sRect.sYMin = 84;
sRect.sXMax = 42;
sRect.sYMax = 104;
GrRectFill(&g_sContext, &sRect);
GrContextForegroundSet(&g_sContext, ClrSlateBlue);
sRect.sXMin += 12;
sRect.sYMin += 15;
sRect.sXMax += 12;
sRect.sYMax += 15;
GrRectDraw(&g_sContext, &sRect);
//
// Draw a piece of text in fonts of increasing size.
//
GrContextForegroundSet(&g_sContext, ClrSilver);
GrStringDraw(&g_sContext, "Strings", -1, 75, 114, 0);
//
// Draw an image.
//
GrImageDraw(&g_sContext, g_pucLogo, 80, 77);
//
// Flush any cached drawing operations.
//
GrFlush(&g_sContext);
//
// Loop forever.
//
while(1)
{
}
}
//*****************************************************************************
//
// Handles paint requests for the primitives canvas widget.
//
//*****************************************************************************
void
OnPrimitivePaint(tWidget *pWidget, tContext *pContext)
{
unsigned long ulIdx;
tRectangle sRect;
//
// Draw a vertical sweep of lines from red to green.
//
for(ulIdx = 0; ulIdx <= 10; ulIdx++)
{
GrContextForegroundSet(pContext,
(((((10 - ulIdx) * 255) / 10) << ClrRedShift) |
(((ulIdx * 255) / 10) << ClrGreenShift)));
GrLineDraw(pContext, 115, 139, 5, 139 - (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, 139, 5 + (ulIdx * 11), 29);
}
//
// Draw a filled circle with an overlapping circle.
//
GrContextForegroundSet(pContext, ClrBrown);
GrCircleFill(pContext, 165, 69, 40);
GrContextForegroundSet(pContext, ClrSkyBlue);
GrCircleDraw(pContext, 195, 99, 40);
//
// Draw a filled rectangle with an overlapping rectangle.
//
GrContextForegroundSet(pContext, ClrSlateGray);
sRect.sXMin = 5;
sRect.sYMin = 149;
sRect.sXMax = 75;
sRect.sYMax = 219;
GrRectFill(pContext, &sRect);
GrContextForegroundSet(pContext, ClrSlateBlue);
sRect.sXMin += 40;
sRect.sYMin += 40;
sRect.sXMax += 40;
sRect.sYMax += 40;
GrRectDraw(pContext, &sRect);
//
// Draw a piece of text in fonts of increasing size.
//
GrContextForegroundSet(pContext, ClrSilver);
GrContextFontSet(pContext, g_pFontCm14);
GrStringDraw(pContext, "Strings", -1, 125, 149, 0);
GrContextFontSet(pContext, g_pFontCm18);
GrStringDraw(pContext, "Strings", -1, 125, 163, 0);
GrContextFontSet(pContext, g_pFontCm22);
GrStringDraw(pContext, "Strings", -1, 125, 181, 0);
GrContextFontSet(pContext, g_pFontCm26);
GrStringDraw(pContext, "Strings", -1, 125, 203, 0);
GrContextFontSet(pContext, g_pFontCm30);
GrStringDraw(pContext, "Strings", -1, 125, 229, 0);
//
// Draw an image.
//
GrImageDraw(pContext, g_pucLogo, 190, 149);
}
//*****************************************************************************
//
// A simple demonstration of the features of the TivaWare Graphics Library.
//
//*****************************************************************************
int
main(void)
{
clockInit();
// Set up the LCD
Sharp96x96_initDisplay();
GrContextInit(&g_sContext, &g_sharp96x96LCD);
GrContextFontSet(&g_sContext, &g_sFontFixed6x8);
int step = -1;
Sharp96x96_VCOM_count = 10;
while(1)
{
if(Sharp96x96_VCOM_count < 4)
{
continue;
}
Sharp96x96_VCOM_count = 0;
if(++step >= 5)
{
step = 0;
}
BlankScreen();
GrFlush(&g_sContext);
switch(step) {
case 0:
// Intro Screen
GrStringDrawCentered(&g_sContext,
"How to use",
AUTO_STRING_LENGTH,
48,
15,
TRANSPARENT_TEXT);
GrStringDrawCentered(&g_sContext,
"the TivaWare",
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);
break;
case 1:
// 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);
break;
case 2:
// 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);
break;
case 3:
// Draw rectangles on the display
GrStringDrawCentered(&g_sContext,
"Draw Rectangles",
AUTO_STRING_LENGTH,
48,
5,
TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangle1);
GrRectFill(&g_sContext, &myRectangle2);
// Text below won't be visible on screen due to transparency
// (foreground colors match)
GrStringDrawCentered(&g_sContext,
"Normal Text",
AUTO_STRING_LENGTH,
50,
50,
TRANSPARENT_TEXT);
// Text below draws foreground and background for opacity
GrStringDrawCentered(&g_sContext,
"Opaque Text",
AUTO_STRING_LENGTH,
50,
65,
OPAQUE_TEXT);
GrContextForegroundSet(&g_sContext, ClrWhite);
GrContextBackgroundSet(&g_sContext, ClrBlack);
GrStringDrawCentered(&g_sContext,
"Invert Text",
AUTO_STRING_LENGTH,
50,
80,
TRANSPARENT_TEXT);
break;
case 4:
// Invert the foreground and background colors
GrContextForegroundSet(&g_sContext, ClrBlack);
GrContextBackgroundSet(&g_sContext, ClrWhite);
GrRectFill(&g_sContext, &myRectangle3);
GrContextForegroundSet(&g_sContext, ClrWhite);
GrContextBackgroundSet(&g_sContext, ClrBlack);
GrStringDrawCentered(&g_sContext,
"Invert Colors",
AUTO_STRING_LENGTH,
48,
5,
TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangle1);
GrRectFill(&g_sContext, &myRectangle2);
// Text below won't be visible on screen due to
// transparency (foreground colors match)
GrStringDrawCentered(&g_sContext,
"Normal Text",
AUTO_STRING_LENGTH,
50,
50,
TRANSPARENT_TEXT);
// Text below draws foreground and background for opacity
GrStringDrawCentered(&g_sContext,
"Opaque Text",
AUTO_STRING_LENGTH,
50,
65,
OPAQUE_TEXT);
// Text below draws with inverted foreground color to become visible
GrContextForegroundSet(&g_sContext, ClrBlack);
GrContextBackgroundSet(&g_sContext, ClrWhite);
GrStringDrawCentered(&g_sContext,
"Invert Text",
AUTO_STRING_LENGTH,
50,
80,
TRANSPARENT_TEXT);
break;
default:
break;
}
GrFlush(&g_sContext);
}
}
//*****************************************************************************
//
// The main loop handler for touch screen events from the touch screen driver.
//
//*****************************************************************************
int32_t
TSMainHandler(uint32_t ui32Message, int32_t i32X, int32_t i32Y)
{
tRectangle sRect;
//
// See which event is being sent from the touch screen driver.
//
switch(ui32Message)
{
//
// The pen has just been placed down.
//
case WIDGET_MSG_PTR_DOWN:
{
//
// Erase the drawing area.
//
GrContextForegroundSet(&g_sContext, ClrBlack);
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = 319;
sRect.i16YMax = 239;
GrRectFill(&g_sContext, &sRect);
//
// Flush any cached drawing operations.
//
GrFlush(&g_sContext);
//
// Set the drawing color to the current pen color.
//
GrContextForegroundSet(&g_sContext, g_pui32Colors[g_ui32ColorIdx]);
//
// Save the current position.
//
g_i32X = i32X;
g_i32Y = i32Y;
//
// This event has been handled.
//
break;
}
//
// Then pen has moved.
//
case WIDGET_MSG_PTR_MOVE:
{
//
// Draw a line from the previous position to the current position.
//
GrLineDraw(&g_sContext, g_i32X, g_i32Y, i32X, i32Y);
//
// Flush any cached drawing operations.
//
GrFlush(&g_sContext);
//
// Save the current position.
//
g_i32X = i32X;
g_i32Y = i32Y;
//
// This event has been handled.
//
break;
}
//
// The pen has just been picked up.
//
case WIDGET_MSG_PTR_UP:
{
//
// Draw a line from the previous position to the current position.
//
GrLineDraw(&g_sContext, g_i32X, g_i32Y, i32X, i32Y);
//
// Flush any cached drawing operations.
//
GrFlush(&g_sContext);
//
// Increment to the next drawing color.
//
g_ui32ColorIdx++;
if(g_ui32ColorIdx ==
(sizeof(g_pui32Colors) / sizeof(g_pui32Colors[0])))
{
g_ui32ColorIdx = 0;
}
//
// This event has been handled.
//
break;
}
}
//
// Success.
//
return(1);
}
//*****************************************************************************
//
// A simple demonstration of the features of the TivaWare Graphics Library.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32Idx;
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 from the PLL.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ |
SYSCTL_OSC_MAIN);
//
// Initialize the display driver.
//
CFAL96x64x16Init();
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sCFAL96x64x16);
//
// Fill the top 12 rows of the screen with blue to create the banner.
//
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.i16YMax = 11;
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, "grlib_demo", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 5, 0);
//
// Draw a vertical sweep of lines from red to green.
//
for(ui32Idx = 0; ui32Idx <= 8; ui32Idx++)
{
GrContextForegroundSet(&g_sContext,
(((((10 - ui32Idx) * 255) / 8) << ClrRedShift) |
(((ui32Idx * 255) / 8) << ClrGreenShift)));
GrLineDraw(&g_sContext, 60, 60, 0, 60 - (5 * ui32Idx));
}
//
// Draw a horizontal sweep of lines from green to blue.
//
for(ui32Idx = 1; ui32Idx <= 11; ui32Idx++)
{
GrContextForegroundSet(&g_sContext,
(((((11 - ui32Idx) * 255) / 11) <<
ClrGreenShift) |
(((ui32Idx * 255) / 11) << ClrBlueShift)));
GrLineDraw(&g_sContext, 60, 60, (ui32Idx * 5), 20);
}
//
// Draw a filled circle with an overlapping circle.
//
GrContextForegroundSet(&g_sContext, ClrBlue);
GrCircleFill(&g_sContext, 80, 30, 15);
GrContextForegroundSet(&g_sContext, ClrWhite);
GrCircleDraw(&g_sContext, 80, 30, 15);
//
// Draw a filled rectangle with an overlapping rectangle.
//
GrContextForegroundSet(&g_sContext, ClrGray);
sRect.i16XMin = 8;
sRect.i16YMin = 45;
sRect.i16XMax = 46;
sRect.i16YMax = 51;
GrRectFill(&g_sContext, &sRect);
GrContextForegroundSet(&g_sContext, ClrWhite);
sRect.i16XMin += 4;
sRect.i16YMin += 4;
sRect.i16XMax += 4;
sRect.i16YMax += 4;
GrRectDraw(&g_sContext, &sRect);
//
// Draw a piece of text in fonts of increasing size.
//
GrContextForegroundSet(&g_sContext, ClrBlack);
GrStringDraw(&g_sContext, "Strings", -1, 6, 16, 0);
GrContextForegroundSet(&g_sContext, ClrSilver);
GrStringDraw(&g_sContext, "Strings", -1, 7, 17, 0);
//
// Draw an image.
//
GrTransparentImageDraw(&g_sContext, g_pui8Logo, 64, 34, ClrBlack);
#if 0
GrImageDraw(&g_sContext, g_pui8Logo, 64, 34);
#endif
//
// Flush any cached drawing operations.
//
GrFlush(&g_sContext);
//
// Loop forever.
//
while(1)
{
}
}
void main(void){
WDT_A_hold(WDT_A_BASE); // Stop WDT
boardInit(); // Basic GPIO initialization
clockInit(8000000); // Config clocks. MCLK=SMCLK=FLL=8MHz; ACLK=REFO=32kHz
Sharp96x96_LCDInit(); // Set up the LCD
GrContextInit(&g_sContext, &g_sharp96x96LCD);
GrContextForegroundSet(&g_sContext, ClrBlack);
GrContextBackgroundSet(&g_sContext, ClrWhite);
GrContextFontSet(&g_sContext, &g_sFontFixed6x8);
GrClearDisplay(&g_sContext);
GrFlush(&g_sContext);
while(1){
// Intro Screen
GrClearDisplay(&g_sContext);
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();
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();
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();
GrClearDisplay(&g_sContext);
// Draw rectangles on the display
GrStringDrawCentered(&g_sContext,
"Draw Rectangles",
AUTO_STRING_LENGTH,
48,
5,
TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangle1);
GrRectFill(&g_sContext, &myRectangle2);
// Text below won't be visible on screen due to transparency
// (foreground colors match)
GrStringDrawCentered(&g_sContext,
"Normal Text",
AUTO_STRING_LENGTH,
50,
50,
TRANSPARENT_TEXT);
// Text below draws foreground and background for opacity
GrStringDrawCentered(&g_sContext,
"Opaque Text",
AUTO_STRING_LENGTH,
50,
65,
OPAQUE_TEXT);
GrContextForegroundSet(&g_sContext, ClrWhite);
GrContextBackgroundSet(&g_sContext, ClrBlack);
GrStringDrawCentered(&g_sContext,
"Invert Text",
AUTO_STRING_LENGTH,
50,
80,
TRANSPARENT_TEXT);
GrFlush(&g_sContext);
Delay();
// Invert the foreground and background colors
GrContextForegroundSet(&g_sContext, ClrBlack);
GrContextBackgroundSet(&g_sContext, ClrWhite);
GrRectFill(&g_sContext, &myRectangle3);
GrContextForegroundSet(&g_sContext, ClrWhite);
GrContextBackgroundSet(&g_sContext, ClrBlack);
GrStringDrawCentered(&g_sContext,
"Invert Colors",
AUTO_STRING_LENGTH,
48,
5,
TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangle1);
GrRectFill(&g_sContext, &myRectangle2);
// Text below won't be visible on screen due to
// transparency (foreground colors match)
GrStringDrawCentered(&g_sContext,
"Normal Text",
AUTO_STRING_LENGTH,
50,
50,
TRANSPARENT_TEXT);
// Text below draws foreground and background for opacity
GrStringDrawCentered(&g_sContext,
"Opaque Text",
AUTO_STRING_LENGTH,
50,
65,
OPAQUE_TEXT);
// Text below draws with inverted foreground color to become visible
GrContextForegroundSet(&g_sContext, ClrBlack);
GrContextBackgroundSet(&g_sContext, ClrWhite);
GrStringDrawCentered(&g_sContext,
"Invert Text",
AUTO_STRING_LENGTH,
50,
80,
TRANSPARENT_TEXT);
GrFlush(&g_sContext);
Delay();
GrContextForegroundSet(&g_sContext, ClrBlack);
GrContextBackgroundSet(&g_sContext, ClrWhite);
GrClearDisplay(&g_sContext);
// Draw Images on the display
GrImageDraw(&g_sContext, &LPRocket_96x37_1BPP_UNCOMP, 3, 28);
GrFlush(&g_sContext);
Delay();
GrClearDisplay(&g_sContext);
GrImageDraw(&g_sContext, &TI_Logo_69x64_1BPP_UNCOMP, 15, 15);
GrFlush(&g_sContext);
Delay();
// __bis_SR_register(LPM0_bits+GIE); //enter low power mode 0 with interrupts
}
}
//*****************************************************************************
//
// Draws the black keys on the display.
//
//*****************************************************************************
static inline void
DrawBlackKeys(tContext *pContext)
{
uint32_t ui32Key;
//
// Loop through the black keys.
//
for(ui32Key = 0; ui32Key < NUM_BLACK_KEYS; ui32Key++)
{
//
// Select the color for the top and left edges of the black key.
//
GrContextForegroundSet(pContext, ClrBlackBright);
//
// Draw the top and left edges of the black key.
//
GrLineDraw(pContext,
g_psBlackKeys[ui32Key].sOutline.i16XMin,
g_psBlackKeys[ui32Key].sOutline.i16YMin,
g_psBlackKeys[ui32Key].sOutline.i16XMax,
g_psBlackKeys[ui32Key].sOutline.i16YMin);
GrLineDraw(pContext,
g_psBlackKeys[ui32Key].sOutline.i16XMin + 1,
g_psBlackKeys[ui32Key].sOutline.i16YMin + 1,
g_psBlackKeys[ui32Key].sOutline.i16XMax - 1,
g_psBlackKeys[ui32Key].sOutline.i16YMin + 1);
GrLineDraw(pContext,
g_psBlackKeys[ui32Key].sOutline.i16XMin,
g_psBlackKeys[ui32Key].sOutline.i16YMin + 1,
g_psBlackKeys[ui32Key].sOutline.i16XMin,
g_psBlackKeys[ui32Key].sOutline.i16YMax);
GrLineDraw(pContext,
g_psBlackKeys[ui32Key].sOutline.i16XMin + 1,
g_psBlackKeys[ui32Key].sOutline.i16YMin + 2,
g_psBlackKeys[ui32Key].sOutline.i16XMin + 1,
g_psBlackKeys[ui32Key].sOutline.i16YMax - 1);
//
// Select the color for the bottom and right edges of the black key.
//
GrContextForegroundSet(pContext, ClrBlackDim);
//
// Draw the bottom and right edges of the black key.
//
GrLineDraw(pContext,
g_psBlackKeys[ui32Key].sOutline.i16XMax,
g_psBlackKeys[ui32Key].sOutline.i16YMin + 1,
g_psBlackKeys[ui32Key].sOutline.i16XMax,
g_psBlackKeys[ui32Key].sOutline.i16YMax);
GrLineDraw(pContext,
g_psBlackKeys[ui32Key].sOutline.i16XMax - 1,
g_psBlackKeys[ui32Key].sOutline.i16YMin + 2,
g_psBlackKeys[ui32Key].sOutline.i16XMax - 1,
g_psBlackKeys[ui32Key].sOutline.i16YMax - 1);
GrLineDraw(pContext,
g_psBlackKeys[ui32Key].sOutline.i16XMin + 1,
g_psBlackKeys[ui32Key].sOutline.i16YMax,
g_psBlackKeys[ui32Key].sOutline.i16XMax - 1,
g_psBlackKeys[ui32Key].sOutline.i16YMax);
GrLineDraw(pContext,
g_psBlackKeys[ui32Key].sOutline.i16XMin + 2,
g_psBlackKeys[ui32Key].sOutline.i16YMax - 1,
g_psBlackKeys[ui32Key].sOutline.i16XMax - 2,
g_psBlackKeys[ui32Key].sOutline.i16YMax - 1);
//
// Fill in the black key with the default color.
//
FillBlackKey(pContext, ui32Key, ClrBlackKey);
}
}
//*****************************************************************************
//
//! 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 void
CheckBoxPaint(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,
sRect.sYMin + 1);
//
// See if the check box text or image style is selected.
//
if((pCheck->usStyle & (CB_STYLE_TEXT | CB_STYLE_IMG)) && !bClick)
{
//
// Shrink the clipping region by the size of the check box so that it
// is not overwritten by further "decorative" portions of the widget.
//
sCtx.sClipRegion.sXMin += pCheck->usBoxSize + 4;
//
// If the check box outline style is selected then shrink the clipping
// region by one pixel on each side so that the outline is not
// overwritten by the text or image.
//
if(pCheck->usStyle & CB_STYLE_OUTLINE)
{
sCtx.sClipRegion.sYMin++;
sCtx.sClipRegion.sXMax--;
sCtx.sClipRegion.sYMax--;
}
//
// See if the check box image style is selected.
//
if(pCheck->usStyle & CB_STYLE_IMG)
{
//
// Determine where along the Y extent of the widget to draw the
// image. It is drawn at the top if it takes all (or more than
// all) of the Y extent of the widget, and it is drawn centered if
// it takes less than the Y extent.
//
if(GrImageHeightGet(pCheck->pucImage) >
(sCtx.sClipRegion.sYMax - sCtx.sClipRegion.sYMin))
{
lY = sCtx.sClipRegion.sYMin;
}
else
{
lY = (sCtx.sClipRegion.sYMin +
((sCtx.sClipRegion.sYMax - sCtx.sClipRegion.sYMin -
GrImageHeightGet(pCheck->pucImage) + 1) / 2));
}
//
// Set the foreground and background colors to use for 1 BPP
// images.
//
GrContextForegroundSet(&sCtx, pCheck->ulTextColor);
GrContextBackgroundSet(&sCtx, pCheck->ulFillColor);
//
// Draw the image next to the check box.
//
GrImageDraw(&sCtx, pCheck->pucImage, sCtx.sClipRegion.sXMin, lY);
}
//
// See if the check box text style is selected.
//
if(pCheck->usStyle & CB_STYLE_TEXT)
{
//
// Determine where along the Y extent of the widget to draw the
// string. It is drawn at the top if it takes all (or more than
// all) of the Y extent of the widget, and it is drawn centered if
// it takes less than the Y extent.
//
if(GrFontHeightGet(pCheck->pFont) >
(sCtx.sClipRegion.sYMax - sCtx.sClipRegion.sYMin))
{
lY = sCtx.sClipRegion.sYMin;
}
else
{
lY = (sCtx.sClipRegion.sYMin +
((sCtx.sClipRegion.sYMax - sCtx.sClipRegion.sYMin -
GrFontHeightGet(pCheck->pFont) + 1) / 2));
}
//
// Draw the text next to the check box.
//
GrContextFontSet(&sCtx, pCheck->pFont);
GrContextForegroundSet(&sCtx, pCheck->ulTextColor);
GrContextBackgroundSet(&sCtx, pCheck->ulFillColor);
GrStringDraw(&sCtx, pCheck->pcText, -1, sCtx.sClipRegion.sXMin,
lY, pCheck->usStyle & CB_STYLE_TEXT_OPAQUE);
}
}
}
//*****************************************************************************
//
// This task receives messages from the other tasks and updates the display as
// directed.
//
//*****************************************************************************
static void
DisplayTask(void *pvParameters)
{
tDisplayMessage sMessage;
tContext sContext;
//
// Initialize the graphics library context.
//
GrContextInit(&sContext, &g_sKitronix320x240x16_SSD2119);
GrContextForegroundSet(&sContext, ClrWhite);
GrContextBackgroundSet(&sContext, ClrBlack);
GrContextFontSet(&sContext, g_pFontFixed6x8);
//
// Loop forever.
//
while(1)
{
//
// Read the next message from the queue.
//
if(xQueueReceive(g_pDisplayQueue, &sMessage, portMAX_DELAY) == pdPASS)
{
//
// Determine the message type.
//
switch(sMessage.ulType)
{
//
// The drawing of an image has been requested.
//
case DISPLAY_IMAGE:
{
//
// Draw this image on the display.
//
GrImageDraw(&sContext, (unsigned char *)sMessage.pcMessage,
sMessage.usX, sMessage.usY);
//
// This message has been handled.
//
break;
}
//
// The drawing of a string has been requested.
//
case DISPLAY_STRING:
{
//
// Draw this string on the display.
//
GrStringDraw(&sContext, sMessage.pcMessage, -1,
sMessage.usX, sMessage.usY, 1);
//
// This message has been handled.
//
break;
}
//
// A move of the pen has been requested.
//
case DISPLAY_MOVE:
{
//
// Save the new pen position.
//
g_ulDisplayX = sMessage.usX;
g_ulDisplayY = sMessage.usY;
//
// This message has been handled.
//
break;
}
//
// A draw with the pen has been requested.
//
case DISPLAY_DRAW:
{
//
// Draw a line from the previous pen position to the new
// pen position.
//
GrLineDraw(&sContext, g_ulDisplayX, g_ulDisplayY,
sMessage.usX, sMessage.usY);
//
// Save the new pen position.
//
g_ulDisplayX = sMessage.usX;
g_ulDisplayY = sMessage.usY;
//
// This message has been handled.
//
break;
}
}
}
}
}
//*****************************************************************************
//
// Handles paint requests for the primitives canvas widget.
//
//*****************************************************************************
void
OnPrimitivePaint(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);
}
//*****************************************************************************
//
// Handles paint requests for the primitives canvas widget.
//
//*****************************************************************************
void
OnPrimitivePaint(tWidget *pWidget, tContext *pContext)
{
unsigned long 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, 120, 5, 120 - (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, 120, 5 + (ulIdx * 11), 29);
}
//
// Draw a filled circle with an overlapping circle.
//
GrContextForegroundSet(pContext, ClrBrown);
GrCircleFill(pContext, 185, 69, 40);
GrContextForegroundSet(pContext, ClrSkyBlue);
GrCircleDraw(pContext, 205, 99, 30);
//
// Draw a filled rectangle with an overlapping rectangle.
//
GrContextForegroundSet(pContext, ClrSlateGray);
sRect.sXMin = 20;
sRect.sYMin = 100;
sRect.sXMax = 75;
sRect.sYMax = 160;
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_pFontFixed6x8);
GrStringDraw(pContext, "Strings", -1, 125, 110, 0);
GrContextFontSet(pContext, g_pFontCmss18b);
GrStringDraw(pContext, "Strings", -1, 145, 124, 0);
GrContextFontSet(pContext, g_pFontCmss22b);
GrStringDraw(pContext, "Strings", -1, 165, 142, 0);
//
// Draw an image.
//
GrImageDraw(pContext, g_pucTISymbol_80x75, 240, 80);
}
//*****************************************************************************
//
//! Draws a container widget.
//!
//! \param pWidget is a pointer to the container widget to be drawn.
//!
//! This function draws a container widget on the display. This is called in
//! response to a \b #WIDGET_MSG_PAINT message.
//!
//! \return None.
//
//*****************************************************************************
static void
ContainerPaint(tWidget *pWidget)
{
tContainerWidget *pContainer;
long lX1, lX2, lY;
tContext sCtx;
//
// Check the arguments.
//
ASSERT(pWidget);
//
// Convert the generic widget pointer into a container widget pointer.
//
pContainer = (tContainerWidget *)pWidget;
//
// Initialize a drawing context.
//
GrContextInit(&sCtx, pWidget->pDisplay);
//
// Initialize the clipping region based on the extents of this container.
//
GrContextClipRegionSet(&sCtx, &(pWidget->sPosition));
//
// 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));
}
}
void main(void)
{
tRectangle myRectangle1 = { 5, 10, 60, 50};
tRectangle myRectangle2 = { 30, 20, 100, 60};
tRectangle myRectangle3 = { 0, 0, 101, 63};
// Stop WDT
WDT_A_hold(WDT_A_BASE);
// Basic GPIO initialization
Board_init();
Clock_init();
// Set up LCD
Dogs102x64_UC1701Init();
GrContextInit(&g_sContext, &g_sDogs102x64_UC1701);
GrContextForegroundSet(&g_sContext, ClrBlack);
GrContextBackgroundSet(&g_sContext, ClrWhite);
GrContextFontSet(&g_sContext, &g_sFontFixed6x8);
GrClearDisplay(&g_sContext);
// Intro Screen
GrStringDrawCentered(&g_sContext,
"How to use MSP430",
AUTO_STRING_LENGTH,
51,
16,
TRANSPARENT_TEXT);
GrStringDrawCentered(&g_sContext,
"Graphics Library",
AUTO_STRING_LENGTH,
51,
32,
TRANSPARENT_TEXT);
GrStringDrawCentered(&g_sContext,
"Primitives",
AUTO_STRING_LENGTH,
51,
48,
TRANSPARENT_TEXT);
Delay();
GrClearDisplay(&g_sContext);
// Draw pixels and lines on the display
GrStringDraw(&g_sContext,
"Draw Pixels",
AUTO_STRING_LENGTH,
20,
0,
TRANSPARENT_TEXT);
GrStringDraw(&g_sContext,
"& Lines",
AUTO_STRING_LENGTH,
30,
10,
TRANSPARENT_TEXT);
GrPixelDraw(&g_sContext, 10, 10);
GrPixelDraw(&g_sContext, 10, 12);
GrPixelDraw(&g_sContext, 12, 12);
GrPixelDraw(&g_sContext, 12, 10);
GrLineDraw(&g_sContext, 15, 15, 60, 60);
GrLineDraw(&g_sContext, 10, 50, 90, 10);
GrLineDraw(&g_sContext,
0,
GrContextDpyHeightGet(&g_sContext) - 1,
GrContextDpyWidthGet(&g_sContext) - 1,
GrContextDpyHeightGet(&g_sContext) - 1);
Delay();
GrClearDisplay(&g_sContext);
// Draw circles on the display
GrStringDrawCentered(&g_sContext,
"Draw Circles",
AUTO_STRING_LENGTH,
51,
5,
TRANSPARENT_TEXT);
GrCircleDraw(&g_sContext, 30, 50, 10);
GrCircleFill(&g_sContext, 65, 37, 23);
Delay();
GrClearDisplay(&g_sContext);
// Draw rectangles on the display
GrStringDrawCentered(&g_sContext,
"Draw Rectangles",
AUTO_STRING_LENGTH,
51,
5,
TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangle1);
GrRectFill(&g_sContext, &myRectangle2);
// Text won't be visible on screen due to transparency
GrStringDrawCentered(&g_sContext,
"Normal Text",
AUTO_STRING_LENGTH,
65,
30,
TRANSPARENT_TEXT);
// Text draws foreground and background for opacity
GrStringDrawCentered(&g_sContext,
"Opaque Text",
AUTO_STRING_LENGTH,
65,
40,
OPAQUE_TEXT);
GrContextForegroundSet(&g_sContext, ClrWhite);
GrContextBackgroundSet(&g_sContext, ClrBlack);
// Text draws with inverted color to become visible
GrStringDrawCentered(&g_sContext,
"Invert Text",
AUTO_STRING_LENGTH,
65,
50,
TRANSPARENT_TEXT);
Delay();
GrClearDisplay(&g_sContext);
// Invert the foreground and background colors
GrContextForegroundSet(&g_sContext, ClrBlack);
GrContextBackgroundSet(&g_sContext, ClrWhite);
GrRectFill(&g_sContext, &myRectangle3);
GrContextForegroundSet(&g_sContext, ClrWhite);
GrContextBackgroundSet(&g_sContext, ClrBlack);
GrStringDrawCentered(&g_sContext,
"Invert Colors",
AUTO_STRING_LENGTH,
51,
5,
TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangle1);
GrRectFill(&g_sContext, &myRectangle2);
// Text won't be visible on screen due to transparency
GrStringDrawCentered(&g_sContext,
"Normal Text",
AUTO_STRING_LENGTH,
65,
30,
TRANSPARENT_TEXT);
// Text draws foreground and background for opacity
GrStringDrawCentered(&g_sContext,
"Opaque Text",
AUTO_STRING_LENGTH,
65,
40,
OPAQUE_TEXT);
GrContextForegroundSet(&g_sContext, ClrBlack);
GrContextBackgroundSet(&g_sContext, ClrWhite);
// Text draws with inverted color to become visible
GrStringDrawCentered(&g_sContext,
"Invert Text",
AUTO_STRING_LENGTH,
65,
50,
TRANSPARENT_TEXT);
Delay();
GrContextForegroundSet(&g_sContext, ClrBlack);
GrContextBackgroundSet(&g_sContext, ClrWhite);
GrClearDisplay(&g_sContext);
// Draw Images on the display
GrImageDraw(&g_sContext, &LPRocket_96x37_1BPP_UNCOMP, 3, 13);
Delay();
GrClearDisplay(&g_sContext);
GrImageDraw(&g_sContext, &TI_Logo_69x64_1BPP_UNCOMP, 16, 0);
while(1)
{
}
}