efl

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");
216