//***************************************************************************** // //! Draws the contents of a canvas. //! //! \param pWidget is a pointer to the canvas widget to be drawn. //! //! This function draws the contents of a canvas on the display. This is //! called in response to a \b #WIDGET_MSG_PAINT message. //! //! \return None. // //***************************************************************************** static void CanvasPaint(tWidget *pWidget) { tCanvasWidget *pCanvas; tContext sCtx; int lX, lY, lSize; // // Check the arguments. // ASSERT(pWidget); // // Convert the generic widget pointer into a canvas widget pointer. // pCanvas = (tCanvasWidget *)pWidget; // // Initialize a drawing context. // GrContextInit(&sCtx, pWidget->pDisplay); // // Initialize the clipping region based on the extents of this canvas. // GrContextClipRegionSet(&sCtx, &(pWidget->sPosition)); // // See if the canvas fill style is selected. // if(pCanvas->ulStyle & CANVAS_STYLE_FILL) { // // Fill the canvas with the fill color. // GrContextForegroundSet(&sCtx, pCanvas->ulFillColor); GrRectFill(&sCtx, &(pWidget->sPosition)); } // // See if the canvas outline style is selected. // if(pCanvas->ulStyle & CANVAS_STYLE_OUTLINE) { // // Outline the canvas with the outline color. // GrContextForegroundSet(&sCtx, pCanvas->ulOutlineColor); GrRectDraw(&sCtx, &(pWidget->sPosition)); } // // See if the canvas text or image style is selected. // if(pCanvas->ulStyle & (CANVAS_STYLE_TEXT | CANVAS_STYLE_IMG)) { // // Compute the center of the canvas. // lX = (pWidget->sPosition.sXMin + ((pWidget->sPosition.sXMax - pWidget->sPosition.sXMin + 1) / 2)); lY = (pWidget->sPosition.sYMin + ((pWidget->sPosition.sYMax - pWidget->sPosition.sYMin + 1) / 2)); // // If the canvas 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(pCanvas->ulStyle & CANVAS_STYLE_OUTLINE) { sCtx.sClipRegion.sXMin++; sCtx.sClipRegion.sYMin++; sCtx.sClipRegion.sXMax--; sCtx.sClipRegion.sYMax--; } // // See if the canvas image style is selected. // if(pCanvas->ulStyle & CANVAS_STYLE_IMG) { // // Set the foreground and background colors to use for 1 BPP // images. // GrContextForegroundSet(&sCtx, pCanvas->ulTextColor); GrContextBackgroundSet(&sCtx, pCanvas->ulFillColor); // // Draw the image centered in the canvas. // GrImageDraw(&sCtx, pCanvas->pucImage, lX - (GrImageWidthGet(pCanvas->pucImage) / 2), lY - (GrImageHeightGet(pCanvas->pucImage) / 2)); } // // See if the canvas text style is selected. // if(pCanvas->ulStyle & CANVAS_STYLE_TEXT) { // // Set the relevant font and colors. // GrContextFontSet(&sCtx, pCanvas->pFont); GrContextForegroundSet(&sCtx, pCanvas->ulTextColor); GrContextBackgroundSet(&sCtx, pCanvas->ulFillColor); // // Determine the drawing position for the string based on the // text alignment style. First consider the horizontal case. We // enter this section with lX set to the center of the widget. // // // How wide is the string? // lSize = GrStringWidthGet(&sCtx, pCanvas->pcText, -1); if(pCanvas->ulStyle & CANVAS_STYLE_TEXT_LEFT) { // // The string is to be aligned with the left edge of // the widget. Use the clipping rectangle as reference // since this will ensure that the string doesn't // encroach on any border that is set. // lX = sCtx.sClipRegion.sXMin; } else { if(pCanvas->ulStyle & CANVAS_STYLE_TEXT_RIGHT) { // // The string is to be aligned with the right edge of // the widget. Use the clipping rectangle as reference // since this will ensure that the string doesn't // encroach on any border that is set. // lX = sCtx.sClipRegion.sXMax - lSize; } else { // // We are centering the string horizontally so adjust // the position accordingly to take into account the // width of the string. // lX -= (lSize / 2); } } // // Now consider the horizontal case. We enter this section with lY // set to the center of the widget. // // How tall is the string? // lSize = GrStringHeightGet(&sCtx); if(pCanvas->ulStyle & CANVAS_STYLE_TEXT_TOP) { // // The string is to be aligned with the top edge of // the widget. Use the clipping rectangle as reference // since this will ensure that the string doesn't // encroach on any border that is set. // lY = sCtx.sClipRegion.sYMin; } else { if(pCanvas->ulStyle & CANVAS_STYLE_TEXT_BOTTOM) { // // The string is to be aligned with the bottom edge of // the widget. Use the clipping rectangle as reference // since this will ensure that the string doesn't // encroach on any border that is set. // lY = sCtx.sClipRegion.sYMax - lSize; } else { // // We are centering the string vertically so adjust // the position accordingly to take into account the // height of the string. // lY -= (lSize / 2); } } // // Now draw the string. // GrStringDraw(&sCtx, pCanvas->pcText, -1, lX, lY, pCanvas->ulStyle & CANVAS_STYLE_TEXT_OPAQUE); } } // // See if the application-drawn style is selected. // if(pCanvas->ulStyle & CANVAS_STYLE_APP_DRAWN) { // // Call the application-supplied function to draw the canvas. // pCanvas->pfnOnPaint(pWidget, &sCtx); } }
//***************************************************************************** // //! Draws a slider. //! //! \param psWidget is a pointer to the slider widget to be drawn. //! \param psDirty is the subrectangle of the widget which is to be redrawn. //! This is expressed in screen coordinates. //! //! This function draws a slider on the display. This is called in response to //! a \b #WIDGET_MSG_PAINT message or when the slider position changes. //! //! \return None. // //***************************************************************************** static void SliderPaint(tWidget *psWidget, tRectangle *psDirty) { tRectangle sClipRect, sValueRect, sEmptyRect, sActiveClip; tSliderWidget *pSlider; tContext sCtx; int32_t i32X, i32Y; bool bIntersect; int16_t i16Pos; // // Check the arguments. // ASSERT(psWidget); // // Convert the generic widget pointer into a slider widget pointer. // pSlider = (tSliderWidget *)psWidget; // // Initialize a drawing context. // GrContextInit(&sCtx, psWidget->psDisplay); // // Initialize the clipping region based on the update rectangle passed. // bIntersect = GrRectIntersectGet(psDirty, &(pSlider->sBase.sPosition), &sClipRect); GrContextClipRegionSet(&sCtx, &sClipRect); // // Draw the control outline if necessary. // if(pSlider->ui32Style & SL_STYLE_OUTLINE) { // // Outline the slider with the outline color. // GrContextForegroundSet(&sCtx, pSlider->ui32OutlineColor); GrRectDraw(&sCtx, &(psWidget->sPosition)); // // Adjust the clipping rectangle to prevent the outline from being // corrupted later. // if(sClipRect.i16XMin == psWidget->sPosition.i16XMin) { sClipRect.i16XMin++; } if(sClipRect.i16YMin == psWidget->sPosition.i16YMin) { sClipRect.i16YMin++; } if(sClipRect.i16XMax == psWidget->sPosition.i16XMax) { sClipRect.i16XMax--; } if(sClipRect.i16YMax == psWidget->sPosition.i16YMax) { sClipRect.i16YMax--; } } // // Determine the position associated with the current slider value. // i16Pos = SliderValueToPosition(pSlider, pSlider->i32Value); // // Remember this so that the dirty rectangle code in the click handler // draws the correct thing the first time it is called. // pSlider->i16Pos = i16Pos; // // Determine the rectangles for the active and empty portions of the // widget. // if(pSlider->ui32Style & SL_STYLE_VERTICAL) { // // Determine the rectangle corresponding to the bottom (value) portion // of the slider. // sValueRect.i16XMin = psWidget->sPosition.i16XMin; sValueRect.i16XMax = psWidget->sPosition.i16XMax; sValueRect.i16YMin = i16Pos; sValueRect.i16YMax = psWidget->sPosition.i16YMax; // // Determine the rectangle corresponding to the top (empty) portion // of the slider. // sEmptyRect.i16XMin = psWidget->sPosition.i16XMin; sEmptyRect.i16XMax = psWidget->sPosition.i16XMax; sEmptyRect.i16YMin = psWidget->sPosition.i16YMin; sEmptyRect.i16YMax = max(sEmptyRect.i16YMin, sValueRect.i16YMin - 1); } else { // // Determine the rectangle corresponding to the bottom (value) portion // of the slider. // sValueRect.i16YMin = psWidget->sPosition.i16YMin; sValueRect.i16YMax = psWidget->sPosition.i16YMax; sValueRect.i16XMin = psWidget->sPosition.i16XMin; sValueRect.i16XMax = i16Pos; // // Determine the rectangle corresponding to the top (empty) portion // of the slider. // sEmptyRect.i16YMin = psWidget->sPosition.i16YMin; sEmptyRect.i16YMax = psWidget->sPosition.i16YMax; sEmptyRect.i16XMax = psWidget->sPosition.i16XMax; sEmptyRect.i16XMin = min(sEmptyRect.i16XMax, sValueRect.i16XMax + 1); } // // Compute the center of the slider. This will be needed later if drawing // text or an image. // i32X = (psWidget->sPosition.i16XMin + ((psWidget->sPosition.i16XMax - psWidget->sPosition.i16XMin + 1) / 2)); i32Y = (psWidget->sPosition.i16YMin + ((psWidget->sPosition.i16YMax - psWidget->sPosition.i16YMin + 1) / 2)); // // Get the required clipping rectangle for the active/value part of // the slider. // bIntersect = GrRectIntersectGet(&sClipRect, &sValueRect, &sActiveClip); // // Does any part of the value rectangle intersect with the region we are // supposed to be redrawing? // if(bIntersect) { // // Yes - we have something to draw. // // // Set the new clipping rectangle. // GrContextClipRegionSet(&sCtx, &sActiveClip); // // Do we need to fill the active area with a color? // if(pSlider->ui32Style & SL_STYLE_FILL) { GrContextForegroundSet(&sCtx, pSlider->ui32FillColor); GrRectFill(&sCtx, &sValueRect); } // // Do we need to draw an image in the active area? // if(pSlider->ui32Style & SL_STYLE_IMG) { GrContextForegroundSet(&sCtx, pSlider->ui32TextColor); GrContextBackgroundSet(&sCtx, pSlider->ui32FillColor); GrImageDraw(&sCtx, pSlider->pui8Image, i32X - (GrImageWidthGet(pSlider->pui8Image) / 2), i32Y - (GrImageHeightGet(pSlider->pui8Image) / 2)); } // // Do we need to render a text string over the top of the active area? // if(pSlider->ui32Style & SL_STYLE_TEXT) { GrContextFontSet(&sCtx, pSlider->psFont); GrContextForegroundSet(&sCtx, pSlider->ui32TextColor); GrContextBackgroundSet(&sCtx, pSlider->ui32FillColor); GrStringDrawCentered(&sCtx, pSlider->pcText, -1, i32X, i32Y, pSlider->ui32Style & SL_STYLE_TEXT_OPAQUE); } } // // Now get the required clipping rectangle for the background portion of // the slider. // bIntersect = GrRectIntersectGet(&sClipRect, &sEmptyRect, &sActiveClip); // // Does any part of the background rectangle intersect with the region we // are supposed to be redrawing? // if(bIntersect) { // // Yes - we have something to draw. // // // Set the new clipping rectangle. // GrContextClipRegionSet(&sCtx, &sActiveClip); // // Do we need to fill the active area with a color? // if(pSlider->ui32Style & SL_STYLE_BACKG_FILL) { GrContextForegroundSet(&sCtx, pSlider->ui32BackgroundFillColor); GrRectFill(&sCtx, &sEmptyRect); } // // Do we need to draw an image in the active area? // if(pSlider->ui32Style & SL_STYLE_BACKG_IMG) { GrContextForegroundSet(&sCtx, pSlider->ui32BackgroundTextColor); GrContextBackgroundSet(&sCtx, pSlider->ui32BackgroundFillColor); GrImageDraw(&sCtx, pSlider->pui8BackgroundImage, i32X - (GrImageWidthGet(pSlider->pui8BackgroundImage) / 2), i32Y - (GrImageHeightGet(pSlider->pui8BackgroundImage) / 2)); } // // Do we need to render a text string over the top of the active area? // if(pSlider->ui32Style & SL_STYLE_BACKG_TEXT) { GrContextFontSet(&sCtx, pSlider->psFont); GrContextForegroundSet(&sCtx, pSlider->ui32BackgroundTextColor); GrContextBackgroundSet(&sCtx, pSlider->ui32BackgroundFillColor); GrStringDrawCentered(&sCtx, pSlider->pcText, -1, i32X, i32Y, pSlider->ui32Style & SL_STYLE_BACKG_TEXT_OPAQUE); } } }
//***************************************************************************** // //! Draws a circular push button. //! //! \param pWidget is a pointer to the push button widget to be drawn. //! //! This function draws a circular push button on the display. This is called //! in response to a \b #WIDGET_MSG_PAINT message. //! //! \return None. // //***************************************************************************** static void CircularButtonPaint(tWidget *pWidget) { const unsigned char *pucImage; tPushButtonWidget *pPush; tContext sCtx; long lX, lY, lR; // // Check the arguments. // ASSERT(pWidget); // // Convert the generic widget pointer into a push button widget pointer. // pPush = (tPushButtonWidget *)pWidget; // // Initialize a drawing context. // GrContextInit(&sCtx, pWidget->pDisplay); // // Initialize the clipping region based on the extents of this circular // push button. // GrContextClipRegionSet(&sCtx, &(pWidget->sPosition)); // // Get the radius of the circular push button, along with the X and Y // coordinates for its center. // lR = (pWidget->sPosition.sXMax - pWidget->sPosition.sXMin + 1) / 2; lX = pWidget->sPosition.sXMin + lR; lY = pWidget->sPosition.sYMin + lR; // // See if the push button fill style is selected. // if(pPush->ulStyle & PB_STYLE_FILL) { // // Fill the push button with the fill color. // GrContextForegroundSet(&sCtx, ((pPush->ulStyle & PB_STYLE_PRESSED) ? pPush->ulPressFillColor : pPush->ulFillColor)); GrCircleFill(&sCtx, lX, lY, lR); } // // See if the push button outline style is selected. // if(pPush->ulStyle & PB_STYLE_OUTLINE) { // // Outline the push button with the outline color. // GrContextForegroundSet(&sCtx, pPush->ulOutlineColor); GrCircleDraw(&sCtx, lX, lY, lR); } // // See if the push button text or image style is selected. // if(pPush->ulStyle & (PB_STYLE_TEXT | PB_STYLE_IMG)) { // // If the push button 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(pPush->ulStyle & PB_STYLE_OUTLINE) { sCtx.sClipRegion.sXMin++; sCtx.sClipRegion.sYMin++; sCtx.sClipRegion.sXMax--; sCtx.sClipRegion.sYMax--; } // // See if the push button image style is selected. // if(pPush->ulStyle & PB_STYLE_IMG) { // // Set the foreground and background colors to use for 1 BPP // images. // GrContextForegroundSet(&sCtx, pPush->ulTextColor); GrContextBackgroundSet(&sCtx, ((pPush->ulStyle & PB_STYLE_PRESSED) ? pPush->ulPressFillColor : pPush->ulFillColor)); // // Get the image to be drawn. // pucImage = (((pPush->ulStyle & PB_STYLE_PRESSED) && pPush->pucPressImage) ? pPush->pucPressImage : pPush->pucImage); // // Draw the image centered in the push button. // GrImageDraw(&sCtx, pucImage, lX - (GrImageWidthGet(pucImage) / 2), lY - (GrImageHeightGet(pucImage) / 2)); } // // See if the push button text style is selected. // if(pPush->ulStyle & PB_STYLE_TEXT) { // // Draw the text centered in the middle of the push button. // GrContextFontSet(&sCtx, pPush->pFont); GrContextForegroundSet(&sCtx, pPush->ulTextColor); GrContextBackgroundSet(&sCtx, ((pPush->ulStyle & PB_STYLE_PRESSED) ? pPush->ulPressFillColor : pPush->ulFillColor)); GrStringDrawCentered(&sCtx, pPush->pcText, -1, lX, lY, pPush->ulStyle & PB_STYLE_TEXT_OPAQUE); } } }
//***************************************************************************** // //! Draws a rectangular push button. //! //! \param psWidget is a pointer to the push button widget to be drawn. //! //! This function draws a rectangular push button on the display. This is //! called in response to a \b #WIDGET_MSG_PAINT message. //! //! \return None. // //***************************************************************************** static void RectangularButtonPaint(tWidget *psWidget) { const uint8_t *pui8Image; tPushButtonWidget *pPush; tContext sCtx; int32_t i32X, i32Y; // // Check the arguments. // ASSERT(psWidget); // // Convert the generic widget pointer into a push button widget pointer. // pPush = (tPushButtonWidget *)psWidget; // // Initialize a drawing context. // GrContextInit(&sCtx, psWidget->psDisplay); // // Initialize the clipping region based on the extents of this rectangular // push button. // GrContextClipRegionSet(&sCtx, &(psWidget->sPosition)); // // See if the push button fill style is selected. // if(pPush->ui32Style & PB_STYLE_FILL) { // // Fill the push button with the fill color. // GrContextForegroundSet(&sCtx, ((pPush->ui32Style & PB_STYLE_PRESSED) ? pPush->ui32PressFillColor : pPush->ui32FillColor)); GrRectFill(&sCtx, &(psWidget->sPosition)); } // // See if the push button outline style is selected. // if(pPush->ui32Style & PB_STYLE_OUTLINE) { // // Outline the push button with the outline color. // GrContextForegroundSet(&sCtx, pPush->ui32OutlineColor); GrRectDraw(&sCtx, &(psWidget->sPosition)); } // // See if the push button text or image style is selected. // if(pPush->ui32Style & (PB_STYLE_TEXT | PB_STYLE_IMG)) { // // Compute the center of the push button. // i32X = (psWidget->sPosition.i16XMin + ((psWidget->sPosition.i16XMax - psWidget->sPosition.i16XMin + 1) / 2)); i32Y = (psWidget->sPosition.i16YMin + ((psWidget->sPosition.i16YMax - psWidget->sPosition.i16YMin + 1) / 2)); // // If the push button 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(pPush->ui32Style & PB_STYLE_OUTLINE) { sCtx.sClipRegion.i16XMin++; sCtx.sClipRegion.i16YMin++; sCtx.sClipRegion.i16XMax--; sCtx.sClipRegion.i16YMax--; } // // See if the push button image style is selected. // if(pPush->ui32Style & PB_STYLE_IMG) { // // Set the foreground and background colors to use for 1 BPP // images. // GrContextForegroundSet(&sCtx, pPush->ui32TextColor); GrContextBackgroundSet(&sCtx, ((pPush->ui32Style & PB_STYLE_PRESSED) ? pPush->ui32PressFillColor : pPush->ui32FillColor)); // // Get the image to be drawn. // pui8Image = (((pPush->ui32Style & PB_STYLE_PRESSED) && pPush->pui8PressImage) ? pPush->pui8PressImage : pPush->pui8Image); // // Draw the image centered in the push button. // GrImageDraw(&sCtx, pui8Image, i32X - (GrImageWidthGet(pui8Image) / 2), i32Y - (GrImageHeightGet(pui8Image) / 2)); } // // See if the push button text style is selected. // if(pPush->ui32Style & PB_STYLE_TEXT) { // // Draw the text centered in the middle of the push button. // GrContextFontSet(&sCtx, pPush->psFont); GrContextForegroundSet(&sCtx, pPush->ui32TextColor); GrContextBackgroundSet(&sCtx, ((pPush->ui32Style & PB_STYLE_PRESSED) ? pPush->ui32PressFillColor : pPush->ui32FillColor)); GrStringDrawCentered(&sCtx, pPush->pcText, -1, i32X, i32Y, pPush->ui32Style & PB_STYLE_TEXT_OPAQUE); } } }
//***************************************************************************** // //! Draws an image button. //! //! \param psWidget is a pointer to the image button widget to be drawn. //! //! This function draws a rectangular image button on the display. This is //! called in response to a \b #WIDGET_MSG_PAINT message. //! //! \return None. // //***************************************************************************** static void ImageButtonPaint(tWidget *psWidget) { const uint8_t *pui8Image; tImageButtonWidget *psPush; tContext sCtx; int32_t i32X, i32Y; // // Check the arguments. // ASSERT(psWidget); // // Convert the generic widget pointer into a image button widget pointer. // psPush = (tImageButtonWidget *)psWidget; // // Initialize a drawing context. // GrContextInit(&sCtx, psWidget->psDisplay); // // Initialize the clipping region based on the extents of this rectangular // image button. // GrContextClipRegionSet(&sCtx, &(psWidget->sPosition)); // // Compute the center of the image button. // i32X = (psWidget->sPosition.i16XMin + ((psWidget->sPosition.i16XMax - psWidget->sPosition.i16XMin + 1) / 2)); i32Y = (psWidget->sPosition.i16YMin + ((psWidget->sPosition.i16YMax - psWidget->sPosition.i16YMin + 1) / 2)); // // Do we need to fill the widget background with a color? // if(psPush->ui32Style & IB_STYLE_FILL) { // // Yes. Set the appropriate color depending upon whether or not // the widget is currently pressed. // GrContextForegroundSet(&sCtx, ((psPush->ui32Style & IB_STYLE_PRESSED) ? psPush->ui32PressedColor : psPush->ui32BackgroundColor)); GrRectFill(&sCtx, &(psWidget->sPosition)); } // // Set the foreground and background colors to use for 1 BPP // images and text // GrContextForegroundSet(&sCtx, psPush->ui32ForegroundColor); GrContextBackgroundSet(&sCtx, ((psPush->ui32Style & IB_STYLE_PRESSED) ? psPush->ui32PressedColor : psPush->ui32BackgroundColor)); // // Do we need to draw the background image? // if(!(psPush->ui32Style & IB_STYLE_IMAGE_OFF)) { // // Get the background image to be drawn. // pui8Image = ((psPush->ui32Style & IB_STYLE_PRESSED) ? psPush->pui8PressImage : psPush->pui8Image); // // Draw the image centered in the image button. // GrImageDraw(&sCtx, pui8Image, i32X - (GrImageWidthGet(pui8Image) / 2), i32Y - (GrImageHeightGet(pui8Image) / 2)); } // // Adjust the drawing position if the button is pressed. // i32X += ((psPush->ui32Style & IB_STYLE_PRESSED) ? psPush->i16XOffset : 0); i32Y += ((psPush->ui32Style & IB_STYLE_PRESSED) ? psPush->i16YOffset : 0); // // If there is a keycap image and it is not disabled, center this on the // top of the button, applying any offset defined if the button is // currently pressed. // if(psPush->pui8KeycapImage && !(psPush->ui32Style & IB_STYLE_KEYCAP_OFF)) { // // Draw the keycap image. // GrImageDraw(&sCtx, psPush->pui8KeycapImage, i32X - (GrImageWidthGet(psPush->pui8KeycapImage) / 2), i32Y - (GrImageHeightGet(psPush->pui8KeycapImage) / 2)); } // // See if the button text style is selected. // if(psPush->ui32Style & IB_STYLE_TEXT) { // // Draw the text centered in the middle of the button with offset // applied if the button is currently pressed. // GrContextFontSet(&sCtx, psPush->psFont); GrStringDrawCentered(&sCtx, psPush->pcText, -1, i32X, i32Y, 0); } }
//***************************************************************************** // //! Draws a radio button widget. //! //! \param pWidget 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 void RadioButtonPaint(tWidget *pWidget, int bClick) { tRadioButtonWidget *pRadio; tContext sCtx; long lX, lY; // // Convert the generic widget pointer into a radio button widget pointer. // pRadio = (tRadioButtonWidget *)pWidget; // // Initialize a drawing context. // GrContextInit(&sCtx, pWidget->pDisplay); // // Initialize the clipping region based on the extents of this radio // button. // GrContextClipRegionSet(&sCtx, &(pWidget->sPosition)); // // See if the radio button fill style is selected. // if((pRadio->usStyle & RB_STYLE_FILL) && !bClick) { // // Fill the radio button with the fill color. // GrContextForegroundSet(&sCtx, pRadio->ulFillColor); GrRectFill(&sCtx, &(pWidget->sPosition)); } // // See if the radio button outline style is selected. // if((pRadio->usStyle & RB_STYLE_OUTLINE) && !bClick) { // // Outline the radio button with the outline color. // GrContextForegroundSet(&sCtx, pRadio->ulOutlineColor); GrRectDraw(&sCtx, &(pWidget->sPosition)); } // // Draw the radio button. // lX = pWidget->sPosition.sXMin + (pRadio->usCircleSize / 2) + 2; lY = (pWidget->sPosition.sYMin + ((pWidget->sPosition.sYMax - pWidget->sPosition.sYMin) / 2)); if(!bClick) { GrContextForegroundSet(&sCtx, pRadio->ulOutlineColor); GrCircleDraw(&sCtx, lX, lY, pRadio->usCircleSize / 2); } // // Select the foreground color based on whether or not the radio button is // selected. // if(pRadio->usStyle & RB_STYLE_SELECTED) { GrContextForegroundSet(&sCtx, pRadio->ulOutlineColor); } else { GrContextForegroundSet(&sCtx, pRadio->ulFillColor); } // // Fill in the radio button. // GrCircleFill(&sCtx, lX, lY, (pRadio->usCircleSize / 2) - 2); // // See if the radio button text or image style is selected. // if((pRadio->usStyle & (RB_STYLE_TEXT | RB_STYLE_IMG)) && !bClick) { // // Shrink the clipping region by the size of the radio button so that // it is not overwritten by further "decorative" portions of the // widget. // sCtx.sClipRegion.sXMin += pRadio->usCircleSize + 4; // // If the radio button 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(pRadio->usStyle & RB_STYLE_OUTLINE) { sCtx.sClipRegion.sYMin++; sCtx.sClipRegion.sXMax--; sCtx.sClipRegion.sYMax--; } // // See if the radio button image style is selected. // if(pRadio->usStyle & RB_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(pRadio->pucImage) > (sCtx.sClipRegion.sYMax - sCtx.sClipRegion.sYMin)) { lY = sCtx.sClipRegion.sYMin; } else { lY = (sCtx.sClipRegion.sYMin + ((sCtx.sClipRegion.sYMax - sCtx.sClipRegion.sYMin - GrImageHeightGet(pRadio->pucImage) + 1) / 2)); } // // Set the foreground and background colors to use for 1 BPP // images. // GrContextForegroundSet(&sCtx, pRadio->ulTextColor); GrContextBackgroundSet(&sCtx, pRadio->ulFillColor); // // Draw the image next to the radio button. // GrImageDraw(&sCtx, pRadio->pucImage, sCtx.sClipRegion.sXMin, lY); } // // See if the radio button text style is selected. // if(pRadio->usStyle & RB_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(pRadio->pFont) > (sCtx.sClipRegion.sYMax - sCtx.sClipRegion.sYMin)) { lY = sCtx.sClipRegion.sYMin; } else { lY = (sCtx.sClipRegion.sYMin + ((sCtx.sClipRegion.sYMax - sCtx.sClipRegion.sYMin - GrFontHeightGet(pRadio->pFont) + 1) / 2)); } // // Draw the text next to the radio button. // GrContextFontSet(&sCtx, pRadio->pFont); GrContextForegroundSet(&sCtx, pRadio->ulTextColor); GrContextBackgroundSet(&sCtx, pRadio->ulFillColor); GrStringDraw(&sCtx, pRadio->pcText, -1, sCtx.sClipRegion.sXMin, lY, pRadio->usStyle & RB_STYLE_TEXT_OPAQUE); } } }