src/view/view_user.c

   1 /*
   2
   3  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  * http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an AS IS BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <Elementary.h>
  19 #include <app_debug.h>
  20 #include <viewmgr.h>
  21 #include <inputmgr.h>
  22
  23 #include "defs.h"
  24 #include "view.h"
  25 #include "data_user.h"
  26 #include "datamgr.h"
  27 #include "utils.h"
  28
  29 #define MESSAGE_POPUP_CONTENT "Can not add users more than 8.<br>If you want to add another user, delete one of users"
  30
  31 enum input_handler_type {
  32         INPUT_HANDLER_TYPE_BASE,
  33         INPUT_HANDLER_TYPE_EO,
  34         INPUT_HANDLER_TYPE_BUTTON
  35 };
  36
  37 struct _priv {
  38         Evas_Object *win;
  39         Evas_Object *base;
  40         Evas_Object *scr;
  41         Evas_Object *box;
  42         Eina_List *list;
  43
  44         struct datamgr *dm;
  45         struct _bar_item *foc;
  46 };
  47
  48 struct _bar_item {
  49         Evas_Object *eo;
  50
  51         struct datamgr_item *di;
  52         struct _priv *priv;
  53 };
  54
  55 static void _focused(int id, void *data, Evas_Object *obj,
  56                 Elm_Object_Item *item)
  57 {
  58         struct _priv *priv;
  59         struct _bar_item *bi;
  60
  61         if (id != INPUT_HANDLER_TYPE_EO)
  62                 return;
  63
  64         bi = data;
  65         priv = bi->priv;
  66         priv->foc = bi;
  67
  68         elm_object_signal_emit(obj, SIG_FOCUS, SRC_PROG);
  69 }
  70
  71 static void _unfocused(int id, void *data, Evas_Object *obj,
  72                 Elm_Object_Item *item)
  73 {
  74         if (id != INPUT_HANDLER_TYPE_EO)
  75                 return;
  76
  77         elm_object_signal_emit(obj, SIG_UNFOCUS, SRC_PROG);
  78 }
  79
  80 static void _key_down(int id, void *data, Evas *e, Evas_Object *obj,
  81                 Evas_Event_Key_Down *ev);
  82
  83 static void _mouse_down(int id, void *data, Evas *e, Evas_Object *obj,
  84                 Evas_Event_Mouse_Down *ev);
  85
  86 static input_handler handler = {
  87         .focused = _focused,
  88         .unfocused = _unfocused,
  89         .key_down = _key_down,
  90         .mouse_down = _mouse_down
  91 };
  92
  93 static void _add_popup(struct _priv *priv)
  94 {
  95         Evas_Object *popup, *btn;
  96
  97         popup = utils_add_popup(priv->base, MESSAGE_ADD_USER,
  98                         MESSAGE_POPUP_CONTENT);
  99         if (!popup) {
 100                 _ERR("failed to add popup");
 101                 return;
 102         }
 103
 104         btn = utils_add_button(popup, MESSAGE_OK, PART_POPUP_BUTTON_1);
 105         if (!btn) {
 106                 _ERR("failed to add button");
 107                 evas_object_del(popup);
 108                 return;
 109         }
 110         inputmgr_add_callback(btn, INPUT_HANDLER_TYPE_BUTTON, &handler, popup);
 111         elm_object_focus_set(btn, EINA_TRUE);
 112 }
 113
 114 static void _key_down(int id, void *data, Evas *e, Evas_Object *obj,
 115                 Evas_Event_Key_Down *ev)
 116 {
 117         struct _priv *priv;
 118
 119         if (!data) {
 120                 _ERR("Invalid argument");
 121                 return;
 122         }
 123
 124         switch (id) {
 125         case INPUT_HANDLER_TYPE_BUTTON:
 126                 if (!strcmp(ev->keyname, KEY_ENTER) ||
 127                                 !strcmp(ev->keyname, KEY_ENTER_REMOTE) ||
 128                                 !strcmp(ev->keyname, KEY_BACK) ||
 129                                 !strcmp(ev->keyname, KEY_BACK_REMOTE)) {
 130                         inputmgr_remove_callback(obj, &handler);
 131                         evas_object_del(data);
 132                 }
 133                 break;
 134         case INPUT_HANDLER_TYPE_BASE:
 135                 priv = data;
 136                 if (!strcmp(ev->keyname, KEY_ENTER) ||
 137                                 !strcmp(ev->keyname, KEY_ENTER_REMOTE)) {
 138                         if ((priv->foc->di->action == ITEM_SELECT_ACTION_PUSH)
 139                                         && (eina_list_count(priv->list)
 140                                         >= MAX_USER_COUNT)) {
 141                                 _add_popup(priv);
 142                                 return;
 143                         }
 144
 145                         viewmgr_update_view(VIEW_USER_EDIT, UPDATE_TYPE_EDIT,
 146                                         NULL);
 147                         datamgr_select_item(priv->dm, priv->foc->di);
 148                 } else if (!strcmp(ev->keyname, KEY_BACK) ||
 149                                 !strcmp(ev->keyname, KEY_BACK_REMOTE)) {
 150                         viewmgr_pop_view();
 151                 } else if (!strcmp(ev->keyname, KEY_DOWN)) {
 152                         if (priv->foc->di->action == ITEM_SELECT_ACTION_PUSH)
 153                                 return;
 154
 155                         viewmgr_update_view(VIEW_USER_EDIT, UPDATE_TYPE_EDIT,
 156                                         priv->foc->di);
 157                         viewmgr_push_view(VIEW_USER_EDIT);
 158                 }
 159                 break;
 160         default:
 161                 return;
 162         }
 163 }
 164
 165 static void _mouse_down(int id, void *data, Evas *e, Evas_Object *obj,
 166                 Evas_Event_Mouse_Down *ev)
 167 {
 168         struct _priv *priv;
 169
 170         if (!data) {
 171                 _ERR("Invalid argument");
 172                 return;
 173         }
 174
 175         switch (id) {
 176         case INPUT_HANDLER_TYPE_BASE:
 177                 priv = data;
 178                 if ((priv->foc->di->action == ITEM_SELECT_ACTION_PUSH)
 179                                 && (eina_list_count(priv->list)
 180                                 >= MAX_USER_COUNT)) {
 181                         _add_popup(priv);
 182                         return;
 183                 }
 184
 185                 viewmgr_update_view(VIEW_USER_EDIT, UPDATE_TYPE_EDIT,
 186                                 NULL);
 187                 datamgr_select_item(priv->dm, priv->foc->di);
 188                 break;
 189         case INPUT_HANDLER_TYPE_BUTTON:
 190                 inputmgr_remove_callback(obj, &handler);
 191                 evas_object_del(data);
 192                 break;
 193         default:
 194                 return;
 195         }
 196 }
 197
 198 static Evas_Object *_create(Evas_Object *win, void *data)
 199 {
 200         struct _priv *priv;
 201         struct datamgr *dm;
 202         Evas_Object *base;
 203
 204         if (!win) {
 205                 _ERR("Invalid argument");
 206                 return NULL;
 207         }
 208
 209         priv = calloc(1, sizeof(*priv));
 210         if (!priv) {
 211                 _ERR("failed to calloc priv");
 212                 return NULL;
 213         }
 214
 215         dm = datamgr_init(datamgr_user_get_dclass(), VIEW_USER);
 216         if (!dm) {
 217                 _ERR("failed to initialize datamgr");
 218                 free(priv);
 219                 return NULL;
 220         }
 221
 222         base = utils_add_layout(win, GRP_USER, false, NULL);
 223         if (!base) {
 224                 _ERR("failed to create base");
 225                 datamgr_fini(dm);
 226                 free(priv);
 227                 return NULL;
 228         }
 229         evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
 230                         EVAS_HINT_EXPAND);
 231         elm_win_resize_object_add(win, base);
 232
 233         priv->win = win;
 234         priv->base = base;
 235         priv->dm = dm;
 236
 237         viewmgr_set_view_data(VIEW_USER, priv);
 238         viewmgr_add_view(view_user_edit_get_vclass(), dm);
 239         inputmgr_add_callback(base, INPUT_HANDLER_TYPE_BASE, &handler, priv);
 240
 241         return base;
 242 }
 243
 244 static struct _bar_item *_pack_bar_item(struct _priv *priv, Evas_Object *box,
 245                 struct datamgr_item *di)
 246 {
 247         struct _bar_item *bi;
 248         Evas_Object *eo, *ic, *focus_ic, *lbl, *focus_lbl, *bg;
 249
 250         bi = calloc(1, sizeof(*bi));
 251         if (!bi) {
 252                 _ERR("failed to calloc bar item");
 253                 return NULL;
 254         }
 255
 256         if (di->title) {
 257                 eo = utils_add_layout(box, GRP_USER_ITEM, true, NULL);
 258                 if (!eo) {
 259                         _ERR("failed to add layout");
 260                         free(bi);
 261                         return NULL;
 262                 }
 263                 lbl = utils_add_label(eo, di->title, STYLE_LABEL_TITLE,
 264                                 PART_BAR_ITEM_TITLE);
 265                 if (!lbl)
 266                         goto err;
 267
 268                 focus_lbl = utils_add_label(eo, di->title,
 269                                 STYLE_LABEL_TITLE_FOCUS,
 270                                 PART_BAR_ITEM_TITLE_FOCUS);
 271                 if (!focus_lbl)
 272                         goto err;
 273         } else {
 274                 eo = utils_add_layout(box, GRP_BAR_ITEM, true, NULL);
 275                 if (!eo) {
 276                         _ERR("failed to add layout");
 277                         free(bi);
 278                         return NULL;
 279                 }
 280         }
 281
 282         ic = utils_add_icon(eo, di->icon, PART_BAR_ITEM_ICON);
 283         if (!ic)
 284                 goto err;
 285
 286         focus_ic = utils_add_icon(eo, di->focus_icon,
 287                         PART_BAR_ITEM_ICON_FOCUS);
 288         if (!focus_ic)
 289                 goto err;
 290
 291         if (!strcmp(di->icon, di->focus_icon))
 292                 elm_object_signal_emit(eo, SIG_SHOW_MASK, SRC_PROG);
 293
 294         bg = utils_add_bg(eo, COLOR_DEFAULT_R, COLOR_DEFAULT_G, COLOR_DEFAULT_B,
 295                         COLOR_DEFAULT_A, PART_BAR_ITEM_BG);
 296         if (!bg)
 297                 goto err;
 298
 299         inputmgr_add_callback(eo, INPUT_HANDLER_TYPE_EO, &handler, bi);
 300         elm_box_pack_end(box, eo);
 301         evas_object_show(eo);
 302
 303         bi->priv = priv;
 304         bi->eo = eo;
 305         bi->di = di;
 306
 307         return bi;
 308 err:
 309         _ERR("failed to add home item");
 310         evas_object_del(eo);
 311         free(bi);
 312
 313         return NULL;
 314 }
 315
 316 static void _add_user(struct _priv *priv)
 317 {
 318         Eina_List *list, *l;
 319         Evas_Object *scr, *box;
 320         struct _bar_item *bi;
 321         struct datamgr_item *di;
 322
 323         scr = utils_add_scroller(priv->base);
 324         if (!scr) {
 325                 _ERR("failed to add scroller");
 326                 return;
 327         }
 328
 329         box = utils_add_box(scr, true);
 330         if (!box) {
 331                 _ERR("failed to add box");
 332                 evas_object_del(scr);
 333                 return;
 334         }
 335         elm_object_content_set(scr, box);
 336         elm_object_part_content_set(priv->base, PART_USER_BAR, scr);
 337         evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND,
 338                         EVAS_HINT_EXPAND);
 339
 340         list = datamgr_get_items(priv->dm);
 341         if (!list) {
 342                 _ERR("failed to load list");
 343                 evas_object_del(scr);
 344                 return;
 345         }
 346
 347         EINA_LIST_FOREACH(list, l, di) {
 348                 bi = _pack_bar_item(priv, box, di);
 349                 if (!bi)
 350                         continue;
 351
 352                 priv->list = eina_list_append(priv->list, bi);
 353         }
 354
 355         priv->scr = scr;
 356         priv->box = box;
 357 }
 358
 359 static void _show(void *data)
 360 {
 361         struct _priv *priv;
 362
 363         if (!data) {
 364                 _ERR("Invalid argument");
 365                 return;
 366         }
 367
 368         priv = data;
 369
 370         evas_object_show(priv->base);
 371
 372         _add_user(priv);
 373
 374         if (!priv->foc)
 375                 priv->foc = eina_list_data_get(priv->list);
 376
 377         elm_object_focus_set(priv->foc->eo, EINA_TRUE);
 378 }
 379
 380 static void _unload_user(struct _priv *priv)
 381 {
 382         struct _bar_item *bi;
 383
 384         EINA_LIST_FREE(priv->list, bi) {
 385                 inputmgr_remove_callback(bi->eo, &handler);
 386                 evas_object_del(bi->eo);
 387                 free(bi);
 388         }
 389
 390         elm_box_clear(priv->box);
 391         evas_object_del(priv->scr);
 392         priv->box = NULL;
 393         priv->scr = NULL;
 394         priv->list = NULL;
 395         priv->foc = NULL;
 396 }
 397
 398 static void _hide(void *data)
 399 {
 400         struct _priv *priv;
 401
 402         if (!data) {
 403                 _ERR("Invalid argument");
 404                 return;
 405         }
 406
 407         priv = data;
 408
 409         _unload_user(priv);
 410
 411         evas_object_hide(priv->base);
 412 }
 413
 414 static void _destroy(void *data)
 415 {
 416         struct _priv *priv;
 417
 418         if (!data) {
 419                 _ERR("Invalid argument");
 420                 return;
 421         }
 422
 423         priv = data;
 424
 425         _unload_user(priv);
 426
 427         viewmgr_remove_view(VIEW_USER_EDIT);
 428         datamgr_fini(priv->dm);
 429         inputmgr_remove_callback(priv->base, &handler);
 430         evas_object_del(priv->base);
 431         free(priv);
 432 }
 433
 434 static view_class vclass = {
 435         .view_id = VIEW_USER,
 436         .create = _create,
 437         .show = _show,
 438         .hide = _hide,
 439         .destroy = _destroy
 440 };
 441
 442 view_class *view_user_get_vclass(void)
 443 {
 444         return &vclass;
 445 }
 446