src/edc-callback/cam_common_edc_callback.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *        http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <stdio.h>
  19 #include "camera_utils.h"
  20
  21 #include "edc_string.h"
  22
  23 #include "cam_common_edc_callback.h"
  24 #include "cam_toolbar_edc_callback.h"
  25 #include "cam_indicator_edc_callback.h"
  26 #include "cam_zoom_edc_callback.h"
  27 #include "cam_ev_edc_callback.h"
  28 #include "cam_face_detection_focus.h"
  29 #include "cam_ui_effect_utils.h"
  30 #include "cam_menu_composer.h"
  31 #include "cam_capacity_type.h"
  32 #include "cam_device_capacity.h"
  33 #include "cam_mm.h"
  34
  35
  36 #define ZOOM_THRESHOLD  0.02
  37
  38 static double prev_zoom = 0;
  39
  40 static Evas_Event_Flags __pinch_start(void *data, void *event_info)
  41 {
  42         struct appdata *ad = (struct appdata *)data;
  43         cam_retvm_if(ad == NULL, EVAS_EVENT_FLAG_NONE, "appdata is NULL");
  44         CamAppData *camapp = ad->camapp_handle;
  45         cam_retvm_if(camapp == NULL, EVAS_EVENT_FLAG_NONE, "camapp_handle is NULL");
  46
  47         DEBUG_TRACE("__pinch_start");
  48
  49         if (camapp->touch_af_state == CAM_TOUCH_AF_STATE_DOING) {
  50                 DEBUG_TRACE("touch_af_state is [%d], do not zoom", camapp->touch_af_state);
  51                 return EVAS_EVENT_FLAG_NONE;
  52         }
  53
  54         DEL_EVAS_OBJECT(ad->focus_edje);
  55         cam_mm_stop_focusing();
  56
  57         prev_zoom = 0;
  58
  59         if (ad->toolbar_setting_popup || ad->setting_ctxpopup) {
  60                 ad->displayed_setting_popup = DISPLAY_NONE_POPUP;
  61                 cam_toolbar_setting_popup_destroy(ad);
  62         }
  63
  64         if (ad->edit_shortcuts_popup) {
  65                 toolbar_destroy_shortcuts_popup(ad);
  66         }
  67
  68         if (ad->zoom_edje)
  69                 unload_zoom_edje(ad);
  70
  71         if (ad->ev_edje)
  72                 unload_ev_edje(ad);
  73
  74         cam_zoom_create_pinch_edje(ad);
  75
  76         return EVAS_EVENT_FLAG_NONE;
  77 }
  78
  79 static Evas_Event_Flags __pinch_end(void *data, void *event_info)
  80 {
  81         struct appdata *ad = (struct appdata *)data;
  82         cam_retvm_if(ad == NULL, EVAS_EVENT_FLAG_NONE, "appdata is NULL");
  83
  84         DEBUG_TRACE("__pinch_end");
  85
  86         DEL_EVAS_OBJECT(ad->pinch_edje)
  87         cam_reset_focus_mode(ad);
  88
  89         return EVAS_EVENT_FLAG_NONE;
  90 }
  91
  92 static Evas_Event_Flags __pinch_move(void *data, void *event_info)
  93 {
  94         Elm_Gesture_Zoom_Info *ev = (Elm_Gesture_Zoom_Info *)event_info;
  95         cam_retvm_if(ev == NULL, EVAS_EVENT_FLAG_NONE, "event_info is NULL");
  96         struct appdata *ad = (struct appdata *)data;
  97         cam_retvm_if(ad == NULL, EVAS_EVENT_FLAG_NONE, "appdata is NULL");
  98         CamAppData *camapp = ad->camapp_handle;
  99         cam_retvm_if(camapp == NULL, EVAS_EVENT_FLAG_NONE, "camapp_handle is NULL");
 100
 101         if (camapp->touch_af_state == CAM_TOUCH_AF_STATE_DOING) {
 102                 DEBUG_TRACE("touch_af_state is [%d], do not zoom", camapp->touch_af_state);
 103                 return EVAS_EVENT_FLAG_NONE;
 104         }
 105
 106         if (ad->pinch_edje == NULL)
 107                 __pinch_start(ad, NULL);
 108
 109         double diff = prev_zoom - ev->zoom;
 110         if (ABS(diff) < ZOOM_THRESHOLD) {
 111                 return EVAS_EVENT_FLAG_NONE;
 112         }
 113
 114         prev_zoom = ev->zoom;
 115
 116         gboolean is_zoom_in = FALSE;
 117         if (diff > 0)
 118                 is_zoom_in = FALSE;
 119         else
 120                 is_zoom_in = TRUE;
 121
 122         int state = 0;
 123         state = cam_mm_get_state();
 124         cam_debug(LOG_UI, " state = %d", state);
 125         if (camapp->camera_mode == CAM_CAMERA_MODE) {
 126                 if (state == CAMERA_STATE_PREVIEW
 127                         || state == CAMERA_STATE_CAPTURED) {
 128                         if (!camapp->zoom_lock) {
 129                                 cam_pinch_zoom_in(ad, is_zoom_in, 1);
 130                                 return EVAS_EVENT_FLAG_NONE;
 131                         }
 132                 }
 133         } else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
 134                 if (state == RECORDER_STATE_READY
 135                         || state == RECORDER_STATE_RECORDING
 136                         || state == RECORDER_STATE_PAUSED) {
 137                         if (!camapp->zoom_lock
 138                                         && camapp->recording_mode != CAM_RECORD_SLOW) {
 139                                 cam_pinch_zoom_in(ad, is_zoom_in, 1);
 140                                 return EVAS_EVENT_FLAG_NONE;
 141                         }
 142                 }
 143         }
 144
 145         return EVAS_EVENT_FLAG_NONE;
 146 }
 147
 148 static void __mouse_click(void *data)
 149 {
 150         struct appdata *ad = (struct appdata *)data;
 151         cam_retm_if(ad == NULL, "appdata is NULL");
 152
 153         if (ad->zoom_edje)
 154                 unload_zoom_edje(ad);
 155
 156         if (ad->ev_edje)
 157                 unload_ev_edje(ad);
 158
 159         if (ad->setting_ctxpopup) {
 160                 ad->displayed_setting_popup = DISPLAY_NONE_POPUP;
 161                 cam_toolbar_setting_popup_destroy(ad);
 162         } else if (ad->toolbar_setting_popup) {
 163                 cam_toolbar_setting_popup_destroy(ad);
 164         } else if (ad->edit_shortcuts_popup) {
 165                 toolbar_destroy_shortcuts_popup(ad);
 166         }
 167
 168         return;
 169 }
 170
 171 static void __mouse_up_cb(void *data, Evas * evas, Evas_Object *obj, void *event_info)
 172 {
 173         Evas_Event_Mouse_Up *ev = (Evas_Event_Mouse_Up *)event_info;
 174         cam_retm_if(ev == NULL, "event_info is NULL");
 175         struct appdata *ad = (struct appdata *)data;
 176         cam_retm_if(ad == NULL, "appdata is NULL");
 177
 178         if (ad->is_rotating) {
 179                 cam_critical(LOG_MM, "rotating...");
 180                 return;
 181         }
 182
 183         unsigned int focus_capacity = 0;
 184         GetCamDevFocusCaps(&focus_capacity, ad);
 185
 186         if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK) {
 187                 DEBUG_TRACE("double click");
 188                 return;
 189         }
 190
 191         if (focus_capacity & CAM_CP_FOCUS_AUTO_FOCUS) {
 192                 CAM_UI_LOG("mouse up :[%d, %d]", ev->canvas.x, ev->canvas.y);
 193                 cam_mouse_button_up(ad, ev);
 194         }
 195
 196         __mouse_click(ad);
 197         cam_app_timeout_checker_update();
 198
 199         return;
 200 }
 201
 202 static void __mouse_down_cb(void *data, Evas * evas, Evas_Object *obj, void *event_info)
 203 {
 204         Evas_Event_Mouse_Down *ev = (Evas_Event_Mouse_Down *) event_info;
 205         cam_retm_if(ev == NULL, "event_info is NULL");
 206         struct appdata *ad = (struct appdata *)data;
 207         cam_retm_if(ad == NULL, "appdata is NULL");
 208         CamAppData *camapp = ad->camapp_handle;
 209         cam_retm_if(camapp == NULL, "camapp is NULL");
 210
 211         unsigned int focus_capacity = 0;
 212         GetCamDevFocusCaps(&focus_capacity, ad);
 213
 214         if (ad->is_rotating) {
 215                 cam_critical(LOG_MM, "rotating...");
 216                 return;
 217         }
 218
 219         if (ad->is_processing) {
 220                 cam_critical(LOG_MM, "bust shot popup is displaying...");
 221                 return;
 222         }
 223
 224         if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK) {
 225                 DEBUG_TRACE("double click");
 226
 227                 if(camapp->af_mode == CAM_FOCUS_FACE){
 228                         cam_common_set_mouse_double_click_xy(ev->canvas.x, ev->canvas.y);
 229                 }
 230                 return;
 231         }
 232
 233         if (focus_capacity & CAM_CP_FOCUS_AUTO_FOCUS) {
 234                 CAM_UI_LOG("mouse down :[%d, %d]", ev->canvas.x, ev->canvas.y);
 235                 cam_mouse_button_down(ad, ev);
 236         }
 237
 238         cam_app_timeout_checker_update();
 239
 240         return;
 241 }
 242
 243 static void __mouse_move_cb(void *data, Evas * evas, Evas_Object *obj, void *event_info)
 244 {
 245         cam_app_timeout_checker_update();
 246         return;
 247 }
 248
 249 void define_mouse_callback(void *data)
 250 {
 251         struct appdata *ad = (struct appdata *)data;
 252         cam_retm_if(ad == NULL, "appdata is NULL");
 253
 254         unsigned int capacity = 0;
 255         GetCamDevFuncCaps(&capacity, ad);
 256
 257         Evas_Object *eo = (Evas_Object *)edje_object_part_object_get(_EDJ(ad->ug_base), "mouse_event_layer");
 258
 259         evas_object_event_callback_add(eo, EVAS_CALLBACK_MOUSE_DOWN, __mouse_down_cb, ad);
 260         evas_object_event_callback_add(eo, EVAS_CALLBACK_MOUSE_UP, __mouse_up_cb, ad);
 261         evas_object_event_callback_add(eo, EVAS_CALLBACK_MOUSE_MOVE, __mouse_move_cb, ad);
 262
 263         if (capacity & CAM_CP_FUNC_ZOOM) {
 264                 if(ad->gesture == NULL)
 265                         ad->gesture = elm_gesture_layer_add(eo);
 266
 267                 elm_gesture_layer_cb_set(ad->gesture, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_START, __pinch_start, ad);
 268                 elm_gesture_layer_cb_set(ad->gesture, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_MOVE, __pinch_move, ad);
 269                 elm_gesture_layer_cb_set(ad->gesture, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_END, __pinch_end, ad);
 270                 elm_gesture_layer_cb_set(ad->gesture, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_ABORT, __pinch_end, ad);
 271                 elm_gesture_layer_attach(ad->gesture, eo);
 272         } else {
 273                 DEL_EVAS_OBJECT(ad->gesture);
 274         }
 275 }
 276
 277 void cam_layout_del_all(void *data)
 278 {
 279         CAM_UI_LOG();
 280         struct appdata *ad = (struct appdata *)data;
 281         cam_toolbar_destroy(ad);
 282
 283         if (ad->indicator_edje)
 284                 cam_indicator_destory(ad);
 285
 286         if (ad->ev_edje)
 287                 unload_ev_edje(ad);
 288
 289         if (ad->zoom_edje)
 290                 unload_zoom_edje(ad);
 291
 292         ad->displayed_setting_popup = DISPLAY_NONE_POPUP;
 293 }
 294
 295 int cam_convert_shot_mode_to_menu_item(int mode)
 296 {
 297         switch(mode)
 298         {
 299                 case CAM_SINGLE_MODE:
 300                         return CAM_MENU_SHOOTING_SINGLE;
 301                 case CAM_SELF_SINGLE_MODE:
 302                         return CAM_MENU_SHOOTING_SELF_SINGLE;
 303                 default:
 304                         return CAM_MENU_SHOOTING_SINGLE;
 305         }
 306 }
 307
 308 int cam_convert_flash_to_menu_item(int mode)
 309 {
 310         switch(mode)
 311         {
 312                 case CAM_FLASH_OFF:
 313                         return CAM_MENU_FLASH_OFF;
 314                 case CAM_FLASH_ON:
 315                         return CAM_MENU_FLASH_ON;
 316                 case CAM_FLASH_AUTO:
 317                         return CAM_MENU_FLASH_AUTO;
 318                 default:
 319                         return CAM_MENU_FLASH_OFF;
 320         }
 321 }
 322
 323 int cam_convert_recording_mode_to_menu_item(int mode)
 324 {
 325         switch(mode)
 326         {
 327                 case CAM_RECORD_NORMAL:
 328                         return CAM_MENU_RECORDING_MODE_NORMAL;
 329                 case CAM_RECORD_SELF:
 330                         return CAM_MENU_RECORDING_MODE_SELF_NORMAL;
 331                 case CAM_RECORD_MMS:
 332                         return CAM_MENU_RECORDING_MODE_LIMIT;
 333                 case CAM_RECORD_SELF_MMS:
 334                         return CAM_MENU_RECORDING_MODE_SELF_LIMIT;
 335                 case CAM_RECORD_SLOW:
 336                         return CAM_MENU_RECORDING_MODE_SLOW;
 337                 case CAM_RECORD_FAST:
 338                         return CAM_MENU_RECORDING_MODE_FAST;
 339                 default:
 340                         return CAM_MENU_RECORDING_MODE_NORMAL;
 341         }
 342 }
 343
 344 int cam_convert_video_resolution_to_menu_item(int mode)
 345 {
 346         switch(mode)
 347         {
 348
 349                 case CAM_RESOLUTION_FULLHD:
 350                         return CAM_MENU_VIDEO_RESOLUTION_FULLHD;
 351                 case CAM_RESOLUTION_HD:
 352                         return CAM_MENU_VIDEO_RESOLUTION_HD;
 353                 case CAM_RESOLUTION_WVGA2:
 354                         return CAM_MENU_VIDEO_RESOLUTION_WVGA;
 355                 case CAM_RESOLUTION_VGA:
 356                         return CAM_MENU_VIDEO_RESOLUTION_VGA;
 357                 case CAM_RESOLUTION_QVGA:
 358                         return CAM_MENU_VIDEO_RESOLUTION_QVGA;
 359                 case CAM_RESOLUTION_QCIF:
 360                         return CAM_MENU_VIDEO_RESOLUTION_QCIF;
 361                 default:
 362                         return CAM_MENU_VIDEO_RESOLUTION_QCIF;
 363         }
 364 }
 365
 366 int cam_convert_photo_resolution_to_menu_item(int mode)
 367 {
 368         switch(mode)
 369         {
 370                 case CAM_RESOLUTION_3264x2448:
 371                         return CAM_MENU_PHOTO_RESOLUTION_3264x2448;
 372                 case CAM_RESOLUTION_3264x1960:
 373                         return CAM_MENU_PHOTO_RESOLUTION_3264x1960;
 374                 case CAM_RESOLUTION_3264x1836:
 375                         return CAM_MENU_PHOTO_RESOLUTION_3264x1836;
 376                 case CAM_RESOLUTION_2800x1920:
 377                         return CAM_MENU_PHOTO_RESOLUTION_2800x1920;
 378                 case CAM_RESOLUTION_2560x1536:
 379                         return CAM_MENU_PHOTO_RESOLUTION_2560x1536;
 380                 case CAM_RESOLUTION_2560x1440:
 381                         return CAM_MENU_PHOTO_RESOLUTION_2560x1440;
 382                 case CAM_RESOLUTION_2048x1536:
 383                         return CAM_MENU_PHOTO_RESOLUTION_2048x1536;
 384                 case CAM_RESOLUTION_2048x1152:
 385                         return CAM_MENU_PHOTO_RESOLUTION_2048x1152;
 386                 case CAM_RESOLUTION_1920x1080:
 387                         return CAM_MENU_PHOTO_RESOLUTION_1920x1080;
 388                 case CAM_RESOLUTION_1600x1200:
 389                         return CAM_MENU_PHOTO_RESOLUTION_1600x1200;
 390                 case CAM_RESOLUTION_1392x1392:
 391                         return CAM_MENU_PHOTO_RESOLUTION_1392x1392;
 392                 case CAM_RESOLUTION_1280x960:
 393                         return CAM_MENU_PHOTO_RESOLUTION_1280x960;
 394                 case CAM_RESOLUTION_1280x720:
 395                         return CAM_MENU_PHOTO_RESOLUTION_1280x720;
 396                 case CAM_RESOLUTION_VGA:
 397                         return CAM_MENU_PHOTO_RESOLUTION_640x480;
 398                 default:
 399                         return CAM_MENU_PHOTO_RESOLUTION_640x480;
 400         }
 401 }
 402
 403 int cam_convert_iso_to_menu_item(int mode)
 404 {
 405         switch(mode)
 406         {
 407                 case CAM_ISO_AUTO:
 408                         return CAM_MENU_ISO_AUTO;
 409                 case CAM_ISO_50:
 410                         return CAM_MENU_ISO_50;
 411                 case CAM_ISO_100:
 412                         return CAM_MENU_ISO_100;
 413                 case CAM_ISO_200:
 414                         return CAM_MENU_ISO_200;
 415                 case CAM_ISO_400:
 416                         return CAM_MENU_ISO_400;
 417                 case CAM_ISO_800:
 418                         return CAM_MENU_ISO_80O;
 419                 case CAM_ISO_1600:
 420                         return CAM_MENU_ISO_1600;
 421                 case CAM_ISO_3200:
 422                         return CAM_MENU_ISO_320O;
 423                 default:
 424                         return CAM_MENU_ISO_AUTO;
 425         }
 426 }
 427
 428 int cam_convert_focus_to_menu_item(int mode)
 429 {
 430         switch(mode)
 431         {
 432                 case CAM_FOCUS_AUTO:
 433                         return CAM_MENU_FOCUS_AUTO;
 434                 case CAM_FOCUS_MACRO:
 435                         return CAM_MENU_FOCUS_MACRO;
 436                 case CAM_FOCUS_FACE:
 437                         return CAM_MENU_FOCUS_FACE_DETECTION;
 438                 default:
 439                         return CAM_MENU_FOCUS_AUTO;
 440         }
 441 }
 442
 443 int cam_convert_timer_to_menu_item(int mode)
 444 {
 445         switch(mode)
 446         {
 447                 case CAM_SETTINGS_TIMER_OFF:
 448                         return CAM_MENU_TIMER_OFF;
 449                 case CAM_SETTINGS_TIMER_2SEC:
 450                         return CAM_MENU_TIMER_2SEC;
 451                 case CAM_SETTINGS_TIMER_5SEC:
 452                         return CAM_MENU_TIMER_5SEC;
 453                 case CAM_SETTINGS_TIMER_10SEC:
 454                         return CAM_MENU_TIMER_10SEC;
 455                 default:
 456                         return CAM_MENU_TIMER_OFF;
 457         }
 458 }
 459
 460 int cam_convert_scene_mode_to_menu_item(int mode)
 461 {
 462         switch(mode)
 463         {
 464                 case CAM_SCENE_NONE:
 465                         return CAM_MENU_SCENE_AUTO;
 466                 case CAM_SCENE_PORTRAIT:
 467                         return CAM_MENU_SCENE_PORTRAIT;
 468                 case CAM_SCENE_LANDSCAPE:
 469                         return CAM_MENU_SCENE_LANDSCAPE;
 470                 case CAM_SCENE_NIGHT:
 471                         return CAM_MENU_SCENE_NIGHT;
 472                 case CAM_SCENE_SPORTS:
 473                         return CAM_MENU_SCENE_SPORTS;
 474                 case CAM_SCENE_PARTY:
 475                         return CAM_MENU_SCENE_PARTY;
 476                 case CAM_SCENE_BEACHSNOW:
 477                         return CAM_MENU_SCENE_BEACHSNOW;
 478                 case CAM_SCENE_SUNSET:
 479                         return CAM_MENU_SCENE_SUNSET;
 480                 case CAM_SCENE_DUSKDAWN:
 481                         return CAM_MENU_SCENE_DUSKDAWN;
 482                 case CAM_SCENE_FALL:
 483                         return CAM_MENU_SCENE_FALL;
 484                 case CAM_SCENE_FIREWORK:
 485                         return CAM_MENU_SCENE_FIREWORK;
 486                 case CAM_SCENE_TEXT:
 487                         return CAM_MENU_SCENE_TEXT;
 488                 case CAM_SCENE_CANDLELIGHT:
 489                         return CAM_MENU_SCENE_CANDLELIGHT;
 490                 case CAM_SCENE_BACKLIGHT:
 491                         return CAM_MENU_SCENE_BACKLIGHT;
 492                 default:
 493                         return CAM_MENU_SCENE_AUTO;
 494         }
 495 }
 496
 497 int cam_convert_wb_to_menu_item(int mode)
 498 {
 499         switch(mode)
 500         {
 501                 case CAM_SETTINGS_WB_AWB:
 502                         return CAM_MENU_WB_AWB;
 503                 case CAM_SETTINGS_WB_INCANDESCENT:
 504                         return CAM_MENU_WB_INCANDESCENT;
 505                 case CAM_SETTINGS_WB_FLUORESCENT:
 506                         return CAM_MENU_WB_FLUORESCENT;
 507                 case CAM_SETTINGS_WB_DAYLIGHT:
 508                         return CAM_MENU_WB_DAYLIGHT;
 509                 case CAM_SETTINGS_WB_CLOUDY:
 510                         return CAM_MENU_WB_CLOUDY;
 511                 case CAM_SETTINGS_WB_SHADE:
 512                         return CAM_MENU_WB_SHADE;
 513                 case CAM_SETTINGS_WB_HORIZON:
 514                         return CAM_MENU_WB_HORIZON;
 515                 case CAM_SETTINGS_WB_FLASH:
 516                         return CAM_MENU_WB_FLASH;
 517                 case CAM_SETTINGS_WB_CUSTOM:
 518                         return CAM_MENU_WB_CLOUDY;
 519                 default:
 520                         return CAM_MENU_WB_AWB;
 521         }
 522 }
 523
 524 int cam_convert_effect_to_menu_item(int mode)
 525 {
 526         switch(mode)
 527         {
 528                 case CAM_SETTINGS_EFFECTS_NOR:
 529                         return CAM_MENU_EFFECT_NONE;
 530                 case CAM_SETTINGS_EFFECTS_NEGATIVE:
 531                         return CAM_MENU_EFFECT_NEGATIVE;
 532                 case CAM_SETTINGS_EFFECTS_MONO:
 533                         return CAM_MENU_EFFECT_BLACKANDWHITE;
 534                 case CAM_SETTINGS_EFFECTS_SEPIA:
 535                         return CAM_MENU_EFFECT_SEPIA;
 536                 default:
 537                         return CAM_MENU_EFFECT_NONE;
 538         }
 539 }
 540
 541 int cam_convert_metering_to_menu_item(int mode)
 542 {
 543         switch(mode)
 544         {
 545                 case CAM_METERING_MATRIX:
 546                         return CAM_MENU_METERING_MATRIX;
 547                 case CAM_METERING_CENTER_WEIGHTED:
 548                         return CAM_MENU_METERING_CENTER_WEIGHTED;
 549                 case CAM_METERING_SPOT:
 550                         return CAM_MENU_METERING_SPOT;
 551                 default:
 552                         return CAM_MENU_METERING_MATRIX;
 553         }
 554 }
 555
 556 int cam_convert_storage_to_menu_item(int mode)
 557 {
 558         switch(mode)
 559         {
 560                 case CAM_STORAGE_INTERNAL:
 561                         return CAM_MENU_STORAGE_PHONE;
 562                 case CAM_STORAGE_EXTERNAL:
 563                         return CAM_MENU_STORAGE_MMC;
 564                 default:
 565                         return CAM_MENU_STORAGE_PHONE;
 566         }
 567 }
 568
 569 int cam_convert_volume_key_to_menu_item(int mode)
 570 {
 571         switch(mode)
 572         {
 573                 case CAM_VOLUME_KEY_ZOOM:
 574                         return CAM_MENU_VOLUME_KEY_ZOOM;
 575                 case CAM_VOLUME_KEY_SHUTTER:
 576                         return CAM_MENU_VOLUME_KEY_SHUTTER;
 577                 default:
 578                         return CAM_MENU_VOLUME_KEY_ZOOM;
 579         }
 580 }
 581
 582 int cam_convert_menu_item_to_mmfw_value(int mode)
 583 {
 584         switch(mode)
 585         {
 586                 case CAM_MENU_SCENE_AUTO:
 587                         return  CAM_SCENE_NONE;
 588                 case CAM_MENU_SCENE_PORTRAIT:
 589                         return  CAM_SCENE_PORTRAIT;
 590                 case CAM_MENU_SCENE_LANDSCAPE:
 591                         return  CAM_SCENE_LANDSCAPE;
 592                 case CAM_MENU_SCENE_NIGHT:
 593                         return CAM_SCENE_NIGHT;
 594                 case CAM_MENU_SCENE_SPORTS:
 595                         return CAM_SCENE_SPORTS;
 596                 case CAM_MENU_SCENE_PARTY:
 597                         return CAM_SCENE_PARTY;
 598                 case CAM_MENU_SCENE_BEACHSNOW:
 599                         return CAM_SCENE_BEACHSNOW;
 600                 case CAM_MENU_SCENE_SUNSET:
 601                         return CAM_SCENE_SUNSET;
 602                 case CAM_MENU_SCENE_DUSKDAWN:
 603                         return CAM_SCENE_DUSKDAWN;
 604                 case CAM_MENU_SCENE_FALL:
 605                         return CAM_SCENE_FALL;
 606                 case CAM_MENU_SCENE_FIREWORK:
 607                         return CAM_SCENE_FIREWORK;
 608                 case CAM_MENU_SCENE_TEXT:
 609                         return CAM_SCENE_TEXT;
 610                 case CAM_MENU_SCENE_CANDLELIGHT:
 611                         return CAM_SCENE_CANDLELIGHT;
 612                 case CAM_MENU_SCENE_BACKLIGHT:
 613                         return CAM_SCENE_BACKLIGHT;
 614                 case CAM_MENU_SHOOTING_SINGLE:
 615                         return CAM_SINGLE_MODE;
 616                 case CAM_MENU_SHOOTING_SELF_SINGLE:
 617                         return CAM_SELF_SINGLE_MODE;
 618                 case CAM_MENU_PHOTO_RESOLUTION_3264x2448:
 619                         return CAM_RESOLUTION_3264x2448;
 620                 case CAM_MENU_PHOTO_RESOLUTION_3264x1960:
 621                         return CAM_RESOLUTION_3264x1960;
 622                 case CAM_MENU_PHOTO_RESOLUTION_3264x1836:
 623                         return CAM_RESOLUTION_3264x1836;
 624                 case CAM_MENU_PHOTO_RESOLUTION_2800x1920:
 625                         return CAM_RESOLUTION_2800x1920;
 626                 case CAM_MENU_PHOTO_RESOLUTION_2560x1920:
 627                         return CAM_RESOLUTION_2560x1920;
 628                 case CAM_MENU_PHOTO_RESOLUTION_2560x1536:
 629                         return CAM_RESOLUTION_2560x1536;
 630                 case CAM_MENU_PHOTO_RESOLUTION_2560x1440:
 631                         return CAM_RESOLUTION_2560x1440;
 632                 case CAM_MENU_PHOTO_RESOLUTION_2048x1536:
 633                         return CAM_RESOLUTION_2048x1536;
 634                 case CAM_MENU_PHOTO_RESOLUTION_2048x1152:
 635                         return CAM_RESOLUTION_2048x1152;
 636                 case CAM_MENU_PHOTO_RESOLUTION_1920x1080:
 637                         return CAM_RESOLUTION_1920x1080;
 638                 case CAM_MENU_PHOTO_RESOLUTION_1600x1200:
 639                         return CAM_RESOLUTION_1600x1200;
 640                 case CAM_MENU_PHOTO_RESOLUTION_1392x1392:
 641                         return CAM_RESOLUTION_1392x1392;
 642                 case CAM_MENU_PHOTO_RESOLUTION_1280x960:
 643                         return CAM_RESOLUTION_1280x960;
 644                 case CAM_MENU_PHOTO_RESOLUTION_1280x720:
 645                         return CAM_RESOLUTION_1280x720;
 646                 case CAM_MENU_PHOTO_RESOLUTION_640x480:
 647                         return CAM_RESOLUTION_VGA;
 648                 case CAM_MENU_VIDEO_RESOLUTION_FULLHD:
 649                         return CAM_RESOLUTION_FULLHD;
 650                 case CAM_MENU_VIDEO_RESOLUTION_HD:
 651                         return CAM_RESOLUTION_HD;
 652                 case CAM_MENU_VIDEO_RESOLUTION_WVGA:
 653                         return CAM_RESOLUTION_WVGA2;
 654                 case CAM_MENU_VIDEO_RESOLUTION_VGA:
 655                         return CAM_RESOLUTION_VGA;
 656                 case CAM_MENU_VIDEO_RESOLUTION_QVGA:
 657                         return CAM_RESOLUTION_QVGA;
 658                 case CAM_MENU_VIDEO_RESOLUTION_QCIF:
 659                         return CAM_RESOLUTION_QCIF;
 660                 case CAM_MENU_WB_AWB:
 661                         return CAM_SETTINGS_WB_AWB;
 662                 case CAM_MENU_WB_INCANDESCENT:
 663                         return CAM_SETTINGS_WB_INCANDESCENT;
 664                 case CAM_MENU_WB_FLUORESCENT:
 665                         return CAM_SETTINGS_WB_FLUORESCENT;
 666                 case CAM_MENU_WB_DAYLIGHT:
 667                         return CAM_SETTINGS_WB_DAYLIGHT;
 668                 case CAM_MENU_WB_CLOUDY:
 669                         return CAM_SETTINGS_WB_CLOUDY;
 670                 case CAM_MENU_WB_SHADE:
 671                         return CAM_SETTINGS_WB_SHADE;
 672                 case CAM_MENU_WB_HORIZON:
 673                         return CAM_SETTINGS_WB_HORIZON;
 674                 case CAM_MENU_WB_FLASH:
 675                         return CAM_SETTINGS_WB_FLASH;
 676                 case CAM_MENU_WB_CUSTOM:
 677                         return CAM_SETTINGS_WB_CUSTOM;
 678                 case CAM_MENU_EFFECT_NONE:
 679                         return CAM_SETTINGS_EFFECTS_NOR;
 680                 case CAM_MENU_EFFECT_NEGATIVE:
 681                         return CAM_SETTINGS_EFFECTS_NEGATIVE;
 682                 case CAM_MENU_EFFECT_BLACKANDWHITE:
 683                         return CAM_SETTINGS_EFFECTS_GRAY;
 684                 case CAM_MENU_EFFECT_SEPIA:
 685                         return CAM_SETTINGS_EFFECTS_SEPIA;
 686                 case CAM_MENU_FOCUS_AUTO:
 687                         return CAM_FOCUS_AUTO;
 688                 case CAM_MENU_FOCUS_MACRO:
 689                         return CAM_FOCUS_MACRO;
 690                 case CAM_MENU_FOCUS_FACE_DETECTION:
 691                         return CAM_FOCUS_FACE;
 692                 case CAM_MENU_RECORDING_MODE_NORMAL:
 693                         return CAM_RECORD_NORMAL;
 694                 case CAM_MENU_RECORDING_MODE_LIMIT:
 695                         return CAM_RECORD_MMS;
 696                 case CAM_MENU_RECORDING_MODE_SLOW:
 697                         return CAM_RECORD_SLOW;
 698                 case CAM_MENU_RECORDING_MODE_FAST:
 699                         return CAM_RECORD_FAST;
 700                 case CAM_MENU_RECORDING_MODE_SELF_NORMAL:
 701                         return CAM_RECORD_SELF;
 702                 case CAM_MENU_RECORDING_MODE_SELF_LIMIT:
 703                         return CAM_RECORD_SELF_MMS;
 704                 case CAM_MENU_FLASH_OFF:
 705                         return CAM_FLASH_OFF;
 706                 case CAM_MENU_FLASH_ON:
 707                         return CAM_FLASH_ON;
 708                 case CAM_MENU_FLASH_AUTO:
 709                         return CAM_FLASH_AUTO;
 710                 case CAM_MENU_METERING_MATRIX:
 711                         return CAM_METERING_MATRIX;
 712                 case CAM_MENU_METERING_CENTER_WEIGHTED:
 713                         return CAM_METERING_CENTER_WEIGHTED;
 714                 case CAM_MENU_METERING_SPOT:
 715                         return CAM_METERING_SPOT;
 716                 case CAM_MENU_ISO_AUTO:
 717                         return CAM_ISO_AUTO;
 718                 case CAM_MENU_ISO_50:
 719                         return CAM_ISO_50;
 720                 case CAM_MENU_ISO_100:
 721                         return CAM_ISO_100;
 722                 case CAM_MENU_ISO_200:
 723                         return CAM_ISO_200;
 724                 case CAM_MENU_ISO_400:
 725                         return CAM_ISO_400;
 726                 case CAM_MENU_ISO_80O:
 727                         return CAM_ISO_800;
 728                 case CAM_MENU_ISO_1600:
 729                         return CAM_ISO_1600;
 730                 case CAM_MENU_ISO_320O:
 731                         return CAM_ISO_3200;
 732
 733                 default:
 734                         return -1;
 735
 736         }
 737 }
 738
 739 int cam_get_menu_item_to_index(void* data, int menu_type, int item)
 740 {
 741         cam_menu_composer* menu_composer = NULL;
 742         menu_composer = calloc(1, sizeof(cam_menu_composer));
 743
 744         switch((CAM_MENU_ITEM)menu_type)
 745         {
 746                 case CAM_MENU_SHOOTING_MODE:
 747                         cam_compose_menu_shooting_mode(data, menu_composer);
 748                         break;
 749
 750                 case CAM_MENU_FLASH:
 751                         cam_compose_menu_flash(data, menu_composer);
 752                         break;
 753
 754                 case CAM_MENU_RECORDING_MODE:
 755                         cam_compose_menu_recording_mode(data, menu_composer);
 756                         break;
 757
 758                 case CAM_MENU_PHOTO_RESOLUTION:
 759                         cam_compose_menu_photo_resolution(data, menu_composer);
 760                         break;
 761
 762                 case CAM_MENU_VIDEO_RESOLUTION:
 763                         cam_compose_menu_video_resolution(data, menu_composer);
 764                         break;
 765
 766                 case CAM_MENU_ISO:
 767                         cam_compose_menu_iso(data, menu_composer);
 768                         break;
 769
 770                 case CAM_MENU_FOCUS_MODE:
 771                         cam_compose_menu_focus_mode(data, menu_composer);
 772                         break;
 773
 774                 case CAM_MENU_SCENE_MODE:
 775                         cam_compose_menu_scene_mode(data, menu_composer);
 776                         break;
 777
 778                 case CAM_MENU_WHITE_BALANCE:
 779                         cam_compose_menu_wb(data, menu_composer);
 780                         break;
 781
 782                 case CAM_MENU_EFFECTS:
 783                         cam_compose_menu_effect(data, menu_composer);
 784                         break;
 785
 786                 case CAM_MENU_METERING:
 787                         cam_compose_menu_metering(data, menu_composer);
 788                         break;
 789
 790                 case CAM_MENU_STORAGE:
 791                         cam_compose_menu_storage(data, menu_composer);
 792                         break;
 793
 794                 case CAM_MENU_VOLUME_KEY:
 795                         cam_compose_menu_volume_key(data, menu_composer);
 796                         break;
 797
 798                 default:
 799                         break;
 800         }
 801
 802         CAM_MENU_ITEM* menu_item  = NULL;
 803         int size = eina_array_count(menu_composer->array);
 804
 805
 806         int index = 0;
 807         for (index = 0; index < size; index++) {
 808                 menu_item = (CAM_MENU_ITEM*)eina_array_data_get(menu_composer->array, index);
 809
 810                 if((CAM_MENU_ITEM)item == *menu_item) {
 811                         cam_compose_free(menu_composer);
 812                         return index;
 813                 }
 814         }
 815
 816         cam_compose_free(menu_composer);
 817         return INVALID_INDEX;
 818 }
 819
 820
 821 int cam_get_value_to_index(void* data, int menu_type, int value)
 822 {
 823         cam_menu_composer* menu_composer = NULL;
 824         menu_composer = calloc(1, sizeof(cam_menu_composer));
 825
 826         int item = 0;
 827
 828         switch(menu_type)
 829         {
 830                 case CAM_MENU_SHOOTING_MODE:
 831                         cam_compose_menu_shooting_mode(data, menu_composer);
 832                         item = cam_convert_shot_mode_to_menu_item(value);
 833                         break;
 834
 835                 case CAM_MENU_FLASH:
 836                         cam_compose_menu_flash(data, menu_composer);
 837                         item = cam_convert_flash_to_menu_item(value);
 838                         break;
 839
 840                 case CAM_MENU_RECORDING_MODE:
 841                         cam_compose_menu_recording_mode(data, menu_composer);
 842                         item = cam_convert_recording_mode_to_menu_item(value);
 843                         break;
 844
 845                 case CAM_MENU_PHOTO_RESOLUTION:
 846                         cam_compose_menu_photo_resolution(data, menu_composer);
 847                         item = cam_convert_photo_resolution_to_menu_item(value);
 848                         break;
 849
 850                 case CAM_MENU_VIDEO_RESOLUTION:
 851                         cam_compose_menu_video_resolution(data, menu_composer);
 852                         item = cam_convert_video_resolution_to_menu_item(value);
 853                         break;
 854
 855                 case CAM_MENU_ISO:
 856                         cam_compose_menu_iso(data, menu_composer);
 857                         item = cam_convert_iso_to_menu_item(value);
 858                         break;
 859
 860                 case CAM_MENU_FOCUS_MODE:
 861                         cam_compose_menu_focus_mode(data, menu_composer);
 862                         item = cam_convert_focus_to_menu_item(value);
 863                         break;
 864
 865                 case CAM_MENU_TIMER:
 866                         cam_compose_menu_timer_mode(data, menu_composer);
 867                         item = cam_convert_timer_to_menu_item(value);
 868                         break;
 869
 870                 case CAM_MENU_SCENE_MODE:
 871                         cam_compose_menu_scene_mode(data, menu_composer);
 872                         item = cam_convert_scene_mode_to_menu_item(value);
 873                         break;
 874
 875                 case CAM_MENU_WHITE_BALANCE:
 876                         cam_compose_menu_wb(data, menu_composer);
 877                         item = cam_convert_wb_to_menu_item(value);
 878                         break;
 879
 880                 case CAM_MENU_EFFECTS:
 881                         cam_compose_menu_effect(data, menu_composer);
 882                         item = cam_convert_effect_to_menu_item(value);
 883                         break;
 884
 885                 case CAM_MENU_METERING:
 886                         cam_compose_menu_metering(data, menu_composer);
 887                         item = cam_convert_metering_to_menu_item(value);
 888                         break;
 889
 890                 case CAM_MENU_STORAGE:
 891                         cam_compose_menu_storage(data, menu_composer);
 892                         item = cam_convert_storage_to_menu_item(value);
 893                         break;
 894
 895                 case CAM_MENU_VOLUME_KEY:
 896                         cam_compose_menu_volume_key(data, menu_composer);
 897                         item = cam_convert_volume_key_to_menu_item(value);
 898                         break;
 899
 900                 default:
 901                         break;
 902         }
 903
 904         CAM_MENU_ITEM* menu_item  = NULL;
 905         int size = eina_array_count(menu_composer->array);
 906
 907         int index = 0;
 908         for (index = 0; index < size; index++) {
 909                 menu_item = (CAM_MENU_ITEM*)eina_array_data_get(menu_composer->array, index);
 910
 911                 if((CAM_MENU_ITEM)item == *menu_item) {
 912                         cam_compose_free(menu_composer);
 913                         return index;
 914                 }
 915         }
 916
 917         cam_compose_free(menu_composer);
 918         return INVALID_INDEX;
 919 }
 920
 921 int cam_get_sound_index(int sound)
 922 {
 923         return sound + 1;
 924 }
 925
 926 int shot_mode_set(void *data, int mode)
 927 {
 928         CAM_UI_LOG("%d", mode);
 929         struct appdata *ad = (struct appdata *)data;
 930         CamAppData *camapp = NULL;
 931         cam_retvm_if(ad == NULL, -1, "appdata is NULL");
 932         camapp = ad->camapp_handle;
 933         cam_retvm_if(camapp == NULL, -1, "camapp_handle is NULL");
 934
 935         GValue value = { 0 };
 936         if (mode == CAM_SINGLE_MODE)
 937                 camapp->enable_touch_af = TRUE;
 938         else
 939                 camapp->enable_touch_af = FALSE;
 940
 941         CAM_GVALUE_SET_INT(value, mode);
 942         if (mode != camapp->shooting_mode) {
 943                 cam_handle_value_set(ad, PROP_SHOT_MODE, &value);
 944         }
 945         return 0;
 946 }
 947
 948
 949