Lcd companion boards support (VKLCD50RTA & VKLCD70RT)

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers rga_func.cpp Source File

rga_func.cpp

00001 /*
00002 Permission is hereby granted, free of charge, to any person obtaining a copy
00003 of this software and associated documentation files (the "Software"), to deal
00004 in the Software without restriction, including without limitation the rights
00005 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00006 copies of the Software, and to permit persons to whom the Software is
00007 furnished to do so, subject to the following conditions:
00008 
00009 The above copyright notice and this permission notice shall be included in
00010 all copies or substantial portions of the Software.
00011 
00012 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00013 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00014 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00015 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00016 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00017 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00018 THE SOFTWARE.
00019 */
00020 
00021 #include "mbed.h"
00022 #include "rga_func.h"
00023 #include "Images/BinaryImage_RZ_A1H.h"
00024 
00025 #define ZOOM_SRC_CENTER_X                   (IMAGE_WIDTH_ZOOM_FUNC / 2)
00026 #define ZOOM_SRC_CENTER_Y                   (IMAGE_HEIGHT_ZOOM_FUNC / 2)
00027 
00028 Canvas2D_ContextClass canvas2d;
00029 
00030 static animation_timing_function_t* accelerator;
00031 
00032 void Set_RGAObject(frame_buffer_t* frmbuf_info) {
00033     errnum_t err;
00034     Canvas2D_ContextConfigClass config;
00035 
00036     config.frame_buffer = frmbuf_info;
00037     canvas2d = R_RGA_New_Canvas2D_ContextClass(config);
00038     err = R_OSPL_GetErrNum();
00039     if (err != 0) {
00040         printf("Line %d, error %d\n", __LINE__, err);
00041         while (1);
00042     }
00043 }
00044 
00045 void RGA_Func_DrawFullScreen(frame_buffer_t* frmbuf_info, const graphics_image_t* image) {
00046 
00047     /* Draw a image */
00048     if(image)
00049         canvas2d.drawImage(image, 0, 0);
00050     else
00051     {
00052         /* Clear */
00053         canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00054         //canvas2d.fillStyle = "#000000";
00055         //canvas2d.fillRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00056     }
00057 
00058     /* Complete drawing */
00059     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00060 }
00061 
00062 void RGA_Func_DrawPNG(frame_buffer_t* frmbuf_info, const graphics_image_t* png_img, int x, int y) {
00063     /* Clear */
00064     //canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00065 
00066     /* Draw a image */
00067     if (frmbuf_info->pixel_format == PIXEL_FORMAT_RGB565)
00068         canvas2d.drawImage(png_img, x, y);  //png_ARGB4444 assumed
00069     //else
00070     //    canvas2d.drawImage(png_img, x, y);
00071 
00072     /* Complete drawing */
00073     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00074 }
00075 
00076 void RGA_Func_DrawCamScreen(uint8_t* cam_buffer) {
00077     /* Clear */
00078     //if(cam_buffer)
00079     //canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00080 
00081     /* Draw a image */
00082     if(cam_buffer)
00083         canvas2d.drawImage((graphics_image_t*)cam_buffer, 0, 0);
00084 
00085     /* Complete drawing */
00086     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00087 }
00088 
00089 #if (LCD_VDC5_CH0_PANEL == LCD_CH0_PANEL_VKLCD70RT)
00090 
00091 void RGA_Func_DrawRectangle(frame_buffer_t* frmbuf_info, draw_rectangle_pos_t * pos, int pos_num) {
00092     int cnt;
00093 
00094     /* Clear */
00095     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00096 
00097     /* Draw description */
00098     canvas2d.drawImage(decs_swipe_jpg_File, 294, 530);
00099 
00100     /* Draw rectangle */
00101     for (cnt = 0; cnt < pos_num; cnt++) {
00102         canvas2d.fillStyle = pos->style;
00103         canvas2d.fillRect(pos->x, pos->y, pos->w, pos->h);
00104         pos++;
00105     }
00106 
00107     /* Draw return button */
00108     canvas2d.drawImage(RetBtn_jpg_File, 792, 6);
00109 
00110     /* Complete drawing */
00111     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00112 }
00113 
00114 void RGA_Func_DrawImage(frame_buffer_t* frmbuf_info, int x, int y) {
00115     int draw_pos_x = x - (CRYSTAL_DIAMETER / 2);
00116     int draw_pos_y = y - (CRYSTAL_DIAMETER / 2);
00117 
00118     /* Clear */
00119     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00120 
00121     /* Draw description */
00122     canvas2d.drawImage(decs_board_jpg_File, 170, 55);
00123     canvas2d.drawImage(decs_swipe_jpg_File, 294, 530);
00124 
00125     /* Draw the first image */
00126     canvas2d.drawImage(Board_jpg_File, 106, 140);
00127 
00128     /* Draw the second image */
00129     if ((frmbuf_info->pixel_format == PIXEL_FORMAT_ARGB8888) || (frmbuf_info->pixel_format == PIXEL_FORMAT_XRGB8888)) {
00130         canvas2d.drawImage(Crystal_png_ARGB8888, draw_pos_x, draw_pos_y);
00131     } else if (frmbuf_info->pixel_format != PIXEL_FORMAT_YUV422) {
00132         canvas2d.drawImage(Crystal_png_ARGB4444, draw_pos_x, draw_pos_y);
00133     } else {
00134         canvas2d.drawImage(Crystal_png_File, draw_pos_x, draw_pos_y);
00135     }
00136 
00137     /* Draw return button */
00138     canvas2d.drawImage(RetBtn_jpg_File, 792, 6);
00139 
00140     /* Complete drawing */
00141     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00142 }
00143 
00144 void RGA_Func_Dissolve(frame_buffer_t* frmbuf_info, float32_t global_alpha, interact_t mode) {
00145     /* Dissolve = Fade Out + Fade In */
00146     /* Clear */
00147     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00148 
00149     /* Draw description */
00150     canvas2d.drawImage(decs_board_jpg_File, 170, 55);
00151     if(mode == AUTO_INTERACT)
00152     {
00153         canvas2d.drawImage(ManualBtn_jpg_File, 848, 230);
00154         canvas2d.drawImage(decs_wait_jpg_File, 405, 530);
00155     }
00156     else
00157     {
00158         canvas2d.drawImage(AutoBtn_jpg_File, 848, 230);
00159         canvas2d.drawImage(decs_swipe_side_jpg_File, 180, 530);
00160     }
00161 
00162     /* fade Out */
00163     canvas2d.globalAlpha = 1.0f - global_alpha;
00164     canvas2d.drawImage(Board_jpg_File, 106, 140);
00165 
00166     /* fade In */
00167     canvas2d.globalAlpha = global_alpha;
00168     canvas2d.fillStyle = "#FFFFFF";
00169     canvas2d.fillRect(106, 140, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT);
00170 
00171     canvas2d.globalAlpha = 1.0f;
00172 
00173     /* Draw return button */
00174     canvas2d.drawImage(RetBtn_jpg_File, 792, 6);
00175 
00176     /* Complete drawing */
00177     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00178 
00179 }
00180 
00181 void RGA_Func_Diss(frame_buffer_t* frmbuf_info, float32_t global_alpha, interact_t mode, graphics_image_t* image) {
00182     /* Dissolve = Fade Out + Fade In */
00183     static int prv_mode = mode;
00184     static int crsr = 0;
00185 
00186     if(!crsr)
00187         if(prv_mode != mode)
00188         {
00189             prv_mode = mode;
00190             crsr = 2;
00191         }
00192 
00193     if(crsr)
00194     {
00195         canvas2d.clearRect(0, 530, frmbuf_info->width, 44);
00196         if(mode == AUTO_INTERACT)
00197         {
00198             canvas2d.drawImage(ManualBtn_jpg_File, 848, 230);
00199             canvas2d.drawImage(decs_wait_jpg_File, 405, 530);
00200         }
00201         else
00202         {
00203             canvas2d.drawImage(AutoBtn_jpg_File, 848, 230);
00204             canvas2d.drawImage(decs_swipe_side_jpg_File, 180, 530);
00205         }
00206 
00207         crsr--;
00208     }
00209 
00210     /* fade Out */
00211     canvas2d.globalAlpha = 1.0f - global_alpha;
00212     canvas2d.drawImage(image, 106, 140);
00213 
00214     /* fade In */
00215     canvas2d.globalAlpha = global_alpha;
00216     canvas2d.fillStyle = "#FFFFFF";
00217     canvas2d.fillRect(106, 140, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT);
00218 
00219     canvas2d.globalAlpha = 1.0f;
00220 
00221     /* Complete drawing */
00222     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00223 }
00224 
00225 void RGA_Func_Scroll(frame_buffer_t* frmbuf_info, int src_width_pos,  interact_t mode) {
00226     /* Clear */
00227     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00228 
00229     /* Draw description */
00230     canvas2d.drawImage(decs_board_jpg_File, 170, 55);
00231     if(mode == AUTO_INTERACT)
00232     {
00233         canvas2d.drawImage(ManualBtn_jpg_File, 848, 230);
00234         canvas2d.drawImage(decs_wait_jpg_File, 405, 530);
00235     }
00236     else
00237     {
00238         canvas2d.drawImage(AutoBtn_jpg_File, 848, 230);
00239         canvas2d.drawImage(decs_swipe_side_jpg_File, 180, 530);
00240     }
00241 
00242     /* Scroll from left to right */
00243     canvas2d.drawImage(Board_wide_jpg_File,
00244                          /* src */       src_width_pos, 0, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT,
00245                          /* dst */       106, 140, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT);
00246 
00247     /* Draw return button */
00248     canvas2d.drawImage(RetBtn_jpg_File, 792, 6);
00249 
00250     /* Complete drawing */
00251     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00252 }
00253 
00254 void RGA_Func_Scr(frame_buffer_t* frmbuf_info, int src_width_pos, interact_t mode, graphics_image_t* image) {
00255     static int prv_mode = mode;
00256     static int crsr = 0;
00257 
00258     if(!crsr)
00259         if(prv_mode != mode)
00260         {
00261             prv_mode = mode;
00262             crsr = 2;
00263         }
00264 
00265     if(crsr)
00266     {
00267         canvas2d.clearRect(0, 530, frmbuf_info->width, 44);
00268         if(mode == AUTO_INTERACT)
00269         {
00270             canvas2d.drawImage(ManualBtn_jpg_File, 848, 230);
00271             canvas2d.drawImage(decs_wait_jpg_File, 405, 530);
00272         }
00273         else
00274         {
00275             canvas2d.drawImage(AutoBtn_jpg_File, 848, 230);
00276             canvas2d.drawImage(decs_swipe_side_jpg_File, 180, 530);
00277         }
00278         crsr--;
00279     }
00280 
00281     /* Scroll from left to right */
00282     canvas2d.drawImage(image,
00283                         /* src */       src_width_pos, 0, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT,
00284                         /* dst */       106, 140, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT);
00285 
00286     /* Complete drawing */
00287     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00288 }
00289 
00290 void RGA_Func_Zoom(frame_buffer_t* frmbuf_info, int src_height_pos, interact_t mode) {
00291     /* Clear */
00292     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00293 
00294     /* Draw description */
00295     canvas2d.drawImage(decs_board_jpg_File, 170, 55);
00296     if(mode == AUTO_INTERACT)
00297     {
00298         canvas2d.drawImage(ManualBtn_jpg_File, 848, 230);
00299         canvas2d.drawImage(decs_wait_jpg_File, 405, 530);
00300     }
00301     else
00302     {
00303         canvas2d.drawImage(AutoBtn_jpg_File, 848, 230);
00304         canvas2d.drawImage(decs_swipe_side_jpg_File, 180, 530);
00305     }
00306 
00307     /* Zoom out */
00308     canvas2d.drawImage(Board_jpg_File,
00309                        /* src X */     ZOOM_SRC_CENTER_X - (src_height_pos * IMG_DRAW_WIDTH / IMG_DRAW_HEIGHT),
00310                        /* src Y */     ZOOM_SRC_CENTER_Y - src_height_pos,
00311                        /* src W */     src_height_pos * 2 * IMG_DRAW_WIDTH / IMG_DRAW_HEIGHT,
00312                        /* src H */     src_height_pos * 2,
00313                        /* dst   */     106, 140, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT);
00314 
00315     /* Draw return button */
00316     canvas2d.drawImage(RetBtn_jpg_File, 792, 6);
00317 
00318     /* Complete drawing */
00319     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00320 }
00321 
00322 
00323 void RGA_Func_Zo(frame_buffer_t* frmbuf_info, int src_height_pos, interact_t mode, graphics_image_t* image) {
00324     static int prv_mode = mode;
00325     static int crsr = 0;
00326 
00327     if(!crsr)
00328     if(prv_mode != mode)
00329     {
00330         prv_mode = mode;
00331         crsr = 2;
00332     }
00333 
00334     if(crsr)
00335     {
00336         canvas2d.clearRect(0, 530, frmbuf_info->width, 44);
00337         if(mode == AUTO_INTERACT)
00338         {
00339             canvas2d.drawImage(ManualBtn_jpg_File, 848, 230);
00340             canvas2d.drawImage(decs_wait_jpg_File, 405, 530);
00341         }
00342         else
00343         {
00344             canvas2d.drawImage(AutoBtn_jpg_File, 848, 230);
00345             canvas2d.drawImage(decs_swipe_side_jpg_File, 180, 530);
00346         }
00347         crsr--;
00348     }
00349 
00350     /* Zoom out */
00351     canvas2d.drawImage(image,
00352                         /* src X */     ZOOM_SRC_CENTER_X - (src_height_pos * IMG_DRAW_WIDTH / IMG_DRAW_HEIGHT),
00353                         /* src Y */     ZOOM_SRC_CENTER_Y - src_height_pos,
00354                         /* src W */     src_height_pos * 2 * IMG_DRAW_WIDTH / IMG_DRAW_HEIGHT,
00355                         /* src H */     src_height_pos * 2,
00356                         /* dst   */     106, 140, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT);
00357 
00358     /* Complete drawing */
00359     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00360 }
00361 
00362 void RGA_Func_Rotation(frame_buffer_t* frmbuf_info, graphics_matrix_float_t image_angle, interact_t mode) {
00363     /* Rotate the image to the right */
00364     /* Clear */
00365     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00366 
00367     /* Draw description */
00368     canvas2d.drawImage(decs_board_jpg_File, 650, 143);
00369     if(mode == AUTO_INTERACT)
00370     {
00371         canvas2d.drawImage(ManualBtn_jpg_File, 848, 230);
00372         canvas2d.drawImage(decs_wait_jpg_File, 704, 530);
00373     }
00374     else
00375     {
00376         canvas2d.drawImage(AutoBtn_jpg_File, 848, 230);
00377         canvas2d.drawImage(decs_swipe_side_jpg_File,   0, 0, 238, 42, 704, 397, 238, 42);
00378         canvas2d.drawImage(decs_swipe_side_jpg_File, 241, 0, 198, 42, 714, 463, 198, 42);
00379         canvas2d.drawImage(decs_swipe_side_jpg_File, 439, 0, 234, 42, 693, 530, 234, 42);
00380     }
00381 
00382     /* Move to drawing position */
00383     canvas2d.translate((100 + (IMG_DRAW_WIDTH / 2)), (140 + (IMG_DRAW_HEIGHT / 2)));
00384 
00385     /* Rotate */
00386     canvas2d.rotate(image_angle * (3.14159 / 180));
00387 
00388     /* Move to center to rotate */
00389     canvas2d.translate((-IMG_DRAW_WIDTH / 2), (-IMG_DRAW_HEIGHT / 2));
00390     canvas2d.drawImage(Board_jpg_File, 0, 0);
00391     canvas2d.setTransform(1, 0, 0, 1, 0, 0);
00392 
00393     /* Draw return button */
00394     canvas2d.drawImage(RetBtn_jpg_File, 792, 6);
00395 
00396     /* Complete drawing */
00397     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00398 }
00399 
00400 void RGA_Func_Rotor(frame_buffer_t* frmbuf_info, graphics_matrix_float_t image_angle, interact_t mode, graphics_image_t* image) {
00401     /* Rotate the image to the right */
00402     static int prv_mode = mode;
00403     static int crsr = 0;
00404 
00405     if(!crsr)
00406         if(prv_mode != mode)
00407         {
00408             prv_mode = mode;
00409             crsr = 2;
00410         }
00411 
00412     if(crsr)
00413     {
00414         if(mode == AUTO_INTERACT)
00415         {
00416             canvas2d.drawImage(ManualBtn_jpg_File, 848, 230);
00417             canvas2d.clearRect(704, 397, 341, 198);
00418             canvas2d.drawImage(decs_wait_jpg_File, 704, 530);
00419         }
00420         else
00421         {
00422             canvas2d.drawImage(AutoBtn_jpg_File, 848, 230);
00423             canvas2d.drawImage(decs_swipe_side_jpg_File,   0, 0, 238, 42, 704, 397, 238, 42);
00424             canvas2d.drawImage(decs_swipe_side_jpg_File, 241, 0, 198, 42, 714, 463, 198, 42);
00425             canvas2d.drawImage(decs_swipe_side_jpg_File, 439, 0, 234, 42, 693, 530, 234, 42);
00426         }
00427         crsr--;
00428     }
00429 
00430     /* Clear [6ms] */
00431     canvas2d.clearRect(0, 0, 90+(IMG_DRAW_WIDTH / 2)+(frmbuf_info->height / 2), frmbuf_info->height);
00432 
00433     /* Move to drawing position [1ms]*/
00434     canvas2d.translate((100 + (IMG_DRAW_WIDTH / 2)), (140 + (IMG_DRAW_HEIGHT / 2)));
00435 
00436     /* Rotate [2ms]*/
00437     canvas2d.rotate(image_angle * (3.14159 / 180));
00438 
00439     /* Move to center to rotate [0,5 + 120 + 1ms]*/
00440     canvas2d.translate((-IMG_DRAW_WIDTH / 2), (-IMG_DRAW_HEIGHT / 2));
00441     canvas2d.drawImage(image, 0, 0);
00442     canvas2d.setTransform(1, 0, 0, 1, 0, 0);
00443 
00444     /* Complete drawing [4ms]*/
00445     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00446 }
00447 
00448 void RGA_Func_Accelerate(frame_buffer_t* frmbuf_info, int animation_timing, float32_t relative_pos) {
00449     /* Do accelerated motion from right to left */
00450     int position;
00451 
00452     /* Clear */
00453     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00454 
00455     /* Draw description */
00456     canvas2d.drawImage(decs_board_jpg_File, 170, 55);
00457 
00458     if (relative_pos == 0.0f) {
00459         switch (animation_timing) {
00460             case ANIMATION_TIMING_EASE:
00461                 R_Get_AnimationTimingFunction("ease", &accelerator);
00462                 break;
00463             case ANIMATION_TIMING_LINEAR:
00464                 R_Get_AnimationTimingFunction("linear", &accelerator);
00465                 break;
00466             case ANIMATION_TIMING_EASE_IN:
00467                 R_Get_AnimationTimingFunction("ease-in", &accelerator);
00468                 break;
00469             case ANIMATION_TIMING_EASE_OUT:
00470                 R_Get_AnimationTimingFunction("ease-out", &accelerator);
00471                 break;
00472             case ANIMATION_TIMING_EASE_IN_OUT:
00473             default:
00474                 R_Get_AnimationTimingFunction("ease-in-out", &accelerator);
00475                 break;
00476         }
00477     }
00478 
00479     /* Draw rectangle */
00480     canvas2d.fillStyle = "#0000FF";  /* blue */
00481     switch (animation_timing) {
00482         case ANIMATION_TIMING_EASE:
00483             canvas2d.fillRect(21, 562, 173, 13);
00484             break;
00485         case ANIMATION_TIMING_LINEAR:
00486             canvas2d.fillRect(220, 562, 173, 13);
00487             break;
00488         case ANIMATION_TIMING_EASE_IN:
00489             canvas2d.fillRect(422, 562, 173, 13);
00490             break;
00491         case ANIMATION_TIMING_EASE_OUT:
00492             canvas2d.fillRect(623, 562, 173, 13);
00493             break;
00494         case ANIMATION_TIMING_EASE_IN_OUT:
00495         default:
00496             canvas2d.fillRect(823, 562, 173, 13);
00497             break;
00498     }
00499 
00500     /* Draw button */
00501     canvas2d.drawImage(animetion_timing_jpg_File, 0, 496);
00502 
00503     position = R_ANIMATION_TIMING_FUNCTION_GetValue(accelerator, relative_pos, 505.0f, 6.0f);
00504     canvas2d.drawImage(Board_jpg_File, position, 140);
00505 
00506     /* Draw return button */
00507     canvas2d.drawImage(RetBtn_jpg_File, 792, 6);
00508 
00509     /* Complete drawing */
00510     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00511 }
00512 
00513 void RGA_Func_Axel(frame_buffer_t* frmbuf_info, int animation_timing, float32_t relative_pos, graphics_image_t* image) {
00514     /* Do accelerated motion from right to left */
00515         static int prv_timing = animation_timing;
00516         static int crsr = 0;
00517         int position;
00518 
00519         /* Clear */
00520         canvas2d.clearRect(0, 140, frmbuf_info->width, IMG_DRAW_HEIGHT);
00521 
00522         if (relative_pos == 0.0f) {
00523             switch (animation_timing) {
00524                 case ANIMATION_TIMING_EASE:
00525                     R_Get_AnimationTimingFunction("ease", &accelerator);
00526                     break;
00527                 case ANIMATION_TIMING_LINEAR:
00528                     R_Get_AnimationTimingFunction("linear", &accelerator);
00529                     break;
00530                 case ANIMATION_TIMING_EASE_IN:
00531                     R_Get_AnimationTimingFunction("ease-in", &accelerator);
00532                     break;
00533                 case ANIMATION_TIMING_EASE_OUT:
00534                     R_Get_AnimationTimingFunction("ease-out", &accelerator);
00535                     break;
00536                 case ANIMATION_TIMING_EASE_IN_OUT:
00537                 default:
00538                     R_Get_AnimationTimingFunction("ease-in-out", &accelerator);
00539                     break;
00540             }
00541             if(prv_timing != animation_timing)
00542             {
00543                 prv_timing = animation_timing;
00544                 crsr = 2;
00545             }
00546         }
00547 
00548         /* Draw rectangle */
00549         canvas2d.fillStyle = "#0000FF";  /* blue */
00550         switch (animation_timing) {
00551             case ANIMATION_TIMING_EASE:
00552                 if(crsr)
00553                 {
00554                     canvas2d.clearRect(0, 563, frmbuf_info->width, 13);
00555                     canvas2d.fillRect(21, 563, 173, 13);
00556                 }
00557                 break;
00558             case ANIMATION_TIMING_LINEAR:
00559                 if(crsr)
00560                 {
00561                     canvas2d.clearRect(0, 563, frmbuf_info->width, 13);
00562                     canvas2d.fillRect(220, 563, 173, 13);
00563                 }
00564                 break;
00565             case ANIMATION_TIMING_EASE_IN:
00566                 if(crsr)
00567                 {
00568                     canvas2d.clearRect(0, 563, frmbuf_info->width, 13);
00569                     canvas2d.fillRect(422, 563, 173, 13);
00570                 }
00571                 break;
00572             case ANIMATION_TIMING_EASE_OUT:
00573                 if(crsr)
00574                 {
00575                     canvas2d.clearRect(0, 563, frmbuf_info->width, 13);
00576                     canvas2d.fillRect(623, 563, 173, 13);
00577                 }
00578                 break;
00579             case ANIMATION_TIMING_EASE_IN_OUT:
00580             default:
00581                 if(crsr)
00582                 {
00583                     canvas2d.clearRect(0, 563, frmbuf_info->width, 13);
00584                     canvas2d.fillRect(823, 563, 173, 13);
00585                 }
00586                 break;
00587         }
00588 
00589         /* Draw button */
00590         if(crsr)
00591         {
00592             canvas2d.drawImage(animetion_timing_jpg_File, 0, 496);
00593             crsr--;
00594         }
00595 
00596         position = R_ANIMATION_TIMING_FUNCTION_GetValue(accelerator, relative_pos, 505.0f, 6.0f);
00597         canvas2d.drawImage(image, position, 140);
00598 
00599         /* Complete drawing */
00600         R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00601 }
00602 
00603 bool RGA_Func_CheckPorts(frame_buffer_t* frmbuf_info, bool rca_pluged, bool usb_pluged) {
00604     static bool rca_visible = false;
00605     static bool usb_visible = false;
00606     bool rca_changed = false;
00607     bool usb_changed = false;
00608 
00609     /* Detect Change in ports status */
00610     if(rca_pluged ^ rca_visible)
00611     {
00612         rca_visible = rca_pluged;
00613         rca_changed = true;
00614     }
00615 
00616     if(usb_pluged ^ usb_visible)
00617     {
00618         usb_visible = usb_pluged;
00619         usb_changed = true;
00620     }
00621 
00622     if(rca_changed | usb_changed)
00623     {
00624         frmbuf_info->draw_buffer_index = (frmbuf_info->draw_buffer_index)? 0 : 1;
00625 
00626         /* Draw a image Clear */
00627         canvas2d.drawImage(TopScrn_jpg_File, 0, 0);
00628 
00629         if(rca_visible)
00630             canvas2d.drawImage(RCA_jpg_File, (frmbuf_info->width/2)-160, 50);
00631 
00632         if(usb_visible)
00633             canvas2d.drawImage(Usb_jpg_File, frmbuf_info->width-100, (frmbuf_info->height/2)-73);
00634 
00635         /* Complete drawing */
00636         R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00637     }
00638 
00639     return (rca_changed | usb_changed);
00640 }
00641 #else
00642 
00643 void RGA_Func_DrawRectangle(frame_buffer_t* frmbuf_info, draw_rectangle_pos_t * pos, int pos_num) {
00644     int cnt;
00645 
00646     /* Clear */
00647     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00648 
00649     /* Draw description */
00650     canvas2d.drawImage(decs_swipe_jpg_File, 138, 240);
00651 
00652     /* Draw rectangle */
00653     for (cnt = 0; cnt < pos_num; cnt++) {
00654         canvas2d.fillStyle = pos->style;
00655         canvas2d.fillRect(pos->x, pos->y, pos->w, pos->h);
00656         pos++;
00657     }
00658 
00659     /* Draw return button */
00660     canvas2d.drawImage(RetBtn_jpg_File, 368, 6);
00661 
00662     /* Complete drawing */
00663     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00664 }
00665 
00666 void RGA_Func_DrawImage(frame_buffer_t* frmbuf_info, int x, int y) {
00667     int draw_pos_x = x - (CRYSTAL_DIAMETER / 2);
00668     int draw_pos_y = y - (CRYSTAL_DIAMETER / 2);
00669 
00670     /* Clear */
00671     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00672 
00673     /* Draw description */
00674     canvas2d.drawImage(decs_board_jpg_File, 80, 25);
00675     canvas2d.drawImage(decs_swipe_jpg_File, 138, 240);
00676 
00677     /* Draw the first image */
00678     canvas2d.drawImage(Board_jpg_File, 50, 65);
00679 
00680     /* Draw the second image */
00681     if ((frmbuf_info->pixel_format == PIXEL_FORMAT_ARGB8888) || (frmbuf_info->pixel_format == PIXEL_FORMAT_XRGB8888)) {
00682         canvas2d.drawImage(Crystal_png_ARGB8888, draw_pos_x, draw_pos_y);
00683     } else if (frmbuf_info->pixel_format != PIXEL_FORMAT_YUV422) {
00684         canvas2d.drawImage(Crystal_png_ARGB4444, draw_pos_x, draw_pos_y);
00685     } else {
00686         canvas2d.drawImage(Crystal_png_File, draw_pos_x, draw_pos_y);
00687     }
00688 
00689     /* Draw return button */
00690     canvas2d.drawImage(RetBtn_jpg_File, 368, 6);
00691 
00692     /* Complete drawing */
00693     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00694 }
00695 
00696 void RGA_Func_Dissolve(frame_buffer_t* frmbuf_info, float32_t global_alpha, interact_t mode) {
00697     /* Dissolve = Fade Out + Fade In */
00698     /* Clear */
00699     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00700 
00701     /* Draw description */
00702     canvas2d.drawImage(decs_board_jpg_File, 80, 25);
00703     if(mode == AUTO_INTERACT)
00704     {
00705         canvas2d.drawImage(ManualBtn_jpg_File, 398, 104);
00706         canvas2d.drawImage(decs_wait_jpg_File, 190, 240);
00707     }
00708     else
00709     {
00710         canvas2d.drawImage(AutoBtn_jpg_File, 398, 104);
00711         canvas2d.drawImage(decs_swipe_side_jpg_File, 84, 240);
00712     }
00713 
00714     /* fade Out */
00715     canvas2d.globalAlpha = 1.0f - global_alpha;
00716     canvas2d.drawImage(Board_jpg_File, 50, 65);
00717 
00718     /* fade In */
00719     canvas2d.globalAlpha = global_alpha;
00720     canvas2d.fillStyle = "#FFFFFF";
00721     canvas2d.fillRect(50, 65, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT);
00722 
00723     canvas2d.globalAlpha = 1.0f;
00724 
00725     /* Draw return button */
00726     canvas2d.drawImage(RetBtn_jpg_File, 368, 6);
00727 
00728     /* Complete drawing */
00729     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00730 }
00731 
00732 void RGA_Func_Diss(frame_buffer_t* frmbuf_info, float32_t global_alpha, interact_t mode, graphics_image_t* image) {
00733     /* Dissolve = Fade Out + Fade In */
00734     static int prv_mode = mode;
00735     static int crsr = 0;
00736 
00737     if(!crsr)
00738         if(prv_mode != mode)
00739         {
00740             prv_mode = mode;
00741             crsr = 2;
00742         }
00743 
00744     if(crsr)
00745     {
00746         canvas2d.clearRect(0, 240, frmbuf_info->width, 20);
00747         if(mode == AUTO_INTERACT)
00748         {
00749             canvas2d.drawImage(ManualBtn_jpg_File, 398, 104);
00750             canvas2d.drawImage(decs_wait_jpg_File, 190, 240);
00751         }
00752         else
00753         {
00754             canvas2d.drawImage(AutoBtn_jpg_File, 398, 104);
00755             canvas2d.drawImage(decs_swipe_side_jpg_File, 84, 240);
00756         }
00757 
00758         crsr--;
00759     }
00760 
00761     /* fade Out */
00762     canvas2d.globalAlpha = 1.0f - global_alpha;
00763     canvas2d.drawImage(image, 50, 65);
00764 
00765     /* fade In */
00766     canvas2d.globalAlpha = global_alpha;
00767     canvas2d.fillStyle = "#FFFFFF";
00768     canvas2d.fillRect(50, 65, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT);
00769 
00770     canvas2d.globalAlpha = 1.0f;
00771 
00772     /* Complete drawing */
00773     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00774 }
00775 
00776 void RGA_Func_Scroll(frame_buffer_t* frmbuf_info, int src_width_pos, interact_t mode) {
00777     /* Clear */
00778     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00779 
00780     /* Draw description */
00781     canvas2d.drawImage(decs_board_jpg_File, 80, 25);
00782     if(mode == AUTO_INTERACT)
00783     {
00784         canvas2d.drawImage(ManualBtn_jpg_File, 398, 104);
00785         canvas2d.drawImage(decs_wait_jpg_File, 190, 240);
00786     }
00787     else
00788     {
00789         canvas2d.drawImage(AutoBtn_jpg_File, 398, 104);
00790         canvas2d.drawImage(decs_swipe_side_jpg_File, 84, 240);
00791     }
00792 
00793     /* Scroll from left to right */
00794     canvas2d.drawImage(Board_wide_jpg_File,
00795                         /* src */       src_width_pos, 0, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT,
00796                         /* dst */       50, 65, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT);
00797 
00798     /* Draw return button */
00799     canvas2d.drawImage(RetBtn_jpg_File, 368, 6);
00800 
00801     /* Complete drawing */
00802     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00803 }
00804 
00805 void RGA_Func_Scr(frame_buffer_t* frmbuf_info, int src_width_pos, interact_t mode, graphics_image_t* image) {
00806     static int prv_mode = mode;
00807     static int crsr = 0;
00808 
00809     if(!crsr)
00810         if(prv_mode != mode)
00811         {
00812             prv_mode = mode;
00813             crsr = 2;
00814         }
00815 
00816     if(crsr)
00817     {
00818         canvas2d.clearRect(0, 240, frmbuf_info->width, 20);
00819         if(mode == AUTO_INTERACT)
00820         {
00821             canvas2d.drawImage(ManualBtn_jpg_File, 398, 104);
00822             canvas2d.drawImage(decs_wait_jpg_File, 190, 240);
00823         }
00824         else
00825         {
00826             canvas2d.drawImage(AutoBtn_jpg_File, 398, 104);
00827             canvas2d.drawImage(decs_swipe_side_jpg_File, 84, 240);
00828         }
00829         crsr--;
00830     }
00831 
00832     /* Scroll from left to right */
00833     canvas2d.drawImage(image,
00834                         /* src */       src_width_pos, 0, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT,
00835                         /* dst */       50, 65, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT);
00836 
00837     /* Complete drawing */
00838     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00839 }
00840 
00841 void RGA_Func_Zoom(frame_buffer_t* frmbuf_info, int src_height_pos, interact_t mode) {
00842     /* Clear */
00843     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00844 
00845     /* Draw description */
00846     canvas2d.drawImage(decs_board_jpg_File, 80, 25);
00847     if(mode == AUTO_INTERACT)
00848     {
00849         canvas2d.drawImage(ManualBtn_jpg_File, 398, 104);
00850         canvas2d.drawImage(decs_wait_jpg_File, 190, 240);
00851     }
00852     else
00853     {
00854         canvas2d.drawImage(AutoBtn_jpg_File, 398, 104);
00855         canvas2d.drawImage(decs_swipe_side_jpg_File, 84, 240);
00856     }
00857 
00858     /* Zoom out */
00859     canvas2d.drawImage(Board_jpg_File,
00860                         /* src X */     ZOOM_SRC_CENTER_X - (src_height_pos * IMG_DRAW_WIDTH / IMG_DRAW_HEIGHT),
00861                         /* src Y */     ZOOM_SRC_CENTER_Y - src_height_pos,
00862                         /* src W */     src_height_pos * 2 * IMG_DRAW_WIDTH / IMG_DRAW_HEIGHT,
00863                         /* src H */     src_height_pos * 2,
00864                         /* dst   */     50, 65, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT);
00865 
00866     /* Draw return button */
00867     canvas2d.drawImage(RetBtn_jpg_File, 368, 6);
00868 
00869     /* Complete drawing */
00870     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00871 }
00872 
00873 void RGA_Func_Zo(frame_buffer_t* frmbuf_info, int src_height_pos, interact_t mode, graphics_image_t* image) {
00874     static int prv_mode = mode;
00875     static int crsr = 0;
00876 
00877     if(!crsr)
00878     if(prv_mode != mode)
00879     {
00880         prv_mode = mode;
00881         crsr = 2;
00882     }
00883 
00884     if(crsr)
00885     {
00886         canvas2d.clearRect(0, 240, frmbuf_info->width, 20);
00887         if(mode == AUTO_INTERACT)
00888         {
00889             canvas2d.drawImage(ManualBtn_jpg_File, 398, 104);
00890             canvas2d.drawImage(decs_wait_jpg_File, 190, 240);
00891         }
00892         else
00893         {
00894             canvas2d.drawImage(AutoBtn_jpg_File, 398, 104);
00895             canvas2d.drawImage(decs_swipe_side_jpg_File, 84, 240);
00896         }
00897         crsr--;
00898     }
00899 
00900     /* Zoom out */
00901     canvas2d.drawImage(image,
00902                         /* src X */     ZOOM_SRC_CENTER_X - (src_height_pos * IMG_DRAW_WIDTH / IMG_DRAW_HEIGHT),
00903                         /* src Y */     ZOOM_SRC_CENTER_Y - src_height_pos,
00904                         /* src W */     src_height_pos * 2 * IMG_DRAW_WIDTH / IMG_DRAW_HEIGHT,
00905                         /* src H */     src_height_pos * 2,
00906                         /* dst   */     50, 65, IMG_DRAW_WIDTH, IMG_DRAW_HEIGHT);
00907 
00908     /* Complete drawing */
00909     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00910 }
00911 
00912 void RGA_Func_Rotation(frame_buffer_t* frmbuf_info, graphics_matrix_float_t image_angle, interact_t mode) {
00913     /* Rotate the image to the right */
00914     /* Clear */
00915     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
00916 
00917     /* Draw description */
00918     canvas2d.drawImage(decs_board_jpg_File, 305, 65);
00919     if(mode == AUTO_INTERACT)
00920     {
00921         canvas2d.drawImage(ManualBtn_jpg_File, 398, 104);
00922         canvas2d.drawImage(decs_wait_jpg_File, 330, 240);
00923     }
00924     else
00925     {
00926         canvas2d.drawImage(AutoBtn_jpg_File, 398, 104);
00927         canvas2d.drawImage(decs_swipe_side_jpg_File,   0, 0, 112, 19, 330, 180, 112, 19);
00928         canvas2d.drawImage(decs_swipe_side_jpg_File, 113, 0, 93,  19, 335, 210,  93, 19);
00929         canvas2d.drawImage(decs_swipe_side_jpg_File, 206, 0, 110, 19, 325, 240, 110, 19);
00930     }
00931 
00932     /* Move to drawing position */
00933     canvas2d.translate((50 + (IMG_DRAW_WIDTH / 2)), (65 + (IMG_DRAW_HEIGHT / 2)));
00934 
00935     /* Rotate */
00936     canvas2d.rotate(image_angle * (3.14159 / 180));
00937 
00938     /* Move to center to rotate */
00939     canvas2d.translate((-IMG_DRAW_WIDTH / 2), (-IMG_DRAW_HEIGHT / 2));
00940     canvas2d.drawImage(Board_jpg_File, 0, 0);
00941     canvas2d.setTransform(1, 0, 0, 1, 0, 0);
00942 
00943     /* Draw return button */
00944     canvas2d.drawImage(RetBtn_jpg_File, 368, 6);
00945 
00946     /* Complete drawing */
00947     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00948 }
00949 
00950 void RGA_Func_Rotor(frame_buffer_t* frmbuf_info, graphics_matrix_float_t image_angle, interact_t mode, graphics_image_t* image) {
00951     /* Rotate the image to the right */
00952     static int prv_mode = mode;
00953     static int crsr = 0;
00954 
00955     if(!crsr)
00956         if(prv_mode != mode)
00957         {
00958             prv_mode = mode;
00959             crsr = 2;
00960         }
00961 
00962     if(crsr)
00963     {
00964         //canvas2d.clearRect(0, 240, frmbuf_info->width, 20);
00965         if(mode == AUTO_INTERACT)
00966         {
00967             canvas2d.drawImage(ManualBtn_jpg_File, 398, 104);
00968             canvas2d.clearRect(330, 180, 160, 90);
00969             canvas2d.drawImage(decs_wait_jpg_File, 330, 240);
00970         }
00971         else
00972         {
00973             canvas2d.drawImage(AutoBtn_jpg_File, 398, 104);
00974             canvas2d.drawImage(decs_swipe_side_jpg_File,   0, 0, 112, 19, 330, 180, 112, 19);
00975             canvas2d.drawImage(decs_swipe_side_jpg_File, 113, 0, 93,  19, 335, 210,  93, 19);
00976             canvas2d.drawImage(decs_swipe_side_jpg_File, 206, 0, 110, 19, 325, 240, 110, 19);
00977         }
00978         crsr--;
00979     }
00980 
00981     /* Clear [6ms] */
00982     canvas2d.clearRect(0, 0, 50+(IMG_DRAW_WIDTH / 2)+(frmbuf_info->height / 2), frmbuf_info->height);
00983 
00984     /* Move to drawing position [1ms]*/
00985     canvas2d.translate((50 + (IMG_DRAW_WIDTH / 2)), (65 + (IMG_DRAW_HEIGHT / 2)));
00986 
00987     /* Rotate [2ms]*/
00988     canvas2d.rotate(image_angle * (3.14159 / 180));
00989 
00990     /* Move to center to rotate [0,5 + 120 + 1ms]*/
00991     canvas2d.translate((-IMG_DRAW_WIDTH / 2), (-IMG_DRAW_HEIGHT / 2));
00992     canvas2d.drawImage(image, 0, 0);
00993     canvas2d.setTransform(1, 0, 0, 1, 0, 0);
00994 
00995     /* Complete drawing [4ms]*/
00996     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
00997 }
00998 
00999 void RGA_Func_Accelerate(frame_buffer_t* frmbuf_info, int animation_timing, float32_t relative_pos) {
01000     /* Do accelerated motion from right to left */
01001     int position;
01002 
01003     /* Clear */
01004     canvas2d.clearRect(0, 0, frmbuf_info->width, frmbuf_info->height);
01005 
01006     /* Draw description */
01007     canvas2d.drawImage(decs_board_jpg_File, 80, 25);
01008 
01009     if (relative_pos == 0.0f) {
01010         switch (animation_timing) {
01011             case ANIMATION_TIMING_EASE:
01012                 R_Get_AnimationTimingFunction("ease", &accelerator);
01013                 break;
01014             case ANIMATION_TIMING_LINEAR:
01015                 R_Get_AnimationTimingFunction("linear", &accelerator);
01016                 break;
01017             case ANIMATION_TIMING_EASE_IN:
01018                 R_Get_AnimationTimingFunction("ease-in", &accelerator);
01019                 break;
01020             case ANIMATION_TIMING_EASE_OUT:
01021                 R_Get_AnimationTimingFunction("ease-out", &accelerator);
01022                 break;
01023             case ANIMATION_TIMING_EASE_IN_OUT:
01024             default:
01025                 R_Get_AnimationTimingFunction("ease-in-out", &accelerator);
01026                 break;
01027         }
01028     }
01029 
01030     /* Draw rectangle */
01031     canvas2d.fillStyle = "#0000FF";  /* blue */
01032     switch (animation_timing) {
01033         case ANIMATION_TIMING_EASE:
01034             canvas2d.fillRect(10, 255, 81, 6);
01035             break;
01036         case ANIMATION_TIMING_LINEAR:
01037             canvas2d.fillRect(103, 255, 81, 6);
01038             break;
01039         case ANIMATION_TIMING_EASE_IN:
01040             canvas2d.fillRect(198, 255, 81, 6);
01041             break;
01042         case ANIMATION_TIMING_EASE_OUT:
01043             canvas2d.fillRect(292, 255, 81, 6);
01044             break;
01045         case ANIMATION_TIMING_EASE_IN_OUT:
01046         default:
01047             canvas2d.fillRect(386, 255, 81, 6);
01048             break;
01049     }
01050 
01051     /* Draw button */
01052     canvas2d.drawImage(animetion_timing_jpg_File, 0, 225);
01053 
01054     position = R_ANIMATION_TIMING_FUNCTION_GetValue(accelerator, relative_pos, 240.0f, 6.0f);
01055     canvas2d.drawImage(Board_jpg_File, position, 65);
01056 
01057     /* Draw return button */
01058     canvas2d.drawImage(RetBtn_jpg_File, 368, 6);
01059 
01060     /* Complete drawing */
01061     R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
01062 }
01063 
01064 void RGA_Func_Axel(frame_buffer_t* frmbuf_info, int animation_timing, float32_t relative_pos, graphics_image_t* image) {
01065     /* Do accelerated motion from right to left */
01066         static int prv_timing = animation_timing;
01067         static int crsr = 0;
01068         int position;
01069 
01070         /* Clear */
01071         canvas2d.clearRect(0, 65, frmbuf_info->width, IMG_DRAW_HEIGHT);
01072 
01073         if (relative_pos == 0.0f) {
01074             switch (animation_timing) {
01075                 case ANIMATION_TIMING_EASE:
01076                     R_Get_AnimationTimingFunction("ease", &accelerator);
01077                     break;
01078                 case ANIMATION_TIMING_LINEAR:
01079                     R_Get_AnimationTimingFunction("linear", &accelerator);
01080                     break;
01081                 case ANIMATION_TIMING_EASE_IN:
01082                     R_Get_AnimationTimingFunction("ease-in", &accelerator);
01083                     break;
01084                 case ANIMATION_TIMING_EASE_OUT:
01085                     R_Get_AnimationTimingFunction("ease-out", &accelerator);
01086                     break;
01087                 case ANIMATION_TIMING_EASE_IN_OUT:
01088                 default:
01089                     R_Get_AnimationTimingFunction("ease-in-out", &accelerator);
01090                     break;
01091             }
01092             if(prv_timing != animation_timing)
01093             {
01094                 prv_timing = animation_timing;
01095                 crsr = 2;
01096             }
01097         }
01098 
01099         /* Draw rectangle */
01100         canvas2d.fillStyle = "#0000FF";  /* blue */
01101         switch (animation_timing) {
01102             case ANIMATION_TIMING_EASE:
01103                 if(crsr)
01104                 {
01105                     canvas2d.clearRect(0, 255, frmbuf_info->width, 6);
01106                     canvas2d.fillRect(10, 255, 81, 6);
01107                 }
01108                 break;
01109             case ANIMATION_TIMING_LINEAR:
01110                 if(crsr)
01111                 {
01112                     canvas2d.clearRect(0, 255, frmbuf_info->width, 6);
01113                     canvas2d.fillRect(103, 255, 81, 6);
01114                 }
01115                 break;
01116             case ANIMATION_TIMING_EASE_IN:
01117                 if(crsr)
01118                 {
01119                     canvas2d.clearRect(0, 255, frmbuf_info->width, 6);
01120                     canvas2d.fillRect(198, 255, 81, 6);
01121                 }
01122                 break;
01123             case ANIMATION_TIMING_EASE_OUT:
01124                 if(crsr)
01125                 {
01126                     canvas2d.clearRect(0, 255, frmbuf_info->width, 6);
01127                     canvas2d.fillRect(292, 255, 81, 6);
01128                 }
01129                 break;
01130             case ANIMATION_TIMING_EASE_IN_OUT:
01131             default:
01132                 if(crsr)
01133                 {
01134                     canvas2d.clearRect(0, 255, frmbuf_info->width, 6);
01135                     canvas2d.fillRect(386, 255, 81, 6);
01136                 }
01137                 break;
01138         }
01139 
01140         /* Draw button */
01141         if(crsr)
01142         {
01143             canvas2d.drawImage(animetion_timing_jpg_File, 0, 225);
01144             crsr--;
01145         }
01146 
01147         position = R_ANIMATION_TIMING_FUNCTION_GetValue(accelerator, relative_pos, 240.0f, 6.0f);
01148         canvas2d.drawImage(image, position, 65);
01149 
01150         /* Complete drawing */
01151         R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
01152 }
01153 
01154 bool RGA_Func_CheckPorts(frame_buffer_t* frmbuf_info, bool rca_pluged, bool usb_pluged) {
01155     static bool rca_visible = false;
01156     static bool usb_visible = false;
01157     bool rca_changed = false;
01158     bool usb_changed = false;
01159 
01160     /* Detect Change in ports status */
01161     if(rca_pluged ^ rca_visible)
01162     {
01163         rca_visible = rca_pluged;
01164         rca_changed = true;
01165     }
01166 
01167     if(usb_pluged ^ usb_visible)
01168     {
01169         usb_visible = usb_pluged;
01170         usb_changed = true;
01171     }
01172 
01173     if(rca_changed | usb_changed)
01174     {
01175         frmbuf_info->draw_buffer_index = (frmbuf_info->draw_buffer_index)? 0 : 1;
01176 
01177         /* Draw a image Clear */
01178         canvas2d.drawImage(TopScrn_jpg_File, 0, 0);
01179 
01180         if(rca_visible)
01181             canvas2d.drawImage(RCA_jpg_File, (frmbuf_info->width/2)-80, 22);
01182 
01183         if(usb_visible)
01184             canvas2d.drawImage(Usb_jpg_File, frmbuf_info->width-50, (frmbuf_info->height/2)-36);
01185 
01186         /* Complete drawing */
01187         R_GRAPHICS_Finish(canvas2d.c_LanguageContext);
01188     }
01189 
01190     return (rca_changed | usb_changed);
01191 }
01192 #endif
01193