src/view/view_user_edit.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 "datamgr.h"
  26 #include "utils.h"
  27
  28 #define MESSAGE_DELETE_CONTENTS "If you delete this user, their data will also be deleted."
  29 #define MESSAGE_DISCARD_CONTENTS "Discard all entered data?<br>If you are out of this screen, data won't be saved"
  30
  31 #define MESSAGE_ENTRY_NAME "User Name"
  32 #define MESSAGE_ENTRY_PIN "Pin code"
  33 #define KEY_ICON "icon"
  34 #define KEY_FOCUS_ICON "focusicon"
  35
  36 #define CTXPOPUP_X 294
  37 #define CTXPOPUP_Y 310
  38 #define MAX_BUF 128
  39
  40 enum input_handler_type {
  41         INPUT_HANDLER_TYPE_PHOTO,
  42         INPUT_HANDLER_TYPE_LOCK,
  43         INPUT_HANDLER_TYPE_DELETE,
  44         INPUT_HANDLER_TYPE_EO,
  45         INPUT_HANDLER_TYPE_BTN_DONE,
  46         INPUT_HANDLER_TYPE_BTN_CANCEL,
  47         INPUT_HANDLER_TYPE_POPUP_BTN_DISCARD,
  48         INPUT_HANDLER_TYPE_POPUP_BTN_CANCEL,
  49         INPUT_HANDLER_TYPE_DELETE_POPUP_BTN_DELETE,
  50         INPUT_HANDLER_TYPE_DELETE_POPUP_BTN_CANCEL
  51 };
  52
  53 enum user_item_type {
  54         USER_ITEM_NONE = 0x00,
  55         USER_ITEM_ADD = 0x01,
  56         USER_ITEM_ADMIN = 0x02,
  57         USER_ITEM_NORMAL = 0x08
  58 };
  59
  60 struct _icon_info {
  61         const char *file;
  62         const char *focus_file;
  63         const char *message;
  64         const char *focus_message;
  65 };
  66
  67 struct _priv {
  68         Evas_Object *win;
  69         Evas_Object *base;
  70         Evas_Object *ly;
  71         Evas_Object *photo;
  72         Evas_Object *name;
  73         Evas_Object *pin;
  74         Evas_Object *lock;
  75         Evas_Object *icon;
  76         Evas_Object *focus_icon;
  77         Evas_Object *done;
  78         Evas_Object *cancel;
  79         Evas_Object *ctxpopup;
  80         Evas_Object *del;
  81         Evas_Object *popup;
  82         Evas_Object *lock_icon;
  83
  84         char *selected_photo;
  85
  86         struct datamgr *dm;
  87         struct datamgr_item *di;
  88 };
  89
  90 static void _focused(int id, void *data, Evas_Object *obj,
  91                 Elm_Object_Item *item)
  92 {
  93         switch (id) {
  94         case INPUT_HANDLER_TYPE_PHOTO:
  95         case INPUT_HANDLER_TYPE_LOCK:
  96         case INPUT_HANDLER_TYPE_DELETE:
  97         case INPUT_HANDLER_TYPE_EO:
  98                 elm_object_signal_emit(obj, SIG_FOCUS, SRC_PROG);
  99                 break;
 100         default:
 101                  return;
 102         }
 103 }
 104
 105 static void _unfocused(int id, void *data, Evas_Object *obj,
 106                 Elm_Object_Item *item)
 107 {
 108         switch (id) {
 109         case INPUT_HANDLER_TYPE_PHOTO:
 110         case INPUT_HANDLER_TYPE_LOCK:
 111         case INPUT_HANDLER_TYPE_DELETE:
 112         case INPUT_HANDLER_TYPE_EO:
 113                 elm_object_signal_emit(obj, SIG_UNFOCUS, SRC_PROG);
 114                 break;
 115         default:
 116                 return;
 117         }
 118 }
 119
 120 static void _key_down(int id, void *data, Evas *e, Evas_Object *obj,
 121                 Evas_Event_Key_Down *ev);
 122
 123 static void _mouse_down(int id, void *data, Evas *e, Evas_Object *obj,
 124                 Evas_Event_Mouse_Down *ev);
 125
 126 static input_handler handler = {
 127         .focused = _focused,
 128         .unfocused = _unfocused,
 129         .key_down = _key_down,
 130         .mouse_down = _mouse_down
 131 };
 132
 133 static void _get_profile(struct _priv *priv, const char **name,
 134                 const char **photo, const char **pin)
 135 {
 136         *name = elm_entry_entry_get(priv->name);
 137         *pin = elm_entry_entry_get(priv->pin);
 138         elm_image_file_get(priv->icon, photo, NULL);
 139         *photo = utils_get_icon_from_photo(*photo);
 140 }
 141
 142 static void _delete_popup(struct _priv *priv, Evas_Object *obj)
 143 {
 144         inputmgr_remove_callback(obj, &handler);
 145         evas_object_del(priv->popup);
 146         priv->popup = NULL;
 147 }
 148
 149 static void _add_discard_popup(struct _priv *priv)
 150 {
 151         Evas_Object *popup, *discard_btn, *cancel_btn;
 152
 153         popup = utils_add_popup(priv->base, MESSAGE_DISCARD,
 154                         MESSAGE_DISCARD_CONTENTS);
 155         if (!popup) {
 156                 _ERR("failed to add popup");
 157                 return;
 158         }
 159         priv->popup = popup;
 160
 161         discard_btn = utils_add_button(popup, MESSAGE_DISCARD,
 162                         PART_POPUP_BUTTON_1);
 163         if (!discard_btn) {
 164                 _ERR("failed to add delete btn");
 165                 evas_object_del(popup);
 166                 return;
 167         }
 168         inputmgr_add_callback(discard_btn, INPUT_HANDLER_TYPE_POPUP_BTN_DISCARD,
 169                         &handler, priv);
 170
 171         cancel_btn = utils_add_button(popup, MESSAGE_CANCEL,
 172                         PART_POPUP_BUTTON_2);
 173         if (!cancel_btn) {
 174                 _ERR("failed to add cancel btn");
 175                 evas_object_del(popup);
 176                 return;
 177         }
 178         inputmgr_add_callback(cancel_btn, INPUT_HANDLER_TYPE_POPUP_BTN_CANCEL,
 179                         &handler, priv);
 180         elm_object_focus_set(cancel_btn, EINA_TRUE);
 181 }
 182
 183 static bool _check_changed_input(struct _priv *priv)
 184 {
 185         const char *photo, *name, *pin;
 186
 187         _get_profile(priv, &name, &photo, &pin);
 188
 189         if (priv->di) {
 190                 if (!strcmp(name, priv->di->title) && !strcmp(pin, "") &&
 191                                 !strcmp(photo, priv->di->icon))
 192                         return false;
 193         } else {
 194                 if (!strcmp(name, MESSAGE_ENTRY_NAME) &&
 195                                 !strcmp(pin, MESSAGE_ENTRY_PIN) &&
 196                                 !strcmp(photo, IMAGE_USER_DEFAULT))
 197                         return false;
 198         }
 199
 200         return true;
 201 }
 202
 203 static bool _add_btns(struct _priv *priv)
 204 {
 205         Evas_Object *done, *cancel;
 206
 207         done = utils_add_button(priv->base, MESSAGE_DONE,
 208                         PART_USER_EDIT_BTN_DONE);
 209         if (!done) {
 210                 _ERR("failed to add done btn");
 211                 return false;
 212         }
 213         inputmgr_add_callback(done, INPUT_HANDLER_TYPE_BTN_DONE, &handler,
 214                         priv);
 215
 216         cancel = utils_add_button(priv->base, MESSAGE_CANCEL,
 217                         PART_USER_EDIT_BTN_CANCEL);
 218         if (!cancel) {
 219                 _ERR("failed to add cancel btn");
 220                 evas_object_del(done);
 221                 return false;
 222         }
 223         inputmgr_add_callback(cancel, INPUT_HANDLER_TYPE_BTN_CANCEL, &handler,
 224                         priv);
 225
 226         priv->cancel = cancel;
 227         priv->done = done;
 228
 229         return true;
 230 }
 231
 232 static void _load_user_icon(struct _priv *priv, const char *file,
 233                 const char *focus_file)
 234 {
 235         Evas_Object *icon, *focus_icon;
 236
 237         icon = utils_add_icon(priv->photo, file, PART_USER_EDIT_PHOTO);
 238         if (!icon)
 239                 _ERR("failed to add icon");
 240         elm_image_fill_outside_set(icon, EINA_TRUE);
 241
 242         focus_icon = utils_add_icon(priv->photo, focus_file,
 243                         PART_USER_EDIT_PHOTO_FOCUS);
 244         if (!focus_icon)
 245                 _ERR("failed to add focus icon");
 246         elm_image_fill_outside_set(focus_icon, EINA_TRUE);
 247
 248         priv->icon = icon;
 249         priv->focus_icon = focus_icon;
 250 }
 251
 252 static Evas_Object *_pack_icon(Evas_Object *table, struct icon_info *_icon_info,
 253                 int i)
 254 {
 255         Evas_Object *eo, *ic, *focus_ic;
 256
 257         eo = utils_add_layout(table, GRP_USER_EDIT_ICON_LIST_ITEM, true, NULL);
 258         if (!eo) {
 259                 _ERR("failed to add layout");
 260                 return NULL;
 261         }
 262         evas_object_show(eo);
 263         elm_table_pack(table, eo, i % 4, i / 4, 1, 1);
 264
 265         ic = utils_add_icon(eo, _icon_info->icon_file,
 266                         PART_USER_EDIT_ICON_LIST_ITEM);
 267         if (!ic) {
 268                 _ERR("failed to add icon");
 269                 evas_object_del(eo);
 270                 return NULL;
 271         }
 272
 273         focus_ic = utils_add_icon(eo, _icon_info->focus_icon_file,
 274                         PART_USER_EDIT_ICON_LIST_ITEM_FOCUS);
 275         if (!focus_ic) {
 276                 _ERR("failed to add focus icon");
 277                 evas_object_del(eo);
 278                 return NULL;
 279         }
 280         evas_object_data_set(eo, KEY_ICON, _icon_info->photo_file);
 281
 282         return eo;
 283 }
 284
 285 static void _add_icon_list(struct _priv *priv)
 286 {
 287         Evas_Coord x, y, w, h;
 288         Evas_Object *ctxpopup, *ly, *table, *eo;
 289         int i;
 290         struct icon_info *_icon_info;
 291
 292         ctxpopup = elm_ctxpopup_add(priv->base);
 293         if (!ctxpopup) {
 294                 _ERR("failed to add ctxpopup");
 295                 return;
 296         }
 297         elm_ctxpopup_horizontal_set(ctxpopup, EINA_TRUE);
 298         elm_ctxpopup_auto_hide_disabled_set(ctxpopup, EINA_TRUE);
 299
 300         ly = utils_add_layout(ctxpopup, GRP_USER_EDIT_ICON_LIST, false, NULL);
 301         if (!ly) {
 302                 _ERR("failed to layout");
 303                 evas_object_del(ctxpopup);
 304                 return;
 305         }
 306         elm_object_content_set(ctxpopup, ly);
 307         evas_object_show(ly);
 308         evas_object_show(ctxpopup);
 309
 310         evas_object_geometry_get(priv->photo, &x, &y, &w, &h);
 311         evas_object_move(ctxpopup,
 312                         (x + w + CTXPOPUP_X) * elm_config_scale_get(),
 313                         (y + CTXPOPUP_Y) * elm_config_scale_get());
 314
 315         table = utils_add_table(ly, true, PART_USER_EDIT_ICON_LIST);
 316         if (!table) {
 317                 _ERR("failed to add table");
 318                 evas_object_del(ctxpopup);
 319                 return;
 320         }
 321         elm_table_padding_set(table, elm_config_scale_get() * 1,
 322                         elm_config_scale_get() * 1);
 323         evas_object_size_hint_weight_set(table, EVAS_HINT_EXPAND,
 324                         EVAS_HINT_EXPAND);
 325
 326         _icon_info = utils_get_icon_info();
 327
 328         for (i = 0; i < MAX_ITEM_COUNT; i++) {
 329                 eo = _pack_icon(table, &_icon_info[i], i);
 330                 if (!eo)
 331                         continue;
 332
 333                 inputmgr_add_callback(eo, INPUT_HANDLER_TYPE_EO, &handler,
 334                                 priv);
 335                 if (i == 0)
 336                         elm_object_focus_set(eo, EINA_TRUE);
 337         }
 338
 339         priv->ctxpopup = ctxpopup;
 340 }
 341
 342 static void _change_entry_status(Evas_Object *pin, Eina_Bool disable,
 343                 const char *signal)
 344 {
 345         Evas_Object *parent;
 346
 347         elm_entry_editable_set(pin, disable);
 348         parent = elm_object_parent_widget_get(pin);
 349         if (parent)
 350                 elm_object_signal_emit(parent, signal, SRC_PROG);
 351
 352         elm_object_focus_allow_set(pin, disable);
 353 }
 354
 355 static void _load_lock_icon(struct _priv *priv)
 356 {
 357         const char *file = NULL;
 358
 359         if (!priv->lock_icon) {
 360                 priv->lock_icon = utils_add_icon(priv->lock, IMAGE_SWITCH_ON,
 361                                 PART_USER_EDIT_SWITCH);
 362                 _change_entry_status(priv->pin, EINA_TRUE, SIG_UNFOCUS);
 363                 return;
 364         }
 365
 366         elm_image_file_get(priv->lock_icon, &file, NULL);
 367         elm_object_part_content_unset(priv->lock, PART_USER_EDIT_SWITCH);
 368         evas_object_del(priv->lock_icon);
 369
 370         if (!file || !strcmp(file, IMAGE_SWITCH_OFF)) {
 371                 file = IMAGE_SWITCH_ON;
 372                 _change_entry_status(priv->pin, EINA_TRUE, SIG_UNFOCUS);
 373                 elm_entry_entry_set(priv->pin, MESSAGE_ENTRY_PIN);
 374         } else {
 375                 file = IMAGE_SWITCH_OFF;
 376                 _change_entry_status(priv->pin, EINA_FALSE, SIG_DISABLE);
 377                 elm_entry_entry_set(priv->pin, "");
 378         }
 379
 380         priv->lock_icon = utils_add_icon(priv->lock, file,
 381                         PART_USER_EDIT_SWITCH);
 382 }
 383
 384 static Evas_Object *_add_layout(struct _priv *priv)
 385 {
 386         Evas_Object *ly, *photo, *name, *pin, *lock;
 387
 388         ly = utils_add_layout(priv->base, GRP_USER_EDIT_CONTENTS, false,
 389                         PART_USER_EDIT_CONTENTS);
 390         if (!ly) {
 391                 _ERR("failed to add layout");
 392                 return NULL;
 393         }
 394
 395         photo = utils_add_layout(ly, GRP_USER_EDIT_PHOTO, true,
 396                         PART_USER_EDIT_CONTENTS_PHOTO);
 397         if (!photo)
 398                 goto err;
 399
 400         name = utils_add_entry(ly, MESSAGE_ENTRY_NAME, false,
 401                         PART_USER_EDIT_CONTENTS_NAME);
 402         if (!name)
 403                 goto err;
 404
 405         pin = utils_add_entry(ly, MESSAGE_ENTRY_PIN, false,
 406                         PART_USER_EDIT_CONTENTS_PIN);
 407         if (!pin)
 408                 goto err;
 409
 410         lock = utils_add_layout(ly, GRP_USER_EDIT_SWITCH, true,
 411                         PART_USER_EDIT_CONTENTS_LOCK);
 412         if (!lock)
 413                 goto err;
 414
 415         inputmgr_add_callback(lock, INPUT_HANDLER_TYPE_LOCK, &handler, priv);
 416         inputmgr_add_callback(photo, INPUT_HANDLER_TYPE_PHOTO, &handler, priv);
 417
 418         priv->lock = lock;
 419         priv->photo = photo;
 420         priv->name = name;
 421         priv->pin = pin;
 422
 423         return ly;
 424 err:
 425         _ERR("failed to add layout");
 426         evas_object_del(ly);
 427         return NULL;
 428 }
 429
 430 static bool _add_user_edit(struct _priv *priv)
 431 {
 432         Evas_Object *ly;
 433
 434         ly = _add_layout(priv);
 435         if (!ly) {
 436                 _ERR("failed to add edit layout");
 437                 return false;
 438         }
 439
 440         if (!_add_btns(priv)) {
 441                 _ERR("failed to add buttons");
 442                 evas_object_del(ly);
 443                 return false;
 444         }
 445
 446         /* It should be implemented later about function btn */
 447
 448         priv->ly = ly;
 449
 450         return true;
 451 }
 452
 453 static Evas_Object *_create(Evas_Object *win, void *data)
 454 {
 455         struct _priv *priv;
 456         Evas_Object *base;
 457
 458         if (!win || !data) {
 459                 _ERR("Invalid argument");
 460                 return NULL;
 461         }
 462
 463         priv = calloc(1, sizeof(*priv));
 464         if (!priv) {
 465                 _ERR("failed to calloc priv");
 466                 return NULL;
 467         }
 468
 469         base = utils_add_layout(win, GRP_USER_EDIT, false, NULL);
 470         if (!base) {
 471                 _ERR("failed to create base");
 472                 free(priv);
 473                 return NULL;
 474         }
 475         evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
 476                         EVAS_HINT_EXPAND);
 477         elm_win_resize_object_add(win, base);
 478
 479         priv->win = win;
 480         priv->base = base;
 481         priv->dm = data;
 482
 483         if (!_add_user_edit(priv)) {
 484                 _ERR("failed to add user edit layout");
 485                 evas_object_del(base);
 486                 free(priv);
 487                 return NULL;
 488         }
 489
 490         viewmgr_set_view_data(VIEW_USER_EDIT, priv);
 491         viewmgr_add_view(view_photo_get_vclass(), NULL);
 492
 493         return base;
 494 }
 495
 496 static void _add_delete_popup(struct _priv *priv)
 497 {
 498         Evas_Object *popup, *delete_btn, *cancel_btn;
 499         char buf[MAX_BUF];
 500
 501         snprintf(buf, sizeof(buf), "%s %s?<br> %s", MESSAGE_DELETE,
 502                         priv->di->title, MESSAGE_DELETE_CONTENTS);
 503
 504         popup = utils_add_popup(priv->base, MESSAGE_DELETE_USER, buf);
 505         if (!popup) {
 506                 _ERR("failed to add popup");
 507                 return;
 508         }
 509         priv->popup = popup;
 510
 511         delete_btn = utils_add_button(popup, MESSAGE_DELETE,
 512                         PART_POPUP_BUTTON_1);
 513         if (!delete_btn) {
 514                 _ERR("failed to add delete btn");
 515                 evas_object_del(popup);
 516                 return;
 517         }
 518         inputmgr_add_callback(delete_btn,
 519                         INPUT_HANDLER_TYPE_DELETE_POPUP_BTN_DELETE,
 520                         &handler, priv);
 521
 522         cancel_btn = utils_add_button(popup, MESSAGE_CANCEL,
 523                         PART_POPUP_BUTTON_2);
 524         if (!cancel_btn) {
 525                 _ERR("failed to add cancel btn");
 526                 evas_object_del(popup);
 527                 return;
 528         }
 529         inputmgr_add_callback(cancel_btn,
 530                         INPUT_HANDLER_TYPE_DELETE_POPUP_BTN_CANCEL,
 531                         &handler, priv);
 532         elm_object_focus_set(cancel_btn, EINA_TRUE);
 533 }
 534
 535 static void _select_eo(struct _priv *priv, Evas_Object *obj)
 536 {
 537         const char *file, *focus_file;
 538
 539         evas_object_del(priv->ctxpopup);
 540         priv->ctxpopup = NULL;
 541
 542         file = evas_object_data_get(obj, KEY_ICON);
 543         focus_file = utils_get_focus_photo_from_photo(file);
 544
 545         if (!strcmp(file, ICON_ADD) || !strcmp(focus_file, ICON_ADD))
 546                 viewmgr_push_view(VIEW_PHOTO);
 547         else
 548                 _load_user_icon(priv, file, focus_file);
 549 }
 550
 551 static void _select_btn_done(struct _priv *priv)
 552 {
 553         const char *name, *pin, *photo;
 554
 555         _get_profile(priv, &name, &photo, &pin);
 556         if (priv->di) {
 557                 priv->di->action = ITEM_SELECT_ACTION_UPDATE;
 558                 priv->di->title = strdup(name ? name : "");
 559                 priv->di->icon = strdup(photo ? photo :
 560                                 IMAGE_USER_DEFAULT);
 561                 priv->di->parameter = strdup(pin ? pin : "");
 562                 datamgr_select_item(priv->dm, priv->di);
 563         } else
 564                 datamgr_add_item(priv->dm, name, photo, pin);
 565
 566         priv->di = NULL;
 567         viewmgr_pop_view();
 568 }
 569
 570 static void _select(struct _priv *priv, int id, Evas_Object *obj)
 571 {
 572         switch (id) {
 573         case INPUT_HANDLER_TYPE_PHOTO:
 574                 _add_icon_list(priv);
 575                 break;
 576         case INPUT_HANDLER_TYPE_LOCK:
 577                 _load_lock_icon(priv);
 578                 break;
 579         case INPUT_HANDLER_TYPE_DELETE:
 580                 _add_delete_popup(priv);
 581                 break;
 582         case INPUT_HANDLER_TYPE_EO:
 583                 _select_eo(priv, obj);
 584                 break;
 585         case INPUT_HANDLER_TYPE_BTN_DONE:
 586                 _select_btn_done(priv);
 587                 break;
 588         case INPUT_HANDLER_TYPE_BTN_CANCEL:
 589                 if (_check_changed_input(priv)) {
 590                         _add_discard_popup(priv);
 591                         return;
 592                 }
 593                 viewmgr_pop_view();
 594                 break;
 595         case INPUT_HANDLER_TYPE_DELETE_POPUP_BTN_DELETE:
 596                 _delete_popup(priv, obj);
 597                 priv->di->action = ITEM_SELECT_ACTION_DELETE;
 598                 datamgr_select_item(priv->dm, priv->di);
 599                 viewmgr_pop_view();
 600                 break;
 601         case INPUT_HANDLER_TYPE_POPUP_BTN_DISCARD:
 602                 _delete_popup(priv, obj);
 603                 viewmgr_pop_view();
 604                 break;
 605         case INPUT_HANDLER_TYPE_DELETE_POPUP_BTN_CANCEL:
 606         case INPUT_HANDLER_TYPE_POPUP_BTN_CANCEL:
 607                 _delete_popup(priv, obj);
 608                 break;
 609         default:
 610                 return;
 611         }
 612 }
 613
 614 static void _key_down(int id, void *data, Evas *e, Evas_Object *obj,
 615                 Evas_Event_Key_Down *ev)
 616 {
 617         struct _priv *priv;
 618
 619         if (!data) {
 620                 _ERR("Invalid argument");
 621                 return;
 622         }
 623
 624         priv = data;
 625         if (!strcmp(ev->keyname, KEY_BACK) ||
 626                         !strcmp(ev->keyname, KEY_BACK_REMOTE)) {
 627                 switch (id) {
 628                 case INPUT_HANDLER_TYPE_EO:
 629                         evas_object_del(priv->ctxpopup);
 630                         priv->ctxpopup = NULL;
 631                         break;
 632                 case INPUT_HANDLER_TYPE_DELETE_POPUP_BTN_DELETE:
 633                         _delete_popup(priv, obj);
 634                         break;
 635                 case INPUT_HANDLER_TYPE_POPUP_BTN_DISCARD:
 636                         _delete_popup(priv, obj);
 637                         break;
 638                 case INPUT_HANDLER_TYPE_DELETE_POPUP_BTN_CANCEL:
 639                 case INPUT_HANDLER_TYPE_POPUP_BTN_CANCEL:
 640                         _delete_popup(priv, obj);
 641                         break;
 642                 default:
 643                         return;
 644                 }
 645         } else if(!strcmp(ev->keyname, KEY_ENTER) ||
 646                         !strcmp(ev->keyname, KEY_ENTER_REMOTE))
 647                 _select(priv, id, obj);
 648 }
 649
 650 static void _mouse_down(int id, void *data, Evas *e, Evas_Object *obj,
 651                 Evas_Event_Mouse_Down *ev)
 652 {
 653         struct _priv *priv;
 654
 655         if (!data) {
 656                 _ERR("Invalid argument");
 657                 return;
 658         }
 659
 660         priv = data;
 661         _select(priv, id, obj);
 662 }
 663
 664 static void _load_del_btn(struct _priv *priv)
 665 {
 666         Evas_Object *btn;
 667
 668         if (priv->di->type == USER_ITEM_ADMIN) {
 669                 btn = utils_add_layout(priv->ly, GRP_USER_EDIT_DELETE, false,
 670                                 PART_USER_EDIT_CONTENTS_DELETE);
 671                 if (!btn) {
 672                         _ERR("failed to add delete button");
 673                         return;
 674                 }
 675                 elm_object_signal_emit(btn, SIG_DISABLE, SRC_PROG);
 676                 return;
 677         }
 678
 679
 680         btn = utils_add_layout(priv->ly, GRP_USER_EDIT_DELETE, true,
 681                         PART_USER_EDIT_CONTENTS_DELETE);
 682         if (!btn) {
 683                 _ERR("failed to add delete button");
 684                 return;
 685         }
 686         inputmgr_add_callback(btn, INPUT_HANDLER_TYPE_DELETE, &handler, priv);
 687
 688         priv->del = btn;
 689 }
 690
 691 static void _show(void *data)
 692 {
 693         struct _priv *priv;
 694         const char *photo, *focus_photo;
 695
 696         if (!data) {
 697                 _ERR("Invalid argument");
 698                 return;
 699         }
 700
 701         priv = data;
 702
 703         if (priv->di) {
 704                 elm_object_part_text_set(priv->base, PART_USER_EDIT_TITLE,
 705                                 MESSAGE_EDIT_USER);
 706                 elm_entry_entry_set(priv->name, priv->di->title);
 707                 elm_entry_entry_set(priv->pin, "");
 708                 if (priv->selected_photo) {
 709                         _load_user_icon(priv, priv->selected_photo,
 710                                         priv->selected_photo);
 711                  } else {
 712                         photo = utils_get_photo_from_icon(priv->di->icon);
 713                         focus_photo = utils_get_focus_photo_from_photo(photo);
 714                         _load_user_icon(priv, photo, focus_photo);
 715                 }
 716                 _load_del_btn(priv);
 717         } else {
 718                 elm_object_part_text_set(priv->base, PART_USER_EDIT_TITLE,
 719                                 MESSAGE_ADD_USER);
 720                 elm_entry_entry_set(priv->name, MESSAGE_ENTRY_NAME);
 721                 elm_entry_entry_set(priv->pin, MESSAGE_ENTRY_PIN);
 722                 if (priv->selected_photo)
 723                         _load_user_icon(priv, priv->selected_photo,
 724                                         priv->selected_photo);
 725                 else
 726                         _load_user_icon(priv, IMAGE_USER_CURRENT_DEFAULT,
 727                                         IMAGE_USER_CURRENT_DEFAULT_FOCUS);
 728         }
 729
 730         _load_lock_icon(priv);
 731         evas_object_show(priv->base);
 732         elm_object_focus_set(priv->cancel, EINA_TRUE);
 733 }
 734
 735 static void _hide(void *data)
 736 {
 737         struct _priv *priv;
 738
 739         if (!data) {
 740                 _ERR("Invalid argument");
 741                 return;
 742         }
 743
 744         priv = data;
 745         if (priv->del) {
 746                 inputmgr_remove_callback(priv->del, &handler);
 747                 evas_object_del(priv->del);
 748                 priv->del = NULL;
 749         }
 750
 751         if (priv->lock_icon) {
 752                 evas_object_del(priv->lock_icon);
 753                 priv->lock_icon = NULL;
 754         }
 755
 756         priv->selected_photo = NULL;
 757         evas_object_hide(priv->base);
 758 }
 759
 760 static void _destroy(void *data)
 761 {
 762         struct _priv *priv;
 763
 764         if (!data) {
 765                 _ERR("Invalid argument");
 766                 return;
 767         }
 768
 769         priv = data;
 770
 771         inputmgr_remove_callback(priv->photo, &handler);
 772         inputmgr_remove_callback(priv->lock, &handler);
 773         inputmgr_remove_callback(priv->done, &handler);
 774         inputmgr_remove_callback(priv->cancel, &handler);
 775         viewmgr_remove_view(VIEW_PHOTO);
 776         evas_object_del(priv->base);
 777         free(priv);
 778 }
 779
 780 static void _update(void *view_data, int update_type, void *data)
 781 {
 782         struct _priv *priv;
 783
 784         if (!view_data) {
 785                 _ERR("Invalid argument");
 786                 return;
 787         }
 788
 789         priv = view_data;
 790
 791         switch (update_type) {
 792         case UPDATE_TYPE_EDIT:
 793                 priv->di = data;
 794                 break;
 795         case UPDATE_TYPE_PHOTO:
 796                 priv->selected_photo = data;
 797                 break;
 798         default:
 799                 _ERR("Invalid type");
 800                 return;
 801         }
 802 }
 803
 804 static view_class vclass = {
 805         .view_id = VIEW_USER_EDIT,
 806         .create = _create,
 807         .show = _show,
 808         .hide = _hide,
 809         .destroy = _destroy,
 810         .update = _update
 811 };
 812
 813 view_class *view_user_edit_get_vclass(void)
 814 {
 815         return &vclass;
 816 }