src/edc-callback/cam_ev_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 "cam.h"
  19 #include "cam_ev_edc_callback.h"
  20
  21
  22 #define EV_DESTROY_TIME         3
  23 #define EXPOSURE_VALUE_GAP      4
  24
  25
  26 static Evas_Object *slider = NULL;
  27 static Ecore_Timer *ev_destroy_timer = NULL;
  28
  29 static Eina_Bool __ev_destroy_timer_cb(void *data);
  30 static void __set_ev_value(struct appdata *data, int ev_value);
  31 static void __ev_slider_stop_cb(void *data, Evas_Object *obj, void *event_info);
  32 static void __ev_slider_changed_cb(void *data, Evas_Object *obj, void *event_info);
  33 static void __ev_selected_cb(void *data, Evas_Object *obj, const char *emission, const char *source);
  34
  35
  36 static Eina_Bool __ev_destroy_timer_cb(void *data)
  37 {
  38         CAM_UI_LOG();
  39
  40         struct appdata *ad = (struct appdata *)data;
  41         cam_retvm_if(ad == NULL, ECORE_CALLBACK_CANCEL, "appdata is NULL");
  42
  43         unload_ev_edje(ad);
  44
  45         if (ev_destroy_timer)
  46                 ev_destroy_timer = NULL;
  47
  48         return ECORE_CALLBACK_CANCEL;
  49 }
  50
  51 static void __set_ev_value(struct appdata *data, int ev_value)
  52 {
  53         CAM_UI_LOG();
  54
  55         struct appdata *ad = (struct appdata *)data;
  56         cam_retm_if(ad == NULL, "appdata is NULL");
  57
  58         GValue value = { 0 };
  59         CAM_GVALUE_SET_INT(value, ev_value);
  60
  61         if (!cam_handle_value_set(ad, PROP_BRIGHTNESS, &value)) {
  62                 DEBUG_TRACE("cam_handle_value_set failed");
  63         }
  64 }
  65
  66 static void __ev_slider_stop_cb(void *data, Evas_Object *obj, void *event_info)
  67 {
  68         struct appdata *ad = (struct appdata *)data;
  69         cam_retm_if(ad == NULL, "appdata is NULL");
  70
  71         if (obj) {
  72                 Evas_Object *slider = (Evas_Object *)obj;
  73                 int slider_value = (int)elm_slider_value_get(slider);
  74                 elm_slider_value_set(slider, slider_value);
  75         } else {
  76                 cam_critical(LOG_UI, "Error : slider is NULL");
  77         }
  78
  79         if(ev_destroy_timer)
  80                 ecore_timer_reset(ev_destroy_timer);
  81 }
  82
  83 static void __ev_slider_changed_cb(void *data, Evas_Object *obj, void *event_info)
  84 {
  85         struct appdata *ad = (struct appdata *)data;
  86         cam_retm_if(ad == NULL, "appdata is NULL");
  87         CamAppData *camapp = ad->camapp_handle;
  88         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
  89
  90         if (obj) {
  91                 Evas_Object *slider = (Evas_Object *)obj;
  92                 int slider_value = (int)elm_slider_value_get(slider);
  93
  94                 if (camapp->self_portrait == FALSE)
  95                         slider_value += EXPOSURE_VALUE_GAP;
  96
  97                 __set_ev_value(ad, slider_value);
  98         } else {
  99                 cam_critical(LOG_UI, "Error : slider is NULL");
 100         }
 101
 102         if(ev_destroy_timer)
 103                 ecore_timer_reset(ev_destroy_timer);
 104         cam_app_timeout_checker_update();
 105 }
 106
 107 static void __ev_selected_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 108 {
 109         struct appdata *ad = (struct appdata *)data;
 110         cam_retm_if(ad == NULL, "appdata is NULL");
 111         CamAppData *camapp = ad->camapp_handle;
 112         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
 113
 114         if (emission && source)
 115                 cam_debug(LOG_UI, "signal: %s, comes from:%s", emission, source);
 116
 117         int slider_value = (int)elm_slider_value_get(slider);
 118
 119         if (camapp->self_portrait == FALSE)
 120                 slider_value += EXPOSURE_VALUE_GAP;
 121
 122         if (emission) {
 123                 if (strcmp(emission, "icon_minus,clicked") == 0) {
 124                         if (slider_value > camapp->brightness_min)
 125                                 slider_value--;
 126                 } else if (strcmp(emission, "icon_plus,clicked") == 0) {
 127                         if (slider_value < camapp->brightness_max)
 128                                 slider_value++;
 129                 }
 130         } else {
 131                 cam_critical(LOG_UI, "emission is NULL");
 132         }
 133
 134         __set_ev_value(ad, slider_value);
 135         update_ev_edje(ad);
 136
 137         if(ev_destroy_timer)
 138                 ecore_timer_reset(ev_destroy_timer);
 139         cam_app_timeout_checker_update();
 140 }
 141
 142 gboolean load_ev_edje(struct appdata *ad)
 143 {
 144         DEBUG_TRACE("START");
 145
 146         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 147         CamAppData *camapp = ad->camapp_handle;
 148         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 149
 150         if(ad->ev_edje)
 151                 unload_ev_edje(ad);
 152
 153         int slider_max = 0;
 154         int slider_min = 0;
 155
 156         elm_object_part_content_unset(ad->ug_base, "ev_layout");
 157
 158         /* ev bg */
 159         gboolean portrait = FALSE;
 160         gboolean slider_inverse = FALSE;
 161         switch (ad->target_direction) {
 162         case CAM_TARGET_DIRECTION_LANDSCAPE:
 163                 ad->ev_edje = cam_app_load_edj(ad->ug_base, CAM_EV_EDJ_NAME, GRP_MAIN);
 164                 portrait = FALSE;
 165                 slider_inverse = TRUE;
 166                 break;
 167         case CAM_TARGET_DIRECTION_LANDSCAPE_INVERSE:
 168                 ad->ev_edje = cam_app_load_edj(ad->ug_base, CAM_EV_EDJ_INVERSE_NAME, GRP_MAIN);
 169                 portrait = FALSE;
 170                 slider_inverse = FALSE;
 171                 break;
 172         case CAM_TARGET_DIRECTION_PORTRAIT:
 173                 ad->ev_edje = cam_app_load_edj(ad->ug_base, CAM_EV_EDJ_VERTICAL_NAME, GRP_MAIN);
 174                 portrait = TRUE;
 175                 slider_inverse = FALSE;
 176                 break;
 177         case CAM_TARGET_DIRECTION_PORTRAIT_INVERSE:
 178                 ad->ev_edje = cam_app_load_edj(ad->ug_base, CAM_EV_EDJ_VERTICAL_INVERSE_NAME, GRP_MAIN);
 179                 slider_inverse = TRUE;
 180                 portrait = TRUE;
 181                 break;
 182         default:
 183                 cam_critical(LOG_UI, "Invalid target direction!!!");
 184         }
 185
 186         cam_retvm_if(ad->ev_edje == NULL, FALSE, "ev_edje is NULL");
 187         elm_object_part_content_set(ad->ug_base, "ev_layout", ad->ev_edje);
 188
 189         /* ev icon */
 190         if (!ad->ev_icon_minus_edje) {
 191                 ad->ev_icon_minus_edje = (Evas_Object *)edje_object_part_object_get(_EDJ(ad->ev_edje), "icon_minus");
 192         }
 193         cam_retvm_if(ad->ev_icon_minus_edje == NULL, FALSE, "ev_icon_minus_edje is NULL");
 194
 195         if (!ad->ev_icon_plus_edje) {
 196                 ad->ev_icon_plus_edje = (Evas_Object *)edje_object_part_object_get(_EDJ(ad->ev_edje), "icon_plus");
 197         }
 198         cam_retvm_if(ad->ev_icon_plus_edje == NULL, FALSE, "ev_icon_plus_edje is NULL");
 199
 200         /* ev slider */
 201         slider = elm_slider_add(ad->ev_edje);
 202         cam_retvm_if(slider == NULL, FALSE, "slider is NULL");
 203
 204         if (camapp->self_portrait == FALSE)
 205                 slider_max = camapp->brightness_max / 2;
 206         else
 207                 slider_max = camapp->brightness_max;
 208
 209         slider_min = (-slider_max);
 210
 211         elm_object_style_set(slider, "camera");
 212         if (portrait) {
 213                 elm_slider_horizontal_set(slider, EINA_TRUE);
 214         } else {
 215                 elm_slider_horizontal_set(slider, EINA_FALSE);
 216         }
 217         if (slider_inverse) {
 218                 elm_slider_inverted_set(slider, EINA_TRUE);
 219         } else {
 220                 elm_slider_inverted_set(slider, EINA_FALSE);
 221         }
 222
 223         elm_slider_min_max_set(slider, slider_min, slider_max);
 224
 225         if (camapp->self_portrait == FALSE)
 226                 elm_slider_value_set(slider, camapp->brightness - EXPOSURE_VALUE_GAP);
 227         else
 228                 elm_slider_value_set(slider, camapp->brightness);
 229
 230         evas_object_size_hint_align_set(slider, EVAS_HINT_FILL, EVAS_HINT_FILL);
 231         evas_object_size_hint_weight_set(slider, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 232         elm_object_part_content_set(ad->ev_edje, "slider", slider);
 233
 234         evas_object_smart_callback_del(slider, "slider,drag,stop", __ev_slider_stop_cb);
 235         evas_object_smart_callback_add(slider, "slider,drag,stop", __ev_slider_stop_cb, (void*)ad);
 236         evas_object_smart_callback_del(slider, "changed", __ev_slider_changed_cb);
 237         evas_object_smart_callback_add(slider, "changed", __ev_slider_changed_cb, (void*)ad);
 238         edje_object_signal_callback_del(_EDJ(ad->ev_edje), "*", "ev_icon_signal", __ev_selected_cb);
 239         edje_object_signal_callback_add(_EDJ(ad->ev_edje), "*", "ev_icon_signal", __ev_selected_cb, (void *)ad);
 240
 241         ev_destroy_timer = ecore_timer_add(EV_DESTROY_TIME, __ev_destroy_timer_cb, ad);
 242
 243         return TRUE;
 244 }
 245
 246 gboolean update_ev_edje(struct appdata *ad)
 247 {
 248         DEBUG_TRACE("START");
 249
 250         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 251         CamAppData *camapp = ad->camapp_handle;
 252         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 253
 254         cam_retvm_if(ad->ev_edje == NULL, FALSE, "ev_edje is NULL");
 255         cam_retvm_if(slider == NULL, FALSE, "ev slider is NULL");
 256
 257         if (camapp->self_portrait == FALSE)
 258                 elm_slider_value_set(slider, camapp->brightness - EXPOSURE_VALUE_GAP);
 259         else
 260                 elm_slider_value_set(slider, camapp->brightness);
 261
 262         return TRUE;
 263 }
 264
 265 gboolean unload_ev_edje(struct appdata *ad)
 266 {
 267         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 268
 269         DEL_EVAS_OBJECT(ad->ev_icon_minus_edje);
 270         DEL_EVAS_OBJECT(ad->ev_icon_plus_edje);
 271         DEL_EVAS_OBJECT(ad->ev_edje);
 272         REMOVE_TIMER(ev_destroy_timer);
 273
 274         return TRUE;
 275 }
 276
 277 //endfile