src/edc-callback/cam_zoom_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_zoom_edc_callback.h"
  20 #include "cam_capacity_type.h"
  21 #include "cam_device_capacity.h"
  22
  23
  24 #define ZOOM_DESTROY_TIME       3.0
  25
  26
  27 static Evas_Object *slider = NULL;
  28 static Ecore_Timer *zoom_destroy_timer = NULL;
  29 static int zoom_value[CAM_ZOOM_VALUE_MAX] = { 0 };
  30
  31 static gboolean __init_zoom_value(struct appdata *ad);
  32 static Eina_Bool __zoom_destroy_timer_cb(void *data);
  33 static void __set_zoom_value(struct appdata *data, int zoom_level);
  34 static void __zoom_slider_stop_cb(void *data, Evas_Object *obj, void *event_info);
  35 static void __zoom_slider_changed_cb(void *data, Evas_Object *obj, void *event_info);
  36 static void __set_gauge_focus(struct appdata *data);
  37
  38
  39 static gboolean __init_zoom_value(struct appdata *ad)
  40 {
  41         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
  42         CamAppData *camapp = ad->camapp_handle;
  43         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
  44
  45         int i = 0;
  46         double gap = (double)(camapp->zoom_max - camapp->zoom_min) / (CAM_ZOOM_VALUE_MAX - 2);
  47         for (i = 2; i < CAM_ZOOM_VALUE_MAX - 1; i++) {
  48                 zoom_value[i] = (int)(0.5 + camapp->zoom_min + (i - 1) * gap);
  49                 DEBUG_TRACE("zoom_value[%d] =%d", i, zoom_value[i]);
  50         }
  51         zoom_value[1] = camapp->zoom_min;
  52         DEBUG_TRACE("zoom_value[%d] =%d", 1, zoom_value[1]);
  53         zoom_value[CAM_ZOOM_VALUE_MAX - 1] = camapp->zoom_max;
  54         DEBUG_TRACE("zoom_value[%d] =%d", (CAM_ZOOM_VALUE_MAX - 1), zoom_value[CAM_ZOOM_VALUE_MAX - 1]);
  55
  56         return TRUE;
  57 }
  58
  59 static Eina_Bool __zoom_destroy_timer_cb(void *data)
  60 {
  61         CAM_UI_LOG();
  62
  63         struct appdata *ad = (struct appdata *)data;
  64         cam_retvm_if(ad == NULL, ECORE_CALLBACK_CANCEL, "appdata is NULL");
  65
  66         unload_zoom_edje(ad);
  67
  68         if (zoom_destroy_timer)
  69                 zoom_destroy_timer = NULL;
  70
  71         return ECORE_CALLBACK_CANCEL;
  72 }
  73
  74 static void __set_zoom_value(struct appdata *data, int zoom_level)
  75 {
  76         struct appdata *ad = (struct appdata *)data;
  77         cam_retm_if(ad == NULL, "appdata is NULL");
  78         CamAppData *camapp = ad->camapp_handle;
  79         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
  80
  81         int zoom = 0;
  82         GValue value = { 0, };
  83
  84         camapp->zoom_mode = zoom_level;
  85
  86         zoom = zoom_value[camapp->zoom_mode];
  87         DEBUG_TRACE("zoom_value =%d", zoom);
  88         CAM_GVALUE_SET_INT(value, zoom);
  89
  90         if (!cam_handle_value_set(ad, PROP_ZOOM, &value)) {
  91                 cam_critical(LOG_CAM, "cam_handle_value_set failed");
  92         }
  93 }
  94
  95 static void __zoom_slider_stop_cb(void *data, Evas_Object *obj, void *event_info)
  96 {
  97         struct appdata *ad = (struct appdata *)data;
  98         cam_retm_if(ad == NULL, "appdata is NULL");
  99
 100         if (obj) {
 101                 DEBUG_TRACE("");
 102                 Evas_Object *slider = (Evas_Object *)obj;
 103                 int slider_value = (int)elm_slider_value_get(slider);
 104                 elm_slider_value_set(slider, slider_value);
 105                 __set_zoom_value(ad, slider_value);
 106         } else {
 107                 cam_critical(LOG_UI, "Error : slider is NULL");
 108         }
 109
 110         if(zoom_destroy_timer)
 111                 ecore_timer_reset(zoom_destroy_timer);
 112 }
 113
 114 static void __zoom_slider_changed_cb(void *data, Evas_Object *obj, void *event_info)
 115 {
 116         struct appdata *ad = (struct appdata *)data;
 117         cam_retm_if(ad == NULL, "appdata is NULL");
 118
 119         if (obj) {
 120                 Evas_Object *slider = (Evas_Object *)obj;
 121                 int slider_value = (int)elm_slider_value_get(slider);
 122                 DEBUG_TRACE("slider_value:%d", slider_value);
 123                 __set_zoom_value(ad, slider_value);
 124         } else {
 125                 cam_critical(LOG_UI, "Error : slider is NULL");
 126         }
 127
 128         if(zoom_destroy_timer)
 129                 ecore_timer_reset(zoom_destroy_timer);
 130 }
 131
 132 gboolean load_zoom_edje(struct appdata *ad)
 133 {
 134         DEBUG_TRACE("START");
 135
 136         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 137         CamAppData *camapp = ad->camapp_handle;
 138         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 139
 140         elm_object_part_content_unset(ad->ug_base, "zoom_layout");
 141         if (ad->zoom_edje)
 142                 cam_zoom_unload_edje(ad);
 143
 144         /* zoom bg */
 145         gboolean portrait = FALSE;
 146         gboolean slider_inverse = FALSE;
 147         switch (ad->target_direction) {
 148         case CAM_TARGET_DIRECTION_LANDSCAPE:
 149                 ad->zoom_edje = cam_app_load_edj(ad->ug_base, CAM_ZOOM_EDJ_NAME, GRP_MAIN);
 150                 portrait = FALSE;
 151                 slider_inverse = TRUE;
 152                 break;
 153         case CAM_TARGET_DIRECTION_LANDSCAPE_INVERSE:
 154                 ad->zoom_edje = cam_app_load_edj(ad->ug_base, CAM_ZOOM_EDJ_INVERSE_NAME, GRP_MAIN);
 155                 portrait = FALSE;
 156                 slider_inverse = FALSE;
 157                 break;
 158         case CAM_TARGET_DIRECTION_PORTRAIT:
 159                 ad->zoom_edje = cam_app_load_edj(ad->ug_base, CAM_ZOOM_EDJ_VERTICAL_NAME, GRP_MAIN);
 160                 portrait = TRUE;
 161                 slider_inverse = FALSE;
 162                 break;
 163         case CAM_TARGET_DIRECTION_PORTRAIT_INVERSE:
 164                 ad->zoom_edje = cam_app_load_edj(ad->ug_base, CAM_ZOOM_EDJ_VERTICAL_INVERSE_NAME, GRP_MAIN);
 165                 slider_inverse = TRUE;
 166                 portrait = TRUE;
 167                 break;
 168         default:
 169                 DEBUG_TRACE("wow, reached un-able reached codes");
 170         }
 171
 172         cam_retvm_if(ad->zoom_edje == NULL, FALSE, "zom_edje is NULL");
 173         elm_object_part_content_set(ad->ug_base, "zoom_layout", ad->zoom_edje);
 174
 175         /* zoom text */
 176         if (!ad->zoom_text_min_edje) {
 177                 ad->zoom_text_min_edje = (Evas_Object *)edje_object_part_object_get(_EDJ(ad->zoom_edje), "text_min");
 178         }
 179         cam_retvm_if(ad->zoom_text_min_edje == NULL, FALSE, "zoom_text_min is NULL");
 180
 181         if (!ad->zoom_text_max_edje) {
 182                 ad->zoom_text_max_edje = (Evas_Object *)edje_object_part_object_get(_EDJ(ad->zoom_edje), "text_max");
 183         }
 184         cam_retvm_if(ad->zoom_text_max_edje == NULL, FALSE, "zoom_text_max is NULL");
 185
 186         edje_object_part_text_set(_EDJ(ad->zoom_edje), "text_min", "x1");
 187         edje_object_part_text_set(_EDJ(ad->zoom_edje), "text_max", "x4");
 188
 189         /* zoom slider */
 190         slider = elm_slider_add(ad->zoom_edje);
 191         cam_retvm_if(slider == NULL, FALSE, "slider is NULL");
 192
 193         elm_object_style_set(slider, "camera");
 194         if (portrait) {
 195                 elm_slider_horizontal_set(slider, EINA_TRUE);
 196         } else {
 197                 elm_slider_horizontal_set(slider, EINA_FALSE);
 198         }
 199         if (slider_inverse) {
 200                 elm_slider_inverted_set(slider, EINA_TRUE);
 201         } else {
 202                 elm_slider_inverted_set(slider, EINA_FALSE);
 203         }
 204         elm_slider_min_max_set(slider, CAM_ZOOM_VALUE_MIN + 1, CAM_ZOOM_VALUE_MAX - 1);
 205
 206
 207         elm_slider_value_set(slider, camapp->zoom_mode);
 208
 209         int slider_value = (int)elm_slider_value_get(slider);
 210         DEBUG_TRACE("slider_value:%d / camapp->zoom_mode:%d", slider_value, camapp->zoom_mode);
 211
 212         evas_object_size_hint_align_set(slider, EVAS_HINT_FILL, EVAS_HINT_FILL);
 213         evas_object_size_hint_weight_set(slider, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 214         elm_object_part_content_set(ad->zoom_edje, "slider", slider);
 215
 216         evas_object_smart_callback_del(slider, "slider,drag,stop", __zoom_slider_stop_cb);
 217         evas_object_smart_callback_add(slider, "slider,drag,stop", __zoom_slider_stop_cb, (void*)ad);
 218         evas_object_smart_callback_del(slider, "changed", __zoom_slider_changed_cb);
 219         evas_object_smart_callback_add(slider, "changed", __zoom_slider_changed_cb, (void*)ad);
 220
 221         return TRUE;;
 222 }
 223
 224 gboolean update_zoom_edje(struct appdata *ad)
 225 {
 226         DEBUG_TRACE("START");
 227
 228         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 229         CamAppData *camapp = ad->camapp_handle;
 230         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 231
 232         cam_retvm_if(ad->zoom_edje == NULL, FALSE, "zom_edje is NULL");
 233         cam_retvm_if(slider == NULL, FALSE, "zoom slider is NULL");
 234
 235         elm_slider_value_set(slider, camapp->zoom_mode);
 236
 237         return TRUE;
 238 }
 239
 240 gboolean unload_zoom_edje(struct appdata *ad)
 241 {
 242         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 243
 244         cam_reset_focus_mode(ad);
 245
 246         DEL_EVAS_OBJECT(ad->zoom_text_min_edje);
 247         DEL_EVAS_OBJECT(ad->zoom_text_max_edje);
 248         DEL_EVAS_OBJECT(ad->zoom_edje);
 249         REMOVE_TIMER(zoom_destroy_timer);
 250
 251         return TRUE;
 252 }
 253
 254 gboolean zoom_in(struct appdata *ad, gboolean is_zoom_in, int zoom_gap)
 255 {
 256         CamAppData *camapp = NULL;
 257         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 258         camapp = ad->camapp_handle;
 259         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 260
 261         int zoom_value = 0;
 262         unsigned int capacity = 0;
 263
 264         GetCamDevFuncCaps(&capacity, ad);
 265         if (!(capacity & CAM_CP_FUNC_ZOOM)) {
 266                 DEBUG_TRACE("Zoom is not supported");
 267                 return FALSE;
 268         }
 269
 270         REMOVE_TIMER(zoom_destroy_timer);
 271
 272         __init_zoom_value(ad);
 273
 274         /* set zoom value */
 275         zoom_value = camapp->zoom_mode;
 276
 277         if (is_zoom_in) {
 278                 if (zoom_value < CAM_ZOOM_VALUE_MAX - 1)
 279                         zoom_value += zoom_gap;
 280         } else {
 281                 if (zoom_value > CAM_ZOOM_VALUE_MIN + 1)
 282                         zoom_value -= zoom_gap;
 283         }
 284         DEBUG_TRACE("zoom_value = %d", zoom_value);
 285
 286         __set_zoom_value(ad, zoom_value);
 287
 288         if (ad->zoom_edje == NULL)
 289                 load_zoom_edje(ad);
 290         else
 291                 update_zoom_edje(ad);
 292
 293         zoom_destroy_timer = ecore_timer_add(ZOOM_DESTROY_TIME, __zoom_destroy_timer_cb, ad);
 294
 295         return TRUE;
 296 }
 297
 298 void cam_zoom_create_pinch_edje(struct appdata *data)
 299 {
 300         struct appdata *ad = (struct appdata *)data;
 301         cam_retm_if(ad == NULL, "appdata is NULL");
 302
 303         if (ad->pinch_edje) {
 304                 evas_object_del(ad->pinch_edje);
 305                 ad->pinch_edje = NULL;
 306         }
 307
 308         elm_object_part_content_unset(ad->ug_base, "pinch_layout");
 309
 310         switch (ad->target_direction) {
 311         case CAM_TARGET_DIRECTION_LANDSCAPE:
 312         case CAM_TARGET_DIRECTION_LANDSCAPE_INVERSE:
 313                 ad->pinch_edje = cam_app_load_edj(ad->ug_base, CAM_ZOOM_EDJ_NAME, "pinch");
 314                 break;
 315         case CAM_TARGET_DIRECTION_PORTRAIT:
 316         case CAM_TARGET_DIRECTION_PORTRAIT_INVERSE:
 317                 ad->pinch_edje = cam_app_load_edj(ad->ug_base, CAM_ZOOM_EDJ_VERTICAL_NAME, "pinch");
 318                 break;
 319         default:
 320                 DEBUG_TRACE("error target direction!");
 321                 break;
 322         }
 323
 324         cam_retm_if(ad->pinch_edje == NULL, "pinch_edje is NULL");
 325         elm_object_part_content_set(ad->ug_base, "pinch_layout", ad->pinch_edje);
 326
 327         __set_gauge_focus(ad);
 328         __init_zoom_value(ad);
 329 }
 330
 331 static void __set_gauge_focus(struct appdata *data)
 332 {
 333         struct appdata *ad = (struct appdata *)data;
 334         CamAppData *camapp = NULL;
 335         cam_retm_if(ad == NULL, "appdata is NULL");
 336         camapp = ad->camapp_handle;
 337         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
 338
 339         DEBUG_TRACE("camapp->zoom_mode %d", camapp->zoom_mode);
 340
 341         char part_name[CAM_ZOOM_VALUE_MAX + 1][128] = {
 342                 {"set.pinch.default"},
 343                 {"set.pinch.default"},
 344                 {"set.pinch.1.1x"},
 345                 {"set.pinch.1.2x"},
 346                 {"set.pinch.1.3x"},
 347                 {"set.pinch.1.4x"},
 348                 {"set.pinch.1.5x"},
 349                 {"set.pinch.1.6x"},
 350                 {"set.pinch.1.7x"},
 351                 {"set.pinch.1.8x"},
 352                 {"set.pinch.1.9x"},
 353                 {"set.pinch.2.0x"},
 354                 {"set.pinch.2.1x"},
 355                 {"set.pinch.2.2x"},
 356                 {"set.pinch.2.3x"},
 357                 {"set.pinch.2.4x"},
 358                 {"set.pinch.2.5x"},
 359                 {"set.pinch.2.6x"},
 360                 {"set.pinch.2.7x"},
 361                 {"set.pinch.2.8x"},
 362                 {"set.pinch.2.9x"},
 363                 {"set.pinch.3.0x"},
 364                 {"set.pinch.3.1x"},
 365                 {"set.pinch.3.2x"},
 366                 {"set.pinch.3.3x"},
 367                 {"set.pinch.3.4x"},
 368                 {"set.pinch.3.5x"},
 369                 {"set.pinch.3.6x"},
 370                 {"set.pinch.3.7x"},
 371                 {"set.pinch.3.8x"},
 372                 {"set.pinch.3.9x"},
 373                 {"set.pinch.4.0x"},
 374                 {"set.pinch.4.0x"},
 375         };
 376
 377         if ((camapp->zoom_mode >= CAM_ZOOM_VALUE_MIN)
 378                 &&(camapp->zoom_mode <= CAM_ZOOM_VALUE_MAX)) {
 379                 elm_object_signal_emit(ad->pinch_edje, part_name[camapp->zoom_mode], "prog");
 380         } else {
 381                 DEBUG_TRACE("NOTE: error zoom mode");
 382         }
 383
 384         evas_object_show(ad->pinch_edje);
 385 }
 386
 387 gboolean cam_pinch_zoom_in(struct appdata* ad,gboolean is_zoom_in,int zoom_value)
 388 {
 389         CamAppData *camapp = NULL;
 390         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 391         camapp = ad->camapp_handle;
 392         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 393
 394         unsigned int capacity = 0;
 395
 396         GetCamDevFuncCaps(&capacity, ad);
 397         if (!(capacity & CAM_CP_FUNC_ZOOM)) {
 398                 DEBUG_TRACE("Zoom is not supported");
 399                 return FALSE;
 400         }
 401
 402         if (is_zoom_in) {
 403                 if (camapp->zoom_mode < CAM_ZOOM_VALUE_MAX - 1) {
 404                         camapp->zoom_mode = camapp->zoom_mode + zoom_value;
 405                 }
 406         } else {
 407                 if (camapp->zoom_mode > CAM_ZOOM_VALUE_MIN + 1) {
 408                         camapp->zoom_mode = camapp->zoom_mode - zoom_value;
 409                 }
 410         }
 411
 412         __set_gauge_focus(ad);
 413         __set_zoom_value(ad, camapp->zoom_mode);
 414
 415         return TRUE;
 416 }
 417 //endfile
 418