src/edje_externals/elm_photocam.c

   1 #include <assert.h>
   2 #include "private.h"
   3
   4 typedef struct _Elm_Params_Photocam
   5 {
   6    Elm_Params base;
   7    const char *file;
   8    double zoom;
   9    const char *zoom_mode;
  10    Eina_Bool paused:1;
  11    Eina_Bool paused_exists:1;
  12    Eina_Bool zoom_exists:1;
  13 } Elm_Params_Photocam;
  14
  15 static const char* choices[] = { "manual", "auto fit", "auto fill", NULL };
  16
  17 static Elm_Photocam_Zoom_Mode
  18 _zoom_mode_setting_get(const char *zoom_mode_str)
  19 {
  20    unsigned int i;
  21
  22    assert(sizeof(choices)/sizeof(choices[0]) == ELM_PHOTOCAM_ZOOM_MODE_LAST + 1);
  23
  24    for (i = 0; i < ELM_PHOTOCAM_ZOOM_MODE_LAST; i++)
  25      {
  26         if (!strcmp(zoom_mode_str, choices[i]))
  27           return i;
  28      }
  29    return ELM_PHOTOCAM_ZOOM_MODE_LAST;
  30 }
  31
  32 static void
  33 external_photocam_state_set(void *data EINA_UNUSED, Evas_Object *obj,
  34                             const void *from_params, const void *to_params,
  35                             float pos EINA_UNUSED)
  36 {
  37    const Elm_Params_Photocam *p;
  38
  39    if (to_params) p = to_params;
  40    else if (from_params) p = from_params;
  41    else return;
  42
  43    if (p->file)
  44      elm_photocam_file_set(obj, p->file);
  45    if (p->zoom_exists)
  46      elm_photocam_zoom_set(obj, p->zoom);
  47    if (p->zoom_mode)
  48      {
  49         Elm_Photocam_Zoom_Mode set = _zoom_mode_setting_get(p->zoom_mode);
  50         if (set == ELM_PHOTOCAM_ZOOM_MODE_LAST) return;
  51         elm_photocam_zoom_mode_set(obj, set);
  52      }
  53    if (p->paused_exists)
  54      elm_photocam_paused_set(obj, p->paused);
  55 }
  56
  57 static Eina_Bool
  58 external_photocam_param_set(void *data EINA_UNUSED, Evas_Object *obj,
  59                             const Edje_External_Param *param)
  60 {
  61    if (!strcmp(param->name, "file"))
  62      {
  63         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
  64           {
  65              elm_photocam_file_set(obj, param->s);
  66              return EINA_TRUE;
  67           }
  68      }
  69    else if (!strcmp(param->name, "zoom"))
  70      {
  71         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
  72           {
  73              elm_photocam_zoom_set(obj, param->d);
  74              return EINA_TRUE;
  75           }
  76      }
  77    else if (!strcmp(param->name, "zoom mode"))
  78      {
  79         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
  80           {
  81              Elm_Photocam_Zoom_Mode set = _zoom_mode_setting_get(param->s);
  82              if (set == ELM_PHOTOCAM_ZOOM_MODE_LAST) return EINA_FALSE;
  83              elm_photocam_zoom_mode_set(obj, set);
  84              return EINA_TRUE;
  85           }
  86      }
  87    else if (!strcmp(param->name, "paused"))
  88      {
  89         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
  90           {
  91              elm_photocam_paused_set(obj, param->i);
  92              return EINA_TRUE;
  93           }
  94      }
  95
  96    ERR("unknown parameter '%s' of type '%s'",
  97        param->name, edje_external_param_type_str(param->type));
  98
  99    return EINA_FALSE;
 100 }
 101
 102 static Eina_Bool
 103 external_photocam_param_get(void *data EINA_UNUSED, const Evas_Object *obj,
 104                             Edje_External_Param *param)
 105 {
 106    if (!strcmp(param->name, "file"))
 107      {
 108         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 109           {
 110              param->s = elm_photocam_file_get(obj);
 111              return EINA_TRUE;
 112           }
 113      }
 114    else if (!strcmp(param->name, "zoom"))
 115      {
 116         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
 117           {
 118              param->d = elm_photocam_zoom_get(obj);
 119              return EINA_TRUE;
 120           }
 121      }
 122    else if (!strcmp(param->name, "zoom mode"))
 123      {
 124         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 125           {
 126              Elm_Photocam_Zoom_Mode zoom_mode_set =
 127                 elm_photocam_zoom_mode_get(obj);
 128
 129              if (zoom_mode_set == ELM_PHOTOCAM_ZOOM_MODE_LAST)
 130                return EINA_FALSE;
 131
 132              param->s = choices[zoom_mode_set];
 133              return EINA_TRUE;
 134           }
 135      }
 136    else if (!strcmp(param->name, "paused"))
 137      {
 138         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 139           {
 140              param->i = elm_photocam_paused_get(obj);
 141              return EINA_TRUE;
 142           }
 143      }
 144
 145    ERR("unknown parameter '%s' of type '%s'",
 146        param->name, edje_external_param_type_str(param->type));
 147
 148    return EINA_FALSE;
 149 }
 150
 151 static void *
 152 external_photocam_params_parse(void *data EINA_UNUSED,
 153                                Evas_Object *obj EINA_UNUSED,
 154                                const Eina_List *params)
 155 {
 156    Elm_Params_Photocam *mem;
 157    Edje_External_Param *param;
 158    const Eina_List *l;
 159
 160    mem = calloc(1, sizeof(Elm_Params_Photocam));
 161    if (!mem)
 162      return NULL;
 163
 164    EINA_LIST_FOREACH(params, l, param)
 165      {
 166         if (!strcmp(param->name, "file"))
 167           mem->file = eina_stringshare_add(param->s);
 168         else if (!strcmp(param->name, "zoom"))
 169           {
 170              mem->zoom = param->d;
 171              mem->zoom_exists = EINA_TRUE;
 172           }
 173         else if (!strcmp(param->name, "zoom mode"))
 174           mem->zoom_mode = eina_stringshare_add(param->s);
 175         else if (!strcmp(param->name, "paused"))
 176           {
 177              mem->paused = !!param->i;
 178              mem->paused_exists = EINA_TRUE;
 179           }
 180      }
 181
 182    return mem;
 183 }
 184
 185 static Evas_Object *external_photocam_content_get(void *data EINA_UNUSED,
 186                                                   const Evas_Object *obj EINA_UNUSED,
 187                                                   const char *content EINA_UNUSED)
 188 {
 189    ERR("No content.");
 190    return NULL;
 191 }
 192
 193 static void
 194 external_photocam_params_free(void *params)
 195 {
 196    Elm_Params_Photocam *mem = params;
 197
 198    if (mem->file)
 199      eina_stringshare_del(mem->file);
 200    if (mem->zoom_mode)
 201      eina_stringshare_del(mem->zoom_mode);
 202    free(mem);
 203 }
 204
 205 static Edje_External_Param_Info external_photocam_params[] = {
 206      DEFINE_EXTERNAL_COMMON_PARAMS,
 207      EDJE_EXTERNAL_PARAM_INFO_STRING("file"),
 208      EDJE_EXTERNAL_PARAM_INFO_DOUBLE("zoom"),
 209      EDJE_EXTERNAL_PARAM_INFO_CHOICE_FULL("zoom mode", "manual", choices),
 210      EDJE_EXTERNAL_PARAM_INFO_BOOL("paused"),
 211      EDJE_EXTERNAL_PARAM_INFO_SENTINEL
 212 };
 213
 214 DEFINE_EXTERNAL_ICON_ADD(photocam, "photocam");
 215 DEFINE_EXTERNAL_TYPE_SIMPLE(photocam, "Photocam");