Animation : filling a rectangle with an ellipse

This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

  • Animation : filling a rectangle with an ellipse

    Hello.
    I need to play a little animation : I want to fill a rectangle at the bottom using an ellipse.

    Here is my code :


    GUI_SetColor(0);
    GUI_DrawRect(100,100,200,150);
    for (idx = 0; idx <100; idx++)
    {
    GUI_AA_FillEllipse(100+50,150+20-idx,50,20);
    GUI_ClearRect(100,151,200,350);
    GUI_ClearRect(100,0,200,99);
    GUI_Delay(50);
    }


    while(1);


    My Rectangle is filled , but I can see sometimes the ellipse before to be cleaned...
    I think I need to use 2 buffers or Memdev service but I don't know how I can use it.
    Is anybody can help me ?
    Thanks a lot in advance.

  • Hi,

    You can enable automatic use of memory devices by calling WM_SetCreateFlags(WM_CF_MEMDEV). Call this function before GUI_Init() so the desktop window (WM_HBKWIN) can make use of the memory devices, too.

    Here is a simple sample which does almost what you want. I use a window for the drawing operation and an animation for calculating the y-position for the ellipse. The filling process starts on a button press.

    C Source Code

    1. #include "DIALOG.h"
    3. #define ANIMATION_TIME 1000
    4. #define RADIUS_ELLIPSE 20
    6. static int _DoAnim;
    7. static int _AnimDir;
    8. static int _yPos;
    10. /*********************************************************************
    11. *
    12. * _AnimateWin
    13. */
    14. static void _AnimateWin(GUI_ANIM_INFO * pInfo, void * pVoid) {
    15. WM_HWIN hWin;
    16. int ySize;
    18. hWin = WM_GetFirstChild(WM_HBKWIN);
    19. ySize = WM_GetWindowSizeY(hWin) + RADIUS_ELLIPSE;
    20. //
    21. // Calculate the y-position for the ellipse
    22. //
    23. if (_AnimDir) {
    24. _yPos = ySize - ((ySize * pInfo->Pos) / GUI_ANIM_RANGE);
    25. } else {
    26. _yPos = (ySize * pInfo->Pos) / GUI_ANIM_RANGE;
    27. }
    28. switch (pInfo->State) {
    29. case GUI_ANIM_START:
    30. break;
    31. case GUI_ANIM_END:
    32. //
    33. // At the end of an animation we change the 'direction' for the next animation
    34. //
    35. _AnimDir = (_AnimDir) ? 0 : 1;
    36. break;
    37. }
    38. hWin = WM_GetFirstChild(WM_HBKWIN);
    39. WM_Invalidate(hWin);
    40. //
    41. // Avoid compiler warnings
    42. //
    43. GUI_USE_PARA(pVoid);
    44. }
    46. /*********************************************************************
    47. *
    48. * _cbWin
    49. */
    50. static void _cbWin(WM_MESSAGE * pMsg) {
    51. GUI_RECT Rect;
    53. switch (pMsg->MsgId) {
    54. case WM_PAINT:
    55. //
    56. // Set a back ground color and clear the window area with it.
    57. // It clears only the window area.
    58. //
    59. GUI_SetBkColor(GUI_BLACK);
    60. GUI_Clear();
    61. //
    62. // Receive client area of this window
    63. //
    64. WM_GetClientRect(&Rect);
    65. //
    66. // Set a foreground color and draw a frame and the ellipse at the calculated y-position.
    67. //
    68. GUI_SetColor(GUI_WHITE);
    69. GUI_DrawRectEx(&Rect);
    70. GUI_AA_FillEllipse(Rect.x1 / 2, Rect.y1 - _yPos + RADIUS_ELLIPSE, Rect.x1 / 2, RADIUS_ELLIPSE);
    71. //
    72. // The ellipse covers just a small area so we fill the rest with a restangle
    73. //
    74. GUI_FillRect(Rect.x0, Rect.y1 - _yPos + RADIUS_ELLIPSE, Rect.x1, Rect.y1);
    75. break;
    76. default:
    77. //
    78. // Any other messages are getting handled by the default callback
    79. //
    80. WM_DefaultProc(pMsg);
    81. break;
    82. }
    83. }
    85. /*********************************************************************
    86. *
    87. * _cbBk
    88. */
    89. static void _cbBk(WM_MESSAGE * pMsg) {
    90. int NCode;
    91. int Id;
    92. int xSize;
    93. int ySize;
    95. switch (pMsg->MsgId) {
    96. case WM_PAINT:
    97. GUI_Clear();
    98. break;
    99. case WM_NOTIFY_PARENT:
    100. Id = WM_GetId(pMsg->hWinSrc);
    101. NCode = pMsg->Data.v;
    102. switch(Id) {
    103. case GUI_ID_BUTTON0: // Notifications sent by 'Button'
    104. switch(NCode) {
    105. case WM_NOTIFICATION_CLICKED:
    106. break;
    107. case WM_NOTIFICATION_RELEASED:
    108. //
    109. // Set flag for starting animation
    110. //
    111. _DoAnim = 1;
    112. break;
    113. }
    114. break;
    115. }
    116. break;
    117. default:
    118. WM_DefaultProc(pMsg);
    119. break;
    120. }
    121. }
    123. /*********************************************************************
    124. *
    125. * Public code
    126. *
    127. **********************************************************************
    128. */
    129. /*********************************************************************
    130. *
    131. * MainTask()
    132. */
    133. void MainTask(void);
    134. void MainTask(void) {
    135. GUI_ANIM_HANDLE hAnim;
    136. WM_HWIN hWin;
    137. WM_HWIN hButton;
    139. //
    140. // Set create flag to use automatically memory devices, this is one way to avoid flickering.
    141. // Call this before GUI_Init() to set this flag for the desktop window, too. The desktop
    142. // window gets created in GUI_Init().
    143. //
    144. WM_SetCreateFlags(WM_CF_MEMDEV);
    145. GUI_Init();
    146. //
    147. // Set a callback for the desktop window. The callback handles the drawing of the window
    148. // and message send from the button.
    149. //
    150. WM_SetCallback(WM_HBKWIN, _cbBk);
    151. //
    152. // Create a simple window which does the drawing of the ellipse.
    153. //
    154. WM_CreateWindowAsChild(100, 100, 200, 150, WM_HBKWIN, WM_CF_SHOW, _cbWin, 0);
    155. //
    156. // Create a button as child of the desktop window. This button starts the animation.
    157. //
    158. hButton = BUTTON_CreateAsChild(10, 10, 60, 30, WM_HBKWIN, GUI_ID_BUTTON0, WM_CF_SHOW);
    159. BUTTON_SetText(hButton, "Start");
    160. while(1) {
    161. //
    162. // If the flag is set we create and start an animation
    163. //
    164. if (_DoAnim) {
    165. hAnim = GUI_ANIM_Create(ANIMATION_TIME, 10, 0, 0); // Create an animation which should last for the given time period.
    166. GUI_ANIM_AddItem(hAnim, 0, ANIMATION_TIME, ANIM_LINEAR, 0, _AnimateWin); // Add an animation item, this handles the calculation of an intensity.
    167. GUI_ANIM_Start(hAnim); // Start the animation
    168. while (GUI_ANIM_Exec(hAnim) == 0) { // As long as the animation lasts we call GUI_Delay(). This allows the
    169. GUI_Delay(5); // window manager to redraw the screen and other tasks can be escuted, too.
    170. }
    171. //
    172. // Once finished, delete animation and restore flag
    173. //
    174. GUI_ANIM_Delete(hAnim);
    175. _DoAnim = 0;
    176. } else {
    177. GUI_Delay(5);
    178. }
    179. }
    180. }
    Display All


    Regards,
    Sven
    Please read the forum rules before posting.

    Keep in mind, this is *not* a support forum.
    Our engineers will try to answer your questions between their projects if possible but this can be delayed by longer periods of time.
    Should you be entitled to support you can contact us via our support system: segger.com/ticket/
    Or you can contact us via e-mail.