src/cam_menu_composer.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (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
  19 #include <app.h>
  20 #include "cam_menu_composer.h"
  21 #include "cam_debug.h"
  22 #include "cam_capacity_type.h"
  23 #include "cam_device_capacity.h"
  24
  25
  26 const CAM_MENU_ITEM setting[] = {CAM_MENU_SHORTCUTS                     , CAM_MENU_VOLUME_KEY           , CAM_MENU_BURST_SHOT_MODE              , CAM_MENU_SELF_PORTRAIT        , CAM_MENU_FLASH , CAM_MENU_SHOOTING_MODE
  27                                                         , CAM_MENU_RECORDING_MODE               , CAM_MENU_SCENE_MODE           , CAM_MENU_EXPLOSURE_VALUE              , CAM_MENU_FOCUS_MODE           , CAM_MENU_TIMER
  28                                                         , CAM_MENU_EFFECTS                              , CAM_MENU_PHOTO_RESOLUTION     , CAM_MENU_VIDEO_RESOLUTION             , CAM_MENU_WHITE_BALANCE        , CAM_MENU_ISO
  29                                                         , CAM_MENU_METERING                             , CAM_MENU_ANTI_SHAKE           , CAM_MENU_OUTDOOR_VISIBILITY   , CAM_MENU_AUTO_CONTRAST        , CAM_MENU_GUIDELINES
  30                                                         , CAM_MENU_CAPTURE_VOICE                , CAM_MENU_GPS_TAG                      , CAM_MENU_SAVE_AS_FLIP                 , CAM_MENU_STORAGE                      , CAM_MENU_RESET};
  31
  32 const CAM_MENU_ITEM scene_mode[] = {CAM_MENU_SCENE_AUTO         , CAM_MENU_SCENE_PORTRAIT       , CAM_MENU_SCENE_LANDSCAPE      , CAM_MENU_SCENE_NIGHT  , CAM_MENU_SCENE_SPORTS
  33                                                                 , CAM_MENU_SCENE_PARTY          , CAM_MENU_SCENE_BEACHSNOW      , CAM_MENU_SCENE_SUNSET         , CAM_MENU_SCENE_DUSKDAWN, CAM_MENU_SCENE_FALL
  34                                                                 , CAM_MENU_SCENE_FIREWORK       , CAM_MENU_SCENE_TEXT           , CAM_MENU_SCENE_CANDLELIGHT, CAM_MENU_SCENE_BACKLIGHT, CAM_MENU_SCENE_SHOW_WINDOW};
  35
  36 const CAM_MENU_ITEM shooting_mode[] = {CAM_MENU_SHOOTING_SINGLE, CAM_MENU_SHOOTING_SELF_SINGLE};
  37
  38 const CAM_MENU_ITEM recording_mode[] = {CAM_MENU_RECORDING_MODE_NORMAL,                 CAM_MENU_RECORDING_MODE_SLOW,   CAM_MENU_RECORDING_MODE_FAST,   CAM_MENU_RECORDING_MODE_LIMIT,
  39                                                                                 CAM_MENU_RECORDING_MODE_SELF_NORMAL,    CAM_MENU_RECORDING_MODE_SELF_LIMIT};
  40
  41 const CAM_MENU_ITEM photo_resolution[] = {CAM_MENU_PHOTO_RESOLUTION_3264x2448           , CAM_MENU_PHOTO_RESOLUTION_3264x1960   , CAM_MENU_PHOTO_RESOLUTION_3264x1836   , CAM_MENU_PHOTO_RESOLUTION_2560x1920
  42                                                                 , CAM_MENU_PHOTO_RESOLUTION_2560x1536                           , CAM_MENU_PHOTO_RESOLUTION_2560x1440   , CAM_MENU_PHOTO_RESOLUTION_2048x1536   , CAM_MENU_PHOTO_RESOLUTION_2048x1152
  43                                                                 , CAM_MENU_PHOTO_RESOLUTION_1920x1080                           , CAM_MENU_PHOTO_RESOLUTION_1600x1200   , CAM_MENU_PHOTO_RESOLUTION_1392x1392   , CAM_MENU_PHOTO_RESOLUTION_1280x960
  44                                                                 , CAM_MENU_PHOTO_RESOLUTION_1280x720                            , CAM_MENU_PHOTO_RESOLUTION_640x480};
  45
  46 const CAM_MENU_ITEM video_resolution[] = {CAM_MENU_VIDEO_RESOLUTION_FULLHD      , CAM_MENU_VIDEO_RESOLUTION_HD          , CAM_MENU_VIDEO_RESOLUTION_WVGA, CAM_MENU_VIDEO_RESOLUTION_VGA
  47                                                                 , CAM_MENU_VIDEO_RESOLUTION_QVGA                        , CAM_MENU_VIDEO_RESOLUTION_QCIF};
  48
  49 const CAM_MENU_ITEM wb[] = {CAM_MENU_WB_AWB             ,               CAM_MENU_WB_INCANDESCENT                ,               CAM_MENU_WB_FLUORESCENT ,               CAM_MENU_WB_DAYLIGHT
  50                                                 , CAM_MENU_WB_CLOUDY    ,               CAM_MENU_WB_SHADE                       ,               CAM_MENU_WB_HORIZON             ,               CAM_MENU_WB_FLASH
  51                                                 , CAM_MENU_WB_CUSTOM};
  52
  53 const CAM_MENU_ITEM effect[] = {CAM_MENU_EFFECT_NONE    ,       CAM_MENU_EFFECT_NEGATIVE        ,       CAM_MENU_EFFECT_BLACKANDWHITE   ,       CAM_MENU_EFFECT_SEPIA };
  54
  55 const CAM_MENU_ITEM focus_mode[] = {CAM_MENU_FOCUS_AUTO ,       CAM_MENU_FOCUS_MACRO    ,       CAM_MENU_FOCUS_FACE_DETECTION   };
  56
  57 const CAM_MENU_ITEM flash[] = {CAM_MENU_FLASH_OFF       ,       CAM_MENU_FLASH_ON       ,       CAM_MENU_FLASH_AUTO     };
  58
  59 const CAM_MENU_ITEM metering[] = {CAM_MENU_METERING_MATRIX      ,       CAM_MENU_METERING_CENTER_WEIGHTED       ,       CAM_MENU_METERING_SPOT  };
  60
  61 const CAM_MENU_ITEM iso[] = {CAM_MENU_ISO_AUTO  ,       CAM_MENU_ISO_50         ,CAM_MENU_ISO_100,      CAM_MENU_ISO_200
  62                                                 ,CAM_MENU_ISO_400       ,       CAM_MENU_ISO_80O,       CAM_MENU_ISO_1600,      CAM_MENU_ISO_320O};
  63
  64 const CAM_MENU_ITEM storage[] = {CAM_MENU_STORAGE_PHONE, CAM_MENU_STORAGE_MMC};
  65 const CAM_MENU_ITEM timer[] = {CAM_MENU_TIMER_OFF,CAM_MENU_TIMER_2SEC, CAM_MENU_TIMER_5SEC,CAM_MENU_TIMER_10SEC};
  66 const CAM_MENU_ITEM volume_key[] = {CAM_MENU_VOLUME_KEY_ZOOM, CAM_MENU_VOLUME_KEY_SHUTTER};
  67
  68
  69 static gboolean __is_enabled_burstshot(void *data);
  70 static gboolean __is_enabled_flash(void* data);
  71 static gboolean __is_enabled_shooting_mode(void* data);
  72 static gboolean __is_enabled_recording_mode(void* data);
  73 static gboolean __is_enabled_scene_mode(void* data);
  74 static gboolean __is_enabled_explosure_value(void* data);
  75 static gboolean __is_enabled_focus_mode(void* data);
  76 static gboolean __is_enabled_timer(void* data);
  77 static gboolean __is_enabled_effects(void* data);
  78 static gboolean __is_enabled_photo_resolution(void* data);
  79 static gboolean __is_enabled_video_resolution(void* data);
  80 static gboolean __is_enabled_white_balance(void* data);
  81 static gboolean __is_enabled_iso(void* data);
  82 static gboolean __is_enabled_metering(void* data);
  83 static gboolean __is_enabled_anti_shake(void* data);
  84 static gboolean __is_enabled_rec_anti_shake(void* data);
  85 static gboolean __is_enabled_outdoor_visibility(void* data);
  86 static gboolean __is_enabled_auto_contrast(void* data);
  87 static gboolean __is_enabled_capture_voice(void* data);
  88 static gboolean __is_enabled_gps_tag(void* data);
  89 static gboolean __is_enalbed_storage(void* data);
  90 static gboolean __is_enabled_self_mode(void* data);
  91 static gboolean __is_enabled_save_as_flip(void *data);
  92
  93
  94 void cam_compose_setting_menu(void *data, cam_menu_composer* composer)
  95 {
  96         struct appdata *ad = (struct appdata *)data;
  97         cam_retm_if(ad == NULL, "appdata is NULL");
  98         CamAppData *camapp = ad->camapp_handle;
  99         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
 100
 101         cam_retm_if(composer == NULL, "composer is NULL");
 102
 103         composer->title =  strdup(dgettext(PACKAGE, "IDS_CAM_BODY_SETTINGS"));
 104         composer->array = eina_array_new(25);
 105         if (!(composer->array)) {
 106                 cam_critical(LOG_CAM, "could not create new eina array");
 107                 return;
 108         }
 109
 110         eina_array_step_set(composer->array, sizeof(*(composer->array)), 5);
 111
 112         unsigned int capacity = 0;
 113         GetCamDevFuncCaps(&capacity, data);
 114
 115         /* Edit shortcuts */
 116         eina_array_push(composer->array, (void*)&setting[0]);
 117
 118         /* Use volume key as */
 119         eina_array_push(composer->array, (void*)&setting[1]);
 120
 121         if(capacity & CAM_CP_FUNC_BURST_SHOT_MODE)
 122                 eina_array_push(composer->array, (void*)&setting[2]);
 123
 124         if(capacity & CAM_CP_FUNC_SELF_MODE)
 125                 eina_array_push(composer->array, (void*)&setting[3]);
 126
 127         if(capacity & CAM_CP_FUNC_FLASH_MODE)
 128                 eina_array_push(composer->array, (void*)&setting[4]);
 129
 130         if(capacity & CAM_CP_FUNC_SHOT_MODE)
 131                 eina_array_push(composer->array, (void*)&setting[5]);
 132
 133         if(capacity & CAM_CP_FUNC_REC_MODE)
 134                 eina_array_push(composer->array, (void*)&setting[6]);
 135
 136         if(capacity & CAM_CP_FUNC_SCENE_MODE)
 137                 eina_array_push(composer->array, (void*)&setting[7]);
 138
 139         if(capacity & CAM_CP_FUNC_EXPOSURE)
 140                 eina_array_push(composer->array, (void*)&setting[8]);
 141
 142         if(capacity & CAM_CP_FUNC_FOCUS_MODE)
 143                 eina_array_push(composer->array, (void*)&setting[9]);
 144
 145         /* Timer */
 146         eina_array_push(composer->array, (void*)&setting[10]);
 147
 148         if(capacity & CAM_CP_FUNC_EFFECT_MODE)
 149                 eina_array_push(composer->array, (void*)&setting[11]);
 150
 151         if(capacity & CAM_CP_FUNC_CAM_RESOLUTION)
 152                 eina_array_push(composer->array, (void*)&setting[12]);
 153
 154         if(capacity & CAM_CP_FUNC_REC_RESOLUTION)
 155                 eina_array_push(composer->array, (void*)&setting[13]);
 156
 157         if(capacity & CAM_CP_FUNC_WHITE_BALANCE)
 158                 eina_array_push(composer->array, (void*)&setting[14]);
 159
 160         if(capacity & CAM_CP_FUNC_ISO)
 161                 eina_array_push(composer->array, (void*)&setting[15]);
 162
 163         if(capacity & CAM_CP_FUNC_METERING)
 164                 eina_array_push(composer->array, (void*)&setting[16]);
 165
 166         if(capacity & CAM_CP_FUNC_CAM_ANS)
 167                 eina_array_push(composer->array, (void*)&setting[17]);
 168
 169         if(capacity & CAM_CP_FUNC_OUTDOOR)
 170                 eina_array_push(composer->array, (void*)&setting[18]);
 171
 172         if(capacity & CAM_CP_FUNC_AUTO_CONTRAST)
 173                 eina_array_push(composer->array, (void*)&setting[19]);
 174
 175         /* Guide lines */
 176         eina_array_push(composer->array, (void*)&setting[20]);
 177
 178         /* Capture with voice */
 179 //      eina_array_push(composer->array, (void*)&setting[21]);
 180
 181         if(capacity & CAM_CP_FUNC_GPS)
 182                 eina_array_push(composer->array, (void*)&setting[22]);
 183
 184 //      eina_array_push(composer->array, (void*)&setting[23]);
 185
 186         if(capacity & CAM_CP_FUNC_STORAGE)
 187                 eina_array_push(composer->array, (void*)&setting[24]);
 188
 189         /* Setting Reset */
 190         eina_array_push(composer->array, (void*)&setting[25]);
 191
 192 }
 193
 194 void cam_compose_list_menu(void *data, int menu_type, cam_menu_composer* composer)
 195 {
 196         struct appdata *ad = (struct appdata *)data;
 197         cam_retm_if(ad == NULL, "appdata is NULL");
 198         CamAppData *camapp = ad->camapp_handle;
 199         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
 200
 201         cam_retm_if(composer == NULL, "composer is NULL");
 202
 203         switch((CAM_MENU_ITEM)menu_type)
 204         {
 205                 case CAM_MENU_VOLUME_KEY:
 206                         cam_compose_menu_volume_key(data, composer);
 207                         break;
 208                 case CAM_MENU_SHOOTING_MODE:
 209                         cam_compose_menu_shooting_mode(data, composer);
 210                         break;
 211                 case CAM_MENU_FLASH:
 212                         cam_compose_menu_flash(data, composer);
 213                         break;
 214                 case CAM_MENU_RECORDING_MODE:
 215                         cam_compose_menu_recording_mode(data, composer);
 216                         break;
 217                 case CAM_MENU_PHOTO_RESOLUTION:
 218                         cam_compose_menu_photo_resolution(data, composer);
 219                         break;
 220                 case CAM_MENU_VIDEO_RESOLUTION:
 221                         cam_compose_menu_video_resolution(data, composer);
 222                         break;
 223                 case CAM_MENU_ISO:
 224                         cam_compose_menu_iso(data, composer);
 225                         break;
 226                 case CAM_MENU_FOCUS_MODE:
 227                         cam_compose_menu_focus_mode(data, composer);
 228                         break;
 229                 case CAM_MENU_TIMER:
 230                         cam_compose_menu_timer_mode(data, composer);
 231                         break;
 232                 case CAM_MENU_SCENE_MODE:
 233                         cam_compose_menu_scene_mode(data, composer);
 234                         break;
 235                 case CAM_MENU_WHITE_BALANCE:
 236                         cam_compose_menu_wb(data, composer);
 237                         break;
 238                 case CAM_MENU_EFFECTS:
 239                         cam_compose_menu_effect(data, composer);
 240                         break;
 241                 case CAM_MENU_METERING:
 242                         cam_compose_menu_metering(data, composer);
 243                         break;
 244                 case CAM_MENU_STORAGE:
 245                         cam_compose_menu_storage(data, composer);
 246                         break;
 247                 default:
 248                         cam_debug(LOG_UI, "invalid menu type");
 249                         break;
 250         }
 251 }
 252
 253 void cam_compose_menu_shooting_mode(void *data, cam_menu_composer* composer)
 254 {
 255         cam_retm_if(composer == NULL, "composer is NULL");
 256
 257         struct appdata *ad = (struct appdata *)data;
 258         cam_retm_if(ad == NULL, "appdata is NULL");
 259         CamAppData *camapp = ad->camapp_handle;
 260         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
 261
 262         composer->array = eina_array_new(10);
 263         if (!(composer->array)) {
 264                 cam_critical(LOG_CAM, "could not create new eina array");
 265                 return;
 266         }
 267         eina_array_step_set(composer->array, sizeof(*(composer->array)), 5);
 268
 269         unsigned int capacity = 0;
 270         GetCamDevShotModeCaps(&capacity, data);
 271
 272         if(camapp->device_type == CAM_DEVICE_MEGA){
 273                 if(capacity & CAM_CP_SHOT_MODE_SINGLE)
 274                         eina_array_push(composer->array, (void*)&shooting_mode[0]);
 275
 276         } else {
 277                 if(capacity & CAM_CP_SHOT_MODE_SINGLE)
 278                         eina_array_push(composer->array, (void*)&shooting_mode[9]);
 279                 }
 280 }
 281
 282 void cam_compose_menu_scene_mode(void *data, cam_menu_composer* composer)
 283 {
 284         cam_retm_if(composer == NULL, "composer is NULL");
 285
 286         composer->array = eina_array_new(15);
 287         if (!(composer->array)) {
 288                 cam_critical(LOG_CAM, "could not create new eina array");
 289                 return;
 290         }
 291
 292         eina_array_step_set(composer->array, sizeof(*(composer->array)), 20);
 293
 294         unsigned int capacity = 0;
 295         GetCamDevSceneModeCaps(&capacity, data);
 296
 297         if(capacity & CAM_CP_SCENE_MODE_AUTO)
 298                 eina_array_push(composer->array, (void*)&scene_mode[0]);
 299
 300         if(capacity & CAM_CP_SCENE_MODE_PORTRAIT)
 301                 eina_array_push(composer->array, (void*)&scene_mode[1]);
 302
 303         if(capacity & CAM_CP_SCENE_MODE_LANDSCAPE)
 304                 eina_array_push(composer->array, (void*)&scene_mode[2]);
 305
 306         if(capacity & CAM_CP_SCENE_MODE_NIGHTSHOT)
 307                 eina_array_push(composer->array, (void*)&scene_mode[3]);
 308
 309         if(capacity & CAM_CP_SCENE_MODE_SPORTS)
 310                 eina_array_push(composer->array, (void*)&scene_mode[4]);
 311
 312         if(capacity & CAM_CP_SCENE_MODE_PARTY_AND_INDOOR)
 313                 eina_array_push(composer->array, (void*)&scene_mode[5]);
 314
 315         if(capacity & CAM_CP_SCENE_MODE_BEACH_AND_SNOW)
 316                 eina_array_push(composer->array, (void*)&scene_mode[6]);
 317
 318         if(capacity & CAM_CP_SCENE_MODE_SUNSET)
 319                 eina_array_push(composer->array, (void*)&scene_mode[7]);
 320
 321         if(capacity & CAM_CP_SCENE_MODE_DUSK_AND_DAWN)
 322                 eina_array_push(composer->array, (void*)&scene_mode[8]);
 323
 324         if(capacity & CAM_CP_SCENE_MODE_FALLCOLOR)
 325                 eina_array_push(composer->array, (void*)&scene_mode[9]);
 326
 327         if(capacity & CAM_CP_SCENE_MODE_FIREWORK)
 328                 eina_array_push(composer->array, (void*)&scene_mode[10]);
 329
 330         if(capacity & CAM_CP_SCENE_MODE_TEXT)
 331                 eina_array_push(composer->array, (void*)&scene_mode[11]);
 332
 333         if(capacity & CAM_CP_SCENE_MODE_CANDLE_LIGHT)
 334                 eina_array_push(composer->array, (void*)&scene_mode[12]);
 335
 336         if(capacity & CAM_CP_SCENE_MODE_BACK_LIGHT)
 337                 eina_array_push(composer->array, (void*)&scene_mode[13]);
 338
 339         if(capacity & CAM_CP_SCENE_MODE_SHOW_WINDOW)
 340                 eina_array_push(composer->array, (void*)&scene_mode[14]);
 341 }
 342
 343 void cam_compose_menu_photo_resolution(void *data, cam_menu_composer* composer)
 344 {
 345         cam_retm_if(composer == NULL, "composer is NULL");
 346
 347         composer->array = eina_array_new(10);
 348         if (!(composer->array)) {
 349                 cam_critical(LOG_CAM, "could not create new eina array");
 350                 return;
 351         }
 352         eina_array_step_set(composer->array, sizeof(*(composer->array)), 15);
 353
 354         unsigned int capacity = 0;
 355         GetCamDevCamResolutionCaps(&capacity, data);
 356
 357
 358         if(capacity & CAM_CP_SIZE_3264X2448)
 359                 eina_array_push(composer->array, (void*)&photo_resolution[0]);
 360
 361         if(capacity & CAM_CP_SIZE_3264X1960)
 362                 eina_array_push(composer->array, (void*)&photo_resolution[1]);
 363
 364         if(capacity & CAM_CP_SIZE_3264X1836)
 365                 eina_array_push(composer->array, (void*)&photo_resolution[2]);
 366
 367         if(capacity & CAM_CP_SIZE_2560X1920)
 368                 eina_array_push(composer->array, (void*)&photo_resolution[3]);
 369
 370         if(capacity & CAM_CP_SIZE_2560X1536)
 371                 eina_array_push(composer->array, (void*)&photo_resolution[4]);
 372
 373         if(capacity & CAM_CP_SIZE_2560X1440)
 374                 eina_array_push(composer->array, (void*)&photo_resolution[5]);
 375
 376         if(capacity & CAM_CP_SIZE_2048X1536)
 377                 eina_array_push(composer->array, (void*)&photo_resolution[6]);
 378
 379         if(capacity & CAM_CP_SIZE_2048X1152)
 380                 eina_array_push(composer->array, (void*)&photo_resolution[7]);
 381
 382         if(capacity & CAM_CP_SIZE_1920X1080)
 383                 eina_array_push(composer->array, (void*)&photo_resolution[8]);
 384
 385         if(capacity & CAM_CP_SIZE_1600X1200)
 386                 eina_array_push(composer->array, (void*)&photo_resolution[9]);
 387
 388         if(capacity & CAM_CP_SIZE_1392X1392)
 389                 eina_array_push(composer->array, (void*)&photo_resolution[10]);
 390
 391         if(capacity & CAM_CP_SIZE_1280X960)
 392                 eina_array_push(composer->array, (void*)&photo_resolution[11]);
 393
 394         if(capacity & CAM_CP_SIZE_1280X720)
 395                 eina_array_push(composer->array, (void*)&photo_resolution[12]);
 396
 397         if(capacity & CAM_CP_SIZE_640X480)
 398                 eina_array_push(composer->array, (void*)&photo_resolution[13]);
 399
 400         int size = eina_array_count(composer->array);
 401         cam_critical(LOG_MM, "size %d ",size );
 402 }
 403
 404 void cam_compose_menu_video_resolution(void *data, cam_menu_composer* composer)
 405 {
 406         cam_retm_if(composer == NULL, "composer is NULL");
 407
 408         composer->array = eina_array_new(10);
 409         if (!(composer->array)) {
 410                 cam_critical(LOG_CAM, "could not create new eina array");
 411                 return;
 412         }
 413         eina_array_step_set(composer->array, sizeof(*(composer->array)), 5);
 414
 415         unsigned int capacity = 0;
 416         GetCamDevRecResolutionCaps(&capacity, data);
 417
 418         if(capacity & CAM_CP_SIZE_1920X1080)
 419                 eina_array_push(composer->array, (void*)&video_resolution[0]);
 420
 421         if(capacity & CAM_CP_SIZE_1280X720)
 422                 eina_array_push(composer->array, (void*)&video_resolution[1]);
 423
 424         if(capacity & CAM_CP_SIZE_720X480)
 425                 eina_array_push(composer->array, (void*)&video_resolution[2]);
 426
 427         if(capacity & CAM_CP_SIZE_640X480)
 428                 eina_array_push(composer->array, (void*)&video_resolution[3]);
 429
 430         if(capacity & CAM_CP_SIZE_320X240)
 431                 eina_array_push(composer->array, (void*)&video_resolution[4]);
 432
 433         int size = eina_array_count(composer->array);
 434         cam_critical(LOG_MM, "size %d ",size );
 435 }
 436
 437 void cam_compose_menu_effect(void *data, cam_menu_composer* composer)
 438 {
 439         cam_retm_if(composer == NULL, "composer is NULL");
 440
 441         composer->array = eina_array_new(5);
 442         if (!(composer->array)) {
 443                 cam_critical(LOG_CAM, "could not create new eina array");
 444                 return;
 445         }
 446         eina_array_step_set(composer->array, sizeof(*(composer->array)), 10);
 447
 448         unsigned int capacity = 0;
 449         GetCamDevEffectCaps(&capacity, data);
 450
 451         if(capacity & CAM_CP_EFFECT_NONE)
 452                 eina_array_push(composer->array, (void*)&effect[0]);
 453
 454         if(capacity & CAM_CP_EFFECT_NEGATIVE)
 455                 eina_array_push(composer->array, (void*)&effect[1]);
 456
 457         if(capacity & CAM_CP_EFFECT_MONO)
 458                 eina_array_push(composer->array, (void*)&effect[2]);
 459
 460         if(capacity & CAM_CP_EFFECT_SEPIA)
 461                 eina_array_push(composer->array, (void*)&effect[3]);
 462 }
 463
 464 void cam_compose_menu_wb(void *data, cam_menu_composer* composer)
 465 {
 466         cam_retm_if(composer == NULL, "composer is NULL");
 467
 468         composer->array = eina_array_new(5);
 469         if (!(composer->array)) {
 470                 cam_critical(LOG_CAM, "could not create new eina array");
 471                 return;
 472         }
 473         eina_array_step_set(composer->array, sizeof(*(composer->array)), 10);
 474
 475         unsigned int capacity = 0;
 476         GetCamDevWBCaps(&capacity, data);
 477
 478         if(capacity & CAM_CP_WB_AUTO)
 479                 eina_array_push(composer->array, (void*)&wb[0]);
 480
 481         if(capacity & CAM_CP_WB_INCANDESCENT)
 482                 eina_array_push(composer->array, (void*)&wb[1]);
 483
 484         if(capacity & CAM_CP_WB_FLUORESCENT)
 485                 eina_array_push(composer->array, (void*)&wb[2]);
 486
 487         if(capacity & CAM_CP_WB_DAYLIGHT)
 488                 eina_array_push(composer->array, (void*)&wb[3]);
 489
 490         if(capacity & CAM_CP_WB_CLOUDY)
 491                 eina_array_push(composer->array, (void*)&wb[4]);
 492
 493         if(capacity & CAM_CP_WB_SHADE)
 494                 eina_array_push(composer->array, (void*)&wb[5]);
 495
 496         if(capacity & CAM_CP_WB_HORIZON)
 497                 eina_array_push(composer->array, (void*)&wb[6]);
 498
 499         if(capacity & CAM_CP_WB_FLASH)
 500                 eina_array_push(composer->array, (void*)&wb[7]);
 501
 502         if(capacity & CAM_CP_WB_CUSTOM)
 503                 eina_array_push(composer->array, (void*)&wb[8]);
 504 }
 505
 506 void cam_compose_menu_focus_mode(void *data, cam_menu_composer* composer)
 507 {
 508         struct appdata *ad = (struct appdata *)data;
 509         cam_retm_if(ad == NULL, "appdata is NULL");
 510         CamAppData *camapp = ad->camapp_handle;
 511         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
 512
 513         cam_retm_if(composer == NULL, "composer is NULL");
 514
 515         composer->array = eina_array_new(5);
 516         if (!(composer->array)) {
 517                 cam_critical(LOG_CAM, "could not create new eina array");
 518                 return;
 519         }
 520         eina_array_step_set(composer->array, sizeof(*(composer->array)), 10);
 521
 522         unsigned int capacity = 0;
 523         GetCamDevFocusCaps(&capacity, data);
 524
 525         if(capacity & CAM_CP_FOCUS_AUTO_FOCUS)
 526                 eina_array_push(composer->array, (void*)&focus_mode[0]);
 527
 528         if(capacity & CAM_CP_FOCUS_MACRO)
 529                 eina_array_push(composer->array, (void*)&focus_mode[1]);
 530
 531         if(!(ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL
 532                 && camapp->camera_mode == CAM_CAMCORDER_MODE)){
 533                 if(capacity & CAM_CP_FOCUS_FACE_DETECTION)
 534                         eina_array_push(composer->array, (void*)&focus_mode[2]);
 535         }
 536 }
 537
 538 void cam_compose_menu_iso(void *data, cam_menu_composer* composer)
 539 {
 540         cam_retm_if(composer == NULL, "composer is NULL");
 541
 542         composer->array = eina_array_new(10);
 543         if (!(composer->array)) {
 544                 cam_critical(LOG_CAM, "could not create new eina array");
 545                 return;
 546         }
 547         eina_array_step_set(composer->array, sizeof(*(composer->array)), 15);
 548
 549         unsigned int capacity = 0;
 550         GetCamDevISOCaps(&capacity, data);
 551
 552         if(capacity & CAM_CP_ISO_AUTO)
 553                 eina_array_push(composer->array, (void*)&iso[0]);
 554
 555         if(capacity & CAM_CP_ISO_50)
 556                 eina_array_push(composer->array, (void*)&iso[1]);
 557
 558         if(capacity & CAM_CP_ISO_100)
 559                 eina_array_push(composer->array, (void*)&iso[2]);
 560
 561         if(capacity & CAM_CP_ISO_200)
 562                 eina_array_push(composer->array, (void*)&iso[3]);
 563
 564         if(capacity & CAM_CP_ISO_400)
 565                 eina_array_push(composer->array, (void*)&iso[4]);
 566
 567         if(capacity & CAM_CP_ISO_800)
 568                 eina_array_push(composer->array, (void*)&iso[5]);
 569
 570 #if 0
 571         if(capacity & CAM_CP_ISO_1600)
 572                 eina_array_push(composer->array, (void*)&iso[6]);
 573
 574         if(capacity & CAM_CP_ISO_3200)
 575                 eina_array_push(composer->array, (void*)&iso[7]);
 576 #endif
 577 }
 578
 579 void cam_compose_menu_metering(void *data, cam_menu_composer* composer)
 580 {
 581         cam_retm_if(composer == NULL, "composer is NULL");
 582
 583         composer->array = eina_array_new(5);
 584         if (!(composer->array)) {
 585                 cam_critical(LOG_CAM, "could not create new eina array");
 586                 return;
 587         }
 588         eina_array_step_set(composer->array, sizeof(*(composer->array)), 10);
 589
 590         unsigned int capacity = 0;
 591         GetCamDevMeteringCaps(&capacity, data);
 592
 593         if(capacity & CAM_CP_METERING_MATRIX)
 594                 eina_array_push(composer->array, (void*)&metering[0]);
 595
 596         if(capacity & CAM_CP_METERING_CENTERWEIGHT)
 597                 eina_array_push(composer->array, (void*)&metering[1]);
 598
 599         if(capacity & CAM_CP_METERING_SPOT)
 600                 eina_array_push(composer->array, (void*)&metering[2]);
 601
 602 }
 603
 604 void cam_compose_menu_recording_mode(void *data, cam_menu_composer* composer)
 605 {
 606         cam_retm_if(composer == NULL, "composer is NULL");
 607
 608         struct appdata *ad = (struct appdata *)data;
 609         cam_retm_if(ad == NULL, "appdata is NULL");
 610         CamAppData *camapp = ad->camapp_handle;
 611         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
 612
 613         composer->array = eina_array_new(5);
 614         if (!(composer->array)) {
 615                 cam_critical(LOG_CAM, "could not create new eina array");
 616                 return;
 617         }
 618         eina_array_step_set(composer->array, sizeof(*(composer->array)), 10);
 619
 620         unsigned int capacity = 0;
 621         GetCamDevRecModeCaps(&capacity, NULL);
 622
 623         if(camapp->device_type == CAM_DEVICE_MEGA){
 624                 if(capacity & CAM_CP_REC_MODE_NORMAL)
 625                         eina_array_push(composer->array, (void*)&recording_mode[0]);
 626
 627                 if(capacity & CAM_CP_REC_MODE_SLOW_MOTION)
 628                         eina_array_push(composer->array, (void*)&recording_mode[1]);
 629
 630                 if(capacity & CAM_CP_REC_MODE_FAST_MOTION)
 631                         eina_array_push(composer->array, (void*)&recording_mode[2]);
 632
 633                 if(capacity & CAM_CP_REC_MODE_MMS)
 634                         eina_array_push(composer->array, (void*)&recording_mode[3]);
 635         } else {
 636                 if(capacity & CAM_CP_REC_MODE_NORMAL)
 637                         eina_array_push(composer->array, (void*)&recording_mode[4]);
 638
 639                 if(capacity & CAM_CP_REC_MODE_MMS)
 640                         eina_array_push(composer->array, (void*)&recording_mode[5]);
 641         }
 642 }
 643
 644
 645 void cam_compose_menu_flash(void *data, cam_menu_composer* composer)
 646 {
 647         struct appdata *ad = (struct appdata *)data;
 648         cam_ret_if(ad == NULL);
 649
 650         CamAppData *camapp = NULL;
 651         camapp = ad->camapp_handle;
 652         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
 653
 654         cam_retm_if(composer == NULL, "composer is NULL");
 655
 656         composer->array = eina_array_new(5);
 657         if (!(composer->array)) {
 658                 cam_critical(LOG_CAM, "could not create new eina array");
 659                 return;
 660         }
 661         eina_array_step_set(composer->array, sizeof(*(composer->array)), 10);
 662
 663         unsigned int capacity = 0;
 664         GetCamDevFlashCaps(&capacity, data);
 665
 666         if(capacity & CAM_CP_FLASH_OFF)
 667                 eina_array_push(composer->array, (void*)&flash[0]);
 668
 669         if(capacity & CAM_CP_FLASH_ON)
 670                 eina_array_push(composer->array, (void*)&flash[1]);
 671
 672         if(camapp->camera_mode == CAM_CAMERA_MODE){
 673                 if(capacity & CAM_CP_FLASH_AUTO)
 674                 eina_array_push(composer->array, (void*)&flash[2]);
 675         }
 676
 677 }
 678
 679 void cam_compose_menu_timer_mode(void *data, cam_menu_composer* composer)
 680 {
 681         cam_retm_if(composer == NULL, "composer is NULL");
 682
 683         composer->array = eina_array_new(4);
 684         if (!(composer->array)) {
 685                 cam_critical(LOG_CAM, "could not create new eina array");
 686                 return;
 687         }
 688         eina_array_step_set(composer->array, sizeof(*(composer->array)), 8);
 689
 690         eina_array_push(composer->array, (void*)&timer[0]);
 691         eina_array_push(composer->array, (void*)&timer[1]);
 692         eina_array_push(composer->array, (void*)&timer[2]);
 693         eina_array_push(composer->array, (void*)&timer[3]);
 694 }
 695
 696 void cam_compose_menu_storage(void* data, cam_menu_composer* composer)
 697 {
 698         cam_retm_if(composer == NULL, "composer is NULL");
 699
 700         composer->array = eina_array_new(2);
 701         if (!(composer->array)) {
 702                 cam_critical(LOG_CAM, "could not create new eina array");
 703                 return;
 704         }
 705         eina_array_step_set(composer->array, sizeof(*(composer->array)), 4);
 706
 707         eina_array_push(composer->array, (void*)&storage[0]);
 708         eina_array_push(composer->array, (void*)&storage[1]);
 709 }
 710
 711 void cam_compose_menu_volume_key(void* data, cam_menu_composer* composer)
 712 {
 713         cam_retm_if(composer == NULL, "composer is NULL");
 714
 715         composer->array = eina_array_new(2);
 716         if (!(composer->array)) {
 717                 cam_critical(LOG_CAM, "could not create new eina array");
 718                 return;
 719         }
 720         eina_array_step_set(composer->array, sizeof(*(composer->array)), 2);
 721
 722         eina_array_push(composer->array, (void*)&volume_key[0]);
 723         eina_array_push(composer->array, (void*)&volume_key[1]);
 724 }
 725
 726 void cam_compose_free(cam_menu_composer* composer)
 727 {
 728         cam_ret_if(composer == NULL);
 729
 730         if (composer->title)
 731                 free(composer->title);
 732
 733         if (composer->array)
 734                 eina_array_free(composer->array);
 735
 736         free(composer);
 737 }
 738
 739 gboolean cam_is_enabled_menu(void *data, const CAM_MENU_ITEM item)
 740 {
 741         struct appdata *ad = (struct appdata *)data;
 742         cam_retv_if(ad == NULL, FALSE);
 743
 744         switch(item) {
 745                 case CAM_MENU_SHORTCUTS:
 746                         return TRUE;
 747                 case CAM_MENU_BURST_SHOT_MODE:
 748                         return __is_enabled_burstshot((void*)ad);
 749                 case CAM_MENU_SELF_PORTRAIT:
 750                         return __is_enabled_self_mode((void*)ad);
 751                 case CAM_MENU_FLASH:
 752                         return __is_enabled_flash((void*)ad);
 753                 case CAM_MENU_SHOOTING_MODE:
 754                         return __is_enabled_shooting_mode((void*)ad);
 755                 case CAM_MENU_RECORDING_MODE:
 756                         return __is_enabled_recording_mode((void*)ad);
 757                 case CAM_MENU_SCENE_MODE:
 758                         return __is_enabled_scene_mode((void*)ad);
 759                 case CAM_MENU_EXPLOSURE_VALUE:
 760                         return __is_enabled_explosure_value((void*)ad);
 761                 case CAM_MENU_FOCUS_MODE:
 762                         return __is_enabled_focus_mode((void*)ad);
 763                 case CAM_MENU_TIMER:
 764                         return __is_enabled_timer((void*)ad);
 765                 case CAM_MENU_EFFECTS:
 766                         return __is_enabled_effects((void*)ad);
 767                 case CAM_MENU_PHOTO_RESOLUTION:
 768                         return __is_enabled_photo_resolution((void*)ad);
 769                 case CAM_MENU_VIDEO_RESOLUTION:
 770                         return __is_enabled_video_resolution((void*)ad);
 771                 case CAM_MENU_WHITE_BALANCE:
 772                         return __is_enabled_white_balance((void*)ad);
 773                 case CAM_MENU_ISO:
 774                         return __is_enabled_iso((void*)ad);
 775                 case CAM_MENU_METERING:
 776                         return __is_enabled_metering((void*)ad);
 777                 case CAM_MENU_ANTI_SHAKE:
 778                         return __is_enabled_anti_shake((void*)ad);
 779                 case CAM_MENU_OUTDOOR_VISIBILITY:
 780                         return __is_enabled_outdoor_visibility((void*)ad);
 781                 case CAM_MENU_AUTO_CONTRAST:
 782                         return __is_enabled_auto_contrast((void*)ad);
 783                 case CAM_MENU_GUIDELINES:
 784                         return TRUE;
 785                 case CAM_MENU_CAPTURE_VOICE:
 786                         return __is_enabled_capture_voice((void*)ad);
 787                 case CAM_MENU_SAVE_AS_FLIP:
 788                         return __is_enabled_save_as_flip((void*)ad);
 789                 case CAM_MENU_GPS_TAG:
 790                         return __is_enabled_gps_tag((void*)ad);
 791                 case CAM_MENU_STORAGE:
 792                         return __is_enalbed_storage((void*)ad);;
 793                 case CAM_MENU_RESET:
 794                         return TRUE;
 795                 case CAM_MENU_VOLUME_KEY:
 796                         return TRUE;
 797                 default:
 798                         break;
 799                 }
 800
 801         return TRUE;
 802
 803 }
 804
 805 static gboolean __is_enabled_burstshot(void *data)
 806 {
 807         struct appdata *ad = (struct appdata *)data;
 808         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 809         CamAppData *camapp = ad->camapp_handle;
 810         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 811
 812         unsigned int capacity;
 813         GetCamDevFuncCaps(&capacity, NULL);
 814
 815         if (!(capacity & CAM_CP_FUNC_BURST_SHOT_MODE))
 816                 return FALSE;
 817
 818         if ((camapp->shooting_mode != CAM_SINGLE_MODE)
 819                         && (camapp->shooting_mode != CAM_SELF_SINGLE_MODE))
 820                 return FALSE;
 821
 822         if(ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL)
 823                 return FALSE;
 824
 825         return TRUE;
 826 }
 827
 828 static gboolean __is_enabled_flash(void* data)
 829 {
 830         struct appdata *ad = (struct appdata *)data;
 831         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 832         CamAppData *camapp = ad->camapp_handle;
 833         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 834
 835         unsigned int capacity;
 836         GetCamDevFuncCaps(&capacity, NULL);
 837
 838         if(!(capacity & CAM_CP_FUNC_FLASH_MODE))
 839                 return FALSE;
 840
 841         if(ad->battery_status == LOW_BATTERY_WARNING_STATUS)
 842                 return FALSE;
 843
 844         if(!(camapp->scene_mode == CAM_SCENE_NONE
 845                 || camapp->scene_mode == CAM_SCENE_PORTRAIT
 846                 || camapp->scene_mode == CAM_SCENE_BACKLIGHT
 847                 || camapp->scene_mode == CAM_SCENE_PARTY
 848                 || camapp->scene_mode == CAM_SCENE_TEXT) )
 849                 return FALSE;
 850
 851         if (ad->torchlight_on)
 852                 return FALSE;
 853
 854         return TRUE;
 855
 856 }
 857
 858 static gboolean __is_enabled_shooting_mode(void* data)
 859 {
 860         struct appdata *ad = (struct appdata *)data;
 861         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 862         CamAppData *camapp = ad->camapp_handle;
 863         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 864
 865         unsigned int capacity;
 866         GetCamDevFuncCaps(&capacity, (void*)ad);
 867
 868         if(!(capacity & CAM_CP_FUNC_SHOT_MODE))
 869                 return FALSE;
 870
 871         if (ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL
 872                 && ad->exe_args->allow_switch == FALSE
 873                 && camapp->camera_mode == CAM_CAMCORDER_MODE)
 874                 return FALSE;
 875
 876         return TRUE;
 877 }
 878
 879 static gboolean __is_enabled_recording_mode(void* data)
 880 {
 881         struct appdata *ad = (struct appdata *)data;
 882         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 883         CamAppData *camapp = ad->camapp_handle;
 884         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 885
 886         if(ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL
 887                 && ad->exe_args->allow_switch == FALSE
 888                 && camapp->camera_mode == CAM_CAMERA_MODE)
 889                 return FALSE;
 890
 891         if(ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL
 892                 && ad->exe_args->resolution == CAM_RESOLUTION_QCIF)
 893                 return FALSE;
 894
 895         return TRUE;
 896 }
 897
 898 static gboolean __is_enabled_scene_mode(void* data)
 899 {
 900         struct appdata *ad = (struct appdata *)data;
 901         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 902         CamAppData *camapp = ad->camapp_handle;
 903         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 904
 905         unsigned int capacity;
 906         GetCamDevFuncCaps(&capacity, (void*)ad);
 907
 908         if(!(capacity & CAM_CP_FUNC_SCENE_MODE))
 909                 return FALSE;
 910
 911         if(ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL
 912                 && ad->exe_args->allow_switch == FALSE
 913                 && camapp->camera_mode == CAM_CAMCORDER_MODE)
 914                 return FALSE;
 915
 916         return TRUE;
 917
 918 }
 919
 920 static gboolean __is_enabled_explosure_value(void* data)
 921 {
 922         struct appdata *ad = (struct appdata *)data;
 923         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 924         CamAppData *camapp = ad->camapp_handle;
 925         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 926
 927         unsigned int capacity;
 928         GetCamDevFuncCaps(&capacity, (void*)ad);
 929
 930         if(!(capacity & CAM_CP_FUNC_EXPOSURE))
 931                 return FALSE;
 932
 933         if(camapp->scene_mode != CAM_SCENE_NONE)
 934                 return FALSE;
 935
 936         return TRUE;
 937
 938 }
 939
 940 static gboolean __is_enabled_focus_mode(void* data)
 941 {
 942         struct appdata *ad = (struct appdata *)data;
 943         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 944         CamAppData *camapp = ad->camapp_handle;
 945         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 946
 947         unsigned int capacity;
 948         GetCamDevFuncCaps(&capacity, (void*)ad);
 949
 950         if(!(capacity & CAM_CP_FUNC_FOCUS_MODE))
 951                 return FALSE;
 952
 953         if(camapp->scene_mode != CAM_SCENE_NONE)
 954                 return FALSE;
 955
 956         return TRUE;
 957
 958 }
 959
 960 static gboolean __is_enabled_timer(void* data)
 961 {
 962         struct appdata *ad = (struct appdata *)data;
 963         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 964         CamAppData *camapp = ad->camapp_handle;
 965         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 966
 967         unsigned int capacity;
 968         GetCamDevFuncCaps(&capacity, (void*)ad);
 969
 970         return TRUE;
 971
 972 }
 973
 974 static gboolean __is_enabled_effects(void* data)
 975 {
 976         struct appdata *ad = (struct appdata *)data;
 977         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 978         CamAppData *camapp = ad->camapp_handle;
 979         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 980
 981         unsigned int capacity;
 982         GetCamDevFuncCaps(&capacity, (void*)ad);
 983
 984         if(!(capacity & CAM_CP_FUNC_EFFECT_MODE))
 985                 return FALSE;
 986
 987         if(camapp->scene_mode != CAM_SCENE_NONE)
 988                 return FALSE;
 989
 990         return TRUE;
 991
 992 }
 993
 994 static gboolean __is_enabled_photo_resolution(void* data)
 995 {
 996         struct appdata *ad = (struct appdata *)data;
 997         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 998         CamAppData *camapp = ad->camapp_handle;
 999         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
1000
1001         unsigned int capacity;
1002         GetCamDevFuncCaps(&capacity, (void*)ad);
1003
1004         if(ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL
1005                 && ad->exe_args->allow_switch == FALSE
1006                 && camapp->camera_mode == CAM_CAMCORDER_MODE)
1007                 return FALSE;
1008
1009         return TRUE;
1010 }
1011
1012 static gboolean __is_enabled_video_resolution(void* data)
1013 {
1014         struct appdata *ad = (struct appdata *)data;
1015         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1016         CamAppData *camapp = ad->camapp_handle;
1017         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
1018
1019         unsigned int capacity;
1020         GetCamDevFuncCaps(&capacity, (void*)ad);
1021
1022         if(camapp->recording_mode == CAM_RECORD_MMS
1023                 || camapp->recording_mode == CAM_RECORD_SELF_MMS
1024                 || camapp->recording_mode == CAM_RECORD_SLOW
1025                 || camapp->recording_mode == CAM_RECORD_FAST)
1026                 return FALSE;
1027
1028         if(ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL
1029                 && ad->exe_args->allow_switch == FALSE
1030                 && camapp->camera_mode == CAM_CAMERA_MODE)
1031                 return FALSE;
1032
1033         return TRUE;
1034 }
1035
1036 static gboolean __is_enabled_white_balance(void* data)
1037 {
1038         struct appdata *ad = (struct appdata *)data;
1039         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1040         CamAppData *camapp = ad->camapp_handle;
1041         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
1042
1043         unsigned int capacity;
1044         GetCamDevFuncCaps(&capacity, (void*)ad);
1045
1046         if(!(capacity & CAM_CP_FUNC_WHITE_BALANCE))
1047                 return FALSE;
1048
1049         if(camapp->scene_mode != CAM_SCENE_NONE)
1050                 return FALSE;
1051
1052         return TRUE;
1053 }
1054
1055 static gboolean __is_enabled_iso(void* data)
1056 {
1057         struct appdata *ad = (struct appdata *)data;
1058         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1059         CamAppData *camapp = ad->camapp_handle;
1060         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
1061
1062         unsigned int capacity;
1063         GetCamDevFuncCaps(&capacity, (void*)ad);
1064
1065         if(!(capacity & CAM_CP_FUNC_ISO))
1066                 return FALSE;
1067
1068         if(camapp->scene_mode != CAM_SCENE_NONE)
1069                 return FALSE;
1070
1071         if(camapp->camera_mode == CAM_CAMCORDER_MODE)
1072                 return FALSE;
1073
1074         return TRUE;
1075
1076 }
1077
1078 static gboolean __is_enabled_metering(void* data)
1079 {
1080         struct appdata *ad = (struct appdata *)data;
1081         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1082         CamAppData *camapp = ad->camapp_handle;
1083         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
1084
1085         unsigned int capacity;
1086         GetCamDevFuncCaps(&capacity, (void*)ad);
1087
1088         if(!(capacity & CAM_CP_FUNC_METERING))
1089                 return FALSE;
1090
1091         if(camapp->scene_mode != CAM_SCENE_NONE)
1092                 return FALSE;
1093
1094         if(camapp->camera_mode == CAM_CAMCORDER_MODE)
1095                 return FALSE;
1096
1097         return TRUE;
1098
1099 }
1100
1101 static gboolean __is_enabled_anti_shake(void* data)
1102 {
1103         struct appdata *ad = (struct appdata *)data;
1104         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1105         CamAppData *camapp = ad->camapp_handle;
1106         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
1107
1108         unsigned int capacity;
1109         GetCamDevFuncCaps(&capacity, (void*)ad);
1110
1111         if (!(capacity & CAM_CP_FUNC_CAM_ANS))
1112                 return FALSE;
1113
1114         if (camapp->scene_mode != CAM_SCENE_NONE)
1115                 return FALSE;
1116
1117         return TRUE;
1118
1119 }
1120
1121 static gboolean __is_enabled_rec_anti_shake(void* data)
1122 {
1123         struct appdata *ad = (struct appdata *)data;
1124         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1125
1126         unsigned int capacity;
1127         GetCamDevFuncCaps(&capacity, (void*)ad);
1128
1129         if(!(capacity & CAM_CP_FUNC_REC_ANS))
1130                 return FALSE;
1131
1132         return TRUE;
1133 }
1134
1135
1136 static gboolean __is_enabled_outdoor_visibility(void* data)
1137 {
1138         struct appdata *ad = (struct appdata *)data;
1139         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1140         CamAppData *camapp = ad->camapp_handle;
1141         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
1142
1143         unsigned int capacity;
1144         GetCamDevFuncCaps(&capacity, (void*)ad);
1145
1146         if(!(capacity & CAM_CP_FUNC_OUTDOOR))
1147                 return FALSE;
1148
1149         return TRUE;
1150
1151 }
1152
1153 static gboolean __is_enabled_auto_contrast(void* data)
1154 {
1155         struct appdata *ad = (struct appdata *)data;
1156         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1157         CamAppData *camapp = ad->camapp_handle;
1158         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
1159
1160         unsigned int capacity;
1161         GetCamDevFuncCaps(&capacity, (void*)ad);
1162
1163         if(!(capacity & CAM_CP_FUNC_AUTO_CONTRAST))
1164                 return FALSE;
1165
1166         if(camapp->scene_mode != CAM_SCENE_NONE)
1167                 return FALSE;
1168
1169
1170         return TRUE;
1171
1172 }
1173
1174 static gboolean __is_enabled_self_mode(void* data)
1175 {
1176         struct appdata *ad = (struct appdata *)data;
1177         cam_retv_if(ad == NULL, FALSE);
1178
1179         unsigned int capacity;
1180         GetCamDevFuncCaps(&capacity, (void*)ad);
1181
1182         if(!(capacity & CAM_CP_FUNC_SELF_MODE))
1183                 return FALSE;
1184         return TRUE;
1185
1186 }
1187
1188
1189 static gboolean __is_enabled_capture_voice(void* data)
1190 {
1191         struct appdata *ad = (struct appdata *)data;
1192         cam_retv_if(ad == NULL, FALSE);
1193
1194         unsigned int capacity;
1195         GetCamDevFuncCaps(&capacity, (void*)ad);
1196
1197         if(!(capacity & CAM_CP_FUNC_CAPTURE_VOICE))
1198                 return FALSE;
1199
1200         return TRUE;
1201
1202 }
1203
1204 static gboolean __is_enabled_gps_tag(void* data)
1205 {
1206         struct appdata *ad = (struct appdata *)data;
1207         cam_retv_if(ad == NULL, FALSE);
1208
1209         unsigned int capacity;
1210         GetCamDevFuncCaps(&capacity, (void*)ad);
1211
1212         if(!(capacity & CAM_CP_FUNC_GPS))
1213                 return FALSE;
1214
1215         return TRUE;
1216
1217 }
1218
1219 static gboolean __is_enabled_save_as_flip(void *data)
1220 {
1221         struct appdata *ad = (struct appdata *)data;
1222         cam_retv_if(ad == NULL, FALSE);
1223
1224         unsigned int capacity;
1225         GetCamDevFuncCaps(&capacity, (void*)ad);
1226
1227         if(!(capacity & CAM_CP_FUNC_SAVE_AS_FLIP))
1228                 return FALSE;
1229
1230         return TRUE;
1231
1232 }
1233
1234
1235 static gboolean __is_enalbed_storage(void* data)
1236 {
1237         int noti_message;
1238         int ret = -1;
1239
1240         ret = vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &noti_message);
1241
1242         if ( ret != 0 ) // falied
1243         {
1244                 cam_debug(LOG_CAM, "Get %s is failed", VCONFKEY_SYSMAN_MMC_STATUS);
1245                 return FALSE;
1246         }
1247
1248         if(noti_message==VCONFKEY_SYSMAN_MMC_MOUNTED)
1249         {
1250                 return TRUE;
1251         }
1252         return FALSE;
1253 }
1254