Changeset 1527 for trunk/core/gui_osd.c


Ignore:
Timestamp:
01/04/12 10:53:44 (17 months ago)
Author:
philmoz
Message:

Merge latest code from reyalp-flt branch to main trunk.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk

  • trunk/core/gui_osd.c

    r1505 r1527  
    1515#include "gui_grid.h" 
    1616#include "gui_osd.h" 
     17 
     18//------------------------------------------------------------------- 
     19void gui_osd_kbd_process(); 
     20void gui_osd_draw(int enforce_redraw); 
     21 
     22gui_handler layoutGuiHandler =  { GUI_MODE_OSD,     gui_osd_draw,   gui_osd_kbd_process,    gui_default_kbd_process_menu_btn, 0,                                    GUI_MODE_MAGICNUM };    // THIS IS OSD LAYOUT EDITOR 
    1723 
    1824//------------------------------------------------------------------- 
    … …  
    102108    step = 10; 
    103109    draw_restore(); 
     110} 
     111 
     112//------------------------------------------------------------------- 
     113void gui_draw_osd_le(int arg) { 
     114    gui_set_mode(&layoutGuiHandler); 
     115    gui_osd_init(); 
    104116} 
    105117 
    … …  
    128140        } 
    129141        sprintf(osd_buf, " %s:  x:%d y:%d s:%d ", lang_str(osd[curr_item].title), osd[curr_item].pos->x, osd[curr_item].pos->y, step); 
    130         draw_string(0, (osd[curr_item].pos->x<strlen(osd_buf)*FONT_WIDTH+4 && osd[curr_item].pos->y<FONT_HEIGHT+4)?screen_height-FONT_HEIGHT:0, 
     142        draw_string(0, (osd[curr_item].pos->x<strlen(osd_buf)*FONT_WIDTH+4 && osd[curr_item].pos->y<FONT_HEIGHT+4)?camera_screen.height-FONT_HEIGHT:0, 
    131143                    osd_buf, MAKE_COLOR(COLOR_RED, COLOR_WHITE)); 
    132144        osd_to_draw = 0; 
    … …  
    144156        break; 
    145157    case KEY_RIGHT: 
    146         if (osd[curr_item].pos->x < screen_width-osd[curr_item].size.x) { 
    147             osd[curr_item].pos->x+=(screen_width-osd[curr_item].size.x-osd[curr_item].pos->x>step)?step:screen_width-osd[curr_item].size.x-osd[curr_item].pos->x; 
     158        if (osd[curr_item].pos->x < camera_screen.width-osd[curr_item].size.x) { 
     159            osd[curr_item].pos->x+=(camera_screen.width-osd[curr_item].size.x-osd[curr_item].pos->x>step)?step:camera_screen.width-osd[curr_item].size.x-osd[curr_item].pos->x; 
    148160            osd_to_draw = 1; 
    149161        } else 
    150             osd[curr_item].pos->x = screen_width-osd[curr_item].size.x; 
     162            osd[curr_item].pos->x = camera_screen.width-osd[curr_item].size.x; 
    151163        break; 
    152164    case KEY_UP: 
    … …  
    157169        break; 
    158170    case KEY_DOWN: 
    159         if (osd[curr_item].pos->y < screen_height-osd[curr_item].size.y) { 
    160             osd[curr_item].pos->y+=(screen_height-osd[curr_item].size.y-osd[curr_item].pos->y>step)?step:screen_height-osd[curr_item].size.y-osd[curr_item].pos->y; 
     171        if (osd[curr_item].pos->y < camera_screen.height-osd[curr_item].size.y) { 
     172            osd[curr_item].pos->y+=(camera_screen.height-osd[curr_item].size.y-osd[curr_item].pos->y>step)?step:camera_screen.height-osd[curr_item].size.y-osd[curr_item].pos->y; 
    161173            osd_to_draw = 1; 
    162174        } else 
    163             osd[curr_item].pos->y = screen_height-osd[curr_item].size.y; 
     175            osd[curr_item].pos->y = camera_screen.height-osd[curr_item].size.y; 
    164176        break; 
    165177    case KEY_SET: 
    … …  
    255267      timer = 0; 
    256268          #if defined (CAM_ZEBRA_NOBUF) 
    257         buffer_size=screen_buffer_size-ZEBRA_HMARGIN0*screen_buffer_width; 
     269        buffer_size=camera_screen.buffer_size-ZEBRA_HMARGIN0*camera_screen.buffer_width; 
    258270        buf=vid_get_bitmap_fb(); 
    259271          #elif defined (CAM_ZEBRA_ASPECT_ADJUST) 
    260         buffer_size=screen_buffer_size-ZEBRA_HMARGIN0*screen_buffer_width; 
     272        buffer_size=camera_screen.buffer_size-ZEBRA_HMARGIN0*camera_screen.buffer_width; 
    261273        buf = malloc(buffer_size); 
    262274        //~ if (!buf) draw_txt_string(0, 14, "Warn: No space to allocate zebra buffer: restart camera", MAKE_COLOR(COLOR_ALT_BG, COLOR_FG)); 
    … …  
    265277        //~ msleep(50); 
    266278      #else 
    267         buf = malloc(screen_buffer_size); 
     279        buf = malloc(camera_screen.buffer_size); 
    268280      #endif 
    269281            scr_buf = vid_get_bitmap_fb(); 
    270282#if ZEBRA_CANONOSD_BORDER_RESTORE 
    271             cur_buf_top = malloc(screen_buffer_width * ZFIX_TOP);  
    272             cur_buf_bot = malloc(screen_buffer_width * ZFIX_BOTTOM);  
     283            cur_buf_top = malloc(camera_screen.buffer_width * ZFIX_TOP);  
     284            cur_buf_bot = malloc(camera_screen.buffer_width * ZFIX_BOTTOM);  
    273285#if defined (CAM_ZEBRA_ASPECT_ADJUST) 
    274             if (cur_buf_top) memset(cur_buf_top,0,screen_buffer_width * ZFIX_TOP); 
    275             if (cur_buf_bot) memset(cur_buf_bot,0,screen_buffer_width * ZFIX_BOTTOM); 
     286            if (cur_buf_top) memset(cur_buf_top,0,camera_screen.buffer_width * ZFIX_TOP); 
     287            if (cur_buf_bot) memset(cur_buf_bot,0,camera_screen.buffer_width * ZFIX_BOTTOM); 
    276288#endif 
    277289#else 
    278             cur_buf = malloc(screen_buffer_size); 
     290            cur_buf = malloc(camera_screen.buffer_size); 
    279291#endif       
    280292                        // cleanup and disable zebra if any mallocs failed 
    … …  
    291303#if CAM_HAS_VARIABLE_ASPECT 
    292304                        else // in variable aspect, the borders would never be cleared 
    293                                 memset(buf,0,screen_buffer_size); 
     305                                memset(buf,0,camera_screen.buffer_size); 
    294306#endif 
    295307        } 
    … …  
    317329//------------------------------------------------------------------- 
    318330int draw_guard_pixel() { 
    319     unsigned char* buffer1 = vid_get_bitmap_fb()+screen_buffer_size/2; 
    320     unsigned char* buffer2 = buffer1+screen_buffer_size; 
     331    unsigned char* buffer1 = vid_get_bitmap_fb()+camera_screen.buffer_size/2; 
     332    unsigned char* buffer2 = buffer1+camera_screen.buffer_size; 
    321333    int has_disappeared=0; 
    322334 
    … …  
    332344    unsigned int a; 
    333345     
    334     a=screen_buffer_size - screen_buffer_width * ZFIX_BOTTOM; 
     346    a=camera_screen.buffer_size - camera_screen.buffer_width * ZFIX_BOTTOM; 
    335347     
    336     if (idx < screen_buffer_width * ZFIX_TOP) return(cur_buf_top[idx]); 
    337     if (idx >= a && idx < screen_buffer_size) return(cur_buf_bot[idx - a]); 
     348    if (idx < camera_screen.buffer_width * ZFIX_TOP) return(cur_buf_top[idx]); 
     349    if (idx >= a && idx < camera_screen.buffer_size) return(cur_buf_bot[idx - a]); 
    338350    return (COLOR_TRANSPARENT); 
    339351} 
    … …  
    473485    if (f) { 
    474486                if (viewport_yoffset > 0) { // clear top & bottom areas of buffer if image height if smaller than viewport 
    475                         memset(buf, COLOR_TRANSPARENT, viewport_yoffset*screen_buffer_width); 
    476                         memset(buf+(viewport_yoffset+viewport_height)*screen_buffer_width, COLOR_TRANSPARENT, viewport_yoffset*screen_buffer_width); 
     487                        memset(buf, COLOR_TRANSPARENT, viewport_yoffset*camera_screen.buffer_width); 
     488                        memset(buf+(viewport_yoffset+viewport_height)*camera_screen.buffer_width, COLOR_TRANSPARENT, viewport_yoffset*camera_screen.buffer_width); 
    477489                } 
    478490        int step_x, step_v, sy, sx; 
    … …  
    480492            if (conf.zebra_multichannel) {step_x=2; step_v=6;} else {step_x=1; step_v=3;} 
    481493            for (y=viewport_yoffset, v=viewport_image_offset; y<viewport_yoffset+viewport_height; ++y) { 
    482                 sy=y*screen_buffer_width; 
     494                sy=y*camera_screen.buffer_width; 
    483495                sx=viewport_xoffset; 
    484496                                if (viewport_xoffset > 0) { // clear left & right areas of buffer if image width if smaller than viewport 
    … …  
    532544//~ #if ZEBRA_CANONOSD_BORDER_RESTORE 
    533545                    //~ // copy rescued Canon OSD to buf[] top/bottom parts and fill center with transparent color: 
    534                     //~ memcpy(buf, cur_buf_top, screen_buffer_width * ZFIX_TOP); 
    535                     //~ memcpy(buf + screen_buffer_size - screen_buffer_width * ZFIX_BOTTOM, cur_buf_bot, screen_buffer_width * ZFIX_BOTTOM); 
    536                     //~ for (s = screen_buffer_width*ZFIX_TOP; s < screen_buffer_size-screen_buffer_width*ZFIX_BOTTOM; s++) { 
     546                    //~ memcpy(buf, cur_buf_top, camera_screen.buffer_width * ZFIX_TOP); 
     547                    //~ memcpy(buf + camera_screen.buffer_size - camera_screen.buffer_width * ZFIX_BOTTOM, cur_buf_bot, camera_screen.buffer_width * ZFIX_BOTTOM); 
     548                    //~ for (s = camera_screen.buffer_width*ZFIX_TOP; s < camera_screen.buffer_size-camera_screen.buffer_width*ZFIX_BOTTOM; s++) { 
    537549                        //~ buf[s]=COLOR_TRANSPARENT; 
    538550                    //~ } 
    539551//~ #else 
    540552                    //~ // copy from a complete Canon OSD rescue screen dump 
    541                     //~ memcpy(buf, cur_buf, screen_buffer_size);  
     553                    //~ memcpy(buf, cur_buf, camera_screen.buffer_size);  
    542554//~ #endif 
    543555                } else { // Not REC mode 
    … …  
    551563                if (buf!=scr_buf) 
    552564                  memcpy(scr_buf, buf, buffer_size); 
    553                   memcpy(scr_buf+screen_buffer_size, buf, buffer_size); 
     565                  memcpy(scr_buf+camera_screen.buffer_size, buf, buffer_size); 
    554566            } 
    555567            need_restore=0; 
    … …  
    563575        if (buf!=scr_buf) 
    564576            memcpy(scr_buf, buf, buffer_size); 
    565             memcpy(scr_buf+screen_buffer_size, buf, buffer_size); 
     577            memcpy(scr_buf+camera_screen.buffer_size, buf, buffer_size); 
    566578 
    567579        need_restore=1; 
    … …  
    597609    { 
    598610        bWide = 0; 
    599         //aspOffset = (screen_width - (screen_width * 12 / 16)) / 2; // = actual calculation, simplified below 
    600         aspOffset = screen_width / 8; // half of the difference in width between equal height 16:9 and 4:3 screens, = black bar width 
     611        //aspOffset = (camera_screen.width - (camera_screen.width * 12 / 16)) / 2; // = actual calculation, simplified below 
     612        aspOffset = camera_screen.width / 8; // half of the difference in width between equal height 16:9 and 4:3 screens, = black bar width 
    601613    } 
    602614#endif 
    … …  
    620632        // rescue Canon OSD from scr_buf to cur_buf_top and _bot: 
    621633        if (n==1) { 
    622             memcpy(cur_buf_top, scr_buf, screen_buffer_width*ZFIX_TOP); 
    623             memcpy(cur_buf_bot, scr_buf + screen_buffer_size - screen_buffer_width*ZFIX_BOTTOM, screen_buffer_width*ZFIX_BOTTOM); 
     634            memcpy(cur_buf_top, scr_buf, camera_screen.buffer_width*ZFIX_TOP); 
     635            memcpy(cur_buf_bot, scr_buf + camera_screen.buffer_size - camera_screen.buffer_width*ZFIX_BOTTOM, camera_screen.buffer_width*ZFIX_BOTTOM); 
    624636        } 
    625637        else { 
    626             memcpy(cur_buf_top, scr_buf + screen_buffer_size, screen_buffer_width*ZFIX_TOP); 
    627             memcpy(cur_buf_bot, scr_buf + 2*screen_buffer_size - screen_buffer_width*ZFIX_BOTTOM, screen_buffer_width*ZFIX_BOTTOM); 
     638            memcpy(cur_buf_top, scr_buf + camera_screen.buffer_size, camera_screen.buffer_width*ZFIX_TOP); 
     639            memcpy(cur_buf_bot, scr_buf + 2*camera_screen.buffer_size - camera_screen.buffer_width*ZFIX_BOTTOM, camera_screen.buffer_width*ZFIX_BOTTOM); 
    628640        } 
    629641#else 
    630642        // rescue Canon OSD from cur_buf 
    631         if(n==1) memcpy(cur_buf, scr_buf, screen_buffer_size); 
    632         else memcpy(cur_buf, scr_buf+screen_buffer_size, screen_buffer_size); 
     643        if(n==1) memcpy(cur_buf, scr_buf, camera_screen.buffer_size); 
     644        else memcpy(cur_buf, scr_buf+camera_screen.buffer_size, camera_screen.buffer_size); 
    633645#endif 
    634646    } 
    … …  
    674686            s = aspOffset; 
    675687            for (y=1, v=0; y<=viewport_height; ++y) { 
    676                 for (x=0; x<screen_width; x+=step_x, s+=step_x, v+=step_v) { 
     688                for (x=0; x<camera_screen.width; x+=step_x, s+=step_x, v+=step_v) { 
    677689                    register int yy, uu, vv; 
    678690                    int sel; 
    679691                                                                                 
    680                     if (!bWide && (x + aspOffset >= screen_width - aspOffset)) continue; // do not draw "outside screen"  
     692                    if (!bWide && (x + aspOffset >= camera_screen.width - aspOffset)) continue; // do not draw "outside screen"  
    681693                                                                                 
    682694                    yy = img_buf[v+1]; 
    … …  
    706718                    } 
    707719                } 
    708                 s+=screen_buffer_width-screen_width; 
    709                 if (y*screen_height/viewport_height == (s+screen_buffer_width)/screen_buffer_width) { 
    710                     memcpy(buf+s, buf+s-screen_buffer_width, screen_buffer_width); 
    711                     s+=screen_buffer_width; 
     720                s+=camera_screen.buffer_width-camera_screen.width; 
     721                if (y*camera_screen.height/viewport_height == (s+camera_screen.buffer_width)/camera_screen.buffer_width) { 
     722                    memcpy(buf+s, buf+s-camera_screen.buffer_width, camera_screen.buffer_width); 
     723                    s+=camera_screen.buffer_width; 
    712724                } 
    713725            } 
    … …  
    724736#if ZEBRA_CANONOSD_BORDER_RESTORE 
    725737                    // copy rescued Canon OSD to buf[] top/bottom parts and fill center with transparent color: 
    726                     memcpy(buf, cur_buf_top, screen_buffer_width * ZFIX_TOP); 
    727                     memcpy(buf + screen_buffer_size - screen_buffer_width * ZFIX_BOTTOM, cur_buf_bot, screen_buffer_width * ZFIX_BOTTOM); 
    728                     for (s = screen_buffer_width*ZFIX_TOP; s < screen_buffer_size-screen_buffer_width*ZFIX_BOTTOM; s++) { 
     738                    memcpy(buf, cur_buf_top, camera_screen.buffer_width * ZFIX_TOP); 
     739                    memcpy(buf + camera_screen.buffer_size - camera_screen.buffer_width * ZFIX_BOTTOM, cur_buf_bot, camera_screen.buffer_width * ZFIX_BOTTOM); 
     740                    for (s = camera_screen.buffer_width*ZFIX_TOP; s < camera_screen.buffer_size-camera_screen.buffer_width*ZFIX_BOTTOM; s++) { 
    729741                        buf[s]=COLOR_TRANSPARENT; 
    730742                    } 
    731743#else 
    732744                    // copy from a complete Canon OSD rescue screen dump 
    733                     memcpy(buf, cur_buf, screen_buffer_size);  
     745                    memcpy(buf, cur_buf, camera_screen.buffer_size);  
    734746#endif 
    735747                } else { // Not REC mode 
    736748                    // No Canon OSD restore, fill buf[] with transparent color: 
    737                     memset(buf, COLOR_TRANSPARENT, screen_buffer_size); 
     749                    memset(buf, COLOR_TRANSPARENT, camera_screen.buffer_size); 
    738750                } 
    739751                // draw CHDK osd and histogram to buf[] (if enabled in config) 
    740752                gui_osd_draw_zebra_osd(); 
    741753                // copy buf[] to both display buffers 
    742                 memcpy(scr_buf, buf, screen_buffer_size); 
    743                 memcpy(scr_buf+screen_buffer_size, buf, screen_buffer_size); 
     754                memcpy(scr_buf, buf, camera_screen.buffer_size); 
     755                memcpy(scr_buf+camera_screen.buffer_size, buf, camera_screen.buffer_size); 
    744756            } 
    745757            need_restore=0; 
    … …  
    751763        gui_osd_draw_zebra_osd(); 
    752764        // copy buf[] to both display buffers           
    753         memcpy(scr_buf, buf, screen_buffer_size); 
    754         memcpy(scr_buf+screen_buffer_size, buf, screen_buffer_size); 
     765        memcpy(scr_buf, buf, camera_screen.buffer_size); 
     766        memcpy(scr_buf+camera_screen.buffer_size, buf, camera_screen.buffer_size); 
    755767 
    756768        need_restore=1; 
    … …  
    11541166    if ((conf.autoiso_enable && shooting_get_iso_mode()<=0 && !(m==MODE_M || m==MODE_TV) && shooting_get_flash_mode() && (!(conf.override_disable==1 && conf.override_disable_all))) || gui_mode==GUI_MODE_OSD)   
    11551167            gui_print_osd_state_string_chr("AUTOISO:", ((conf.autoiso_enable==1)?"ON":"OFF")); 
    1156     if ((conf.subj_dist_override_value && conf.subj_dist_override_koef && shooting_can_focus() && !(conf.override_disable==1)) || ((gui_mode==GUI_MODE_ALT) && shooting_get_common_focus_mode())        || gui_mode==GUI_MODE_OSD)   { 
     1168    if ((conf.subj_dist_override_value && conf.subj_dist_override_koef && shooting_can_focus() && !(conf.override_disable==1)) || ((gui_get_mode()==GUI_MODE_ALT) && shooting_get_common_focus_mode())  || gui_mode==GUI_MODE_OSD)   { 
    11571169        gui_print_osd_state_string_int("SD:",shooting_get_subject_distance_override_value()); 
    11581170        if (gui_mode==GUI_MODE_ALT)   
Note: See TracChangeset for help on using the changeset viewer.