webapp-common/whitelistview.cpp

   1 /*
   2   * Copyright 2012  Samsung Electronics Co., Ltd
   3   *
   4   * Licensed under the Flora License, Version 1.0 (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 #include <Elementary.h>
  18
  19 #include <dpl/wrt-dao-ro/global_dao_read_only.h>
  20 #include <dpl/wrt-dao-rw/global_dao.h>
  21 #include <dpl/foreach.h>
  22 #include <dpl/assert.h>
  23
  24 #include "whitelistview.h"
  25 #include "whiteuriview.h"
  26 #include "icons.h"
  27 #include "util.h"
  28 #include "edc/defs.h"
  29
  30 namespace WebAppCommonSetting {
  31
  32 char *WhiteListView::getUriStr(void *data,
  33                                Evas_Object */*obj*/,
  34                                const char *part)
  35 {
  36     const char *str;
  37     UriData *uriData;
  38
  39     uriData = static_cast<UriData *>(data);
  40     if (!uriData)
  41         return NULL;
  42
  43     if (!strcmp(part, "elm.text.1"))
  44         str = uriData->m_uri.c_str();
  45     else if (!strcmp(part, "elm.text.2"))
  46         str = NULL;
  47     else
  48         str = NULL;
  49
  50     if (!str)
  51         return NULL;
  52
  53     return strdup(str);
  54 }
  55
  56 Evas_Object *WhiteListView::getUriChk(void *data,
  57                                       Evas_Object *obj,
  58                                       const char *part)
  59 {
  60     Evas_Object *chk;
  61     UriData *uriData;
  62
  63     uriData = static_cast<UriData *>(data);
  64     if (!uriData)
  65         return NULL;
  66
  67     if (!strcmp(part, "elm.edit.icon.1")) {
  68         chk = elm_check_add(obj);
  69         if (!chk)
  70             return NULL;
  71         elm_check_state_pointer_set(chk, &uriData->m_selected);
  72         evas_object_propagate_events_set(chk, EINA_FALSE);
  73         evas_object_smart_callback_add(chk,
  74                                        "changed",
  75                                        onUriChkClicked,
  76                                        data);
  77     } else {
  78         return NULL;
  79     }
  80
  81     return chk;
  82 }
  83
  84 void WhiteListView::delUriData(void *data, Evas_Object */*obj*/)
  85 {
  86     UriData *uriData;
  87
  88     uriData = static_cast<UriData*>(data);
  89     delete uriData;
  90 }
  91
  92 void WhiteListView::onBackBtnClicked(void *data,
  93                                      Evas_Object */*obj*/,
  94                                      void */*event_info*/)
  95 {
  96     WhiteListView *whitelistview;
  97
  98     whitelistview = static_cast<WhiteListView *>(data);
  99     Assert(whitelistview);
 100     whitelistview->handleBackBtn();
 101 }
 102
 103 void WhiteListView::onEditModeBtnClicked(void *data,
 104                                          Evas_Object */*obj*/,
 105                                          void */*event_info*/)
 106 {
 107     WhiteListView *whitelistview;
 108
 109     whitelistview = static_cast<WhiteListView *>(data);
 110     Assert(whitelistview);
 111     whitelistview->handleEditModeBtn();
 112 }
 113
 114 void WhiteListView::onOptBtnClicked(void *data,
 115                                     Evas_Object */*obj*/,
 116                                     void */*event_info*/)
 117 {
 118     WhiteListView *whitelistview;
 119
 120     whitelistview = static_cast<WhiteListView *>(data);
 121     Assert(whitelistview);
 122     whitelistview->handleOptBtn();
 123 }
 124
 125 void WhiteListView::onUriClicked(void *data,
 126                                  Evas_Object *obj,
 127                                  void *event_info)
 128 {
 129     UriData *uriData;
 130     Elm_Object_Item *it;
 131     WhiteListView *whiteListView;
 132
 133     uriData = static_cast<UriData *>(data);
 134     it = static_cast<Elm_Object_Item *>(event_info);
 135     Assert(it && uriData);
 136     whiteListView = uriData->m_whiteListView;
 137     Assert(whiteListView);
 138
 139     if (elm_genlist_decorate_mode_get(obj)) {
 140         uriData->m_selected = !uriData->m_selected;
 141         if (uriData->m_selected)
 142             whiteListView->increaseSelectCnt();
 143         else
 144             whiteListView->decreaseSelectCnt();
 145         elm_genlist_item_update(it);
 146     } else {
 147         whiteListView->loadWhiteUriView(&uriData->m_uri);
 148     }
 149
 150     elm_genlist_item_selected_set(it, EINA_FALSE);
 151 }
 152
 153 void WhiteListView::onUriChkClicked(void *data,
 154                                     Evas_Object */*obj*/,
 155                                     void */*event_info*/)
 156 {
 157     UriData *uriData;
 158     WhiteListView *whiteListView;
 159
 160     uriData = static_cast<UriData *>(data);
 161     Assert(uriData);
 162     whiteListView = uriData->m_whiteListView;
 163     Assert(whiteListView);
 164
 165     if (uriData->m_selected)
 166         whiteListView->increaseSelectCnt();
 167     else
 168         whiteListView->decreaseSelectCnt();
 169 }
 170
 171 void WhiteListView::onSelectAllChkClicked(void *data,
 172                                           Evas_Object *obj,
 173                                           void */*event_info*/)
 174 {
 175     WhiteListView *whiteListView;
 176
 177     whiteListView = static_cast<WhiteListView *>(data);
 178     Assert(whiteListView);
 179     whiteListView->selectAll(elm_check_state_get(obj));
 180 }
 181
 182 void WhiteListView::onSelectAllClicked(void *data,
 183                                        Evas */*e*/,
 184                                        Evas_Object *obj,
 185                                        void */*event_info*/)
 186 {
 187     WhiteListView *whiteListView;
 188     Evas_Object *chk;
 189     Eina_Bool state;
 190
 191     Assert(obj);
 192     whiteListView = static_cast<WhiteListView *>(data);
 193     Assert(whiteListView);
 194     chk = elm_object_part_content_get(obj, "elm.icon");
 195     Assert(chk);
 196     state = elm_check_state_get(chk);
 197     elm_check_state_set(chk, !state);
 198     whiteListView->selectAll(!state);
 199 }
 200
 201 void WhiteListView::onRemoveWhiteUriPopupOk(void *data,
 202                                             Evas_Object */*obj*/,
 203                                             void */*event_info*/)
 204 {
 205     WhiteListView *whiteListView;
 206
 207     whiteListView = static_cast<WhiteListView *>(data);
 208     Assert(whiteListView);
 209
 210     whiteListView->removeWhiteUri();
 211     whiteListView->hidePopup();
 212 }
 213
 214 void WhiteListView::onRemoveWhiteUriPopupCancel(void *data,
 215                                                 Evas_Object */*obj*/,
 216                                                 void */*event_info*/)
 217 {
 218     WhiteListView *whiteListView;
 219
 220     whiteListView = static_cast<WhiteListView *>(data);
 221     Assert(whiteListView);
 222
 223     whiteListView->hidePopup();
 224 }
 225
 226 void WhiteListView::onWhiteUriViewUnload(void *data)
 227 {
 228     WhiteListView *whiteListView;
 229
 230     whiteListView = static_cast<WhiteListView *>(data);
 231     Assert(whiteListView);
 232     whiteListView->delWhiteUriView();
 233     whiteListView->reloadUri();
 234 }
 235
 236 void WhiteListView::addUri(DPL::String &uri)
 237 {
 238     UriData *uriData;
 239     Elm_Object_Item *it;
 240     static Elm_Genlist_Item_Class itc;
 241
 242     Assert(m_gl);
 243     itc.item_style = "2text.6";
 244     itc.func.text_get = getUriStr;
 245     itc.func.content_get = getUriChk;
 246     itc.func.state_get = NULL;
 247     itc.func.del = delUriData;
 248     itc.decorate_all_item_style = "edit_default";
 249
 250     try {
 251         uriData = new UriData(this, DPL::ToUTF8String(uri));
 252         it = elm_genlist_item_append(m_gl,
 253                                      &itc,
 254                                      static_cast<void *>(uriData),
 255                                      NULL,
 256                                      ELM_GENLIST_ITEM_NONE,
 257                                      onUriClicked,
 258                                      static_cast<void *>(uriData));
 259         if (!it) {
 260             delete uriData;
 261             return;
 262         }
 263         m_uriCnt++;
 264     } catch (const std::bad_alloc &) {
 265     }
 266 }
 267
 268 Evas_Object *WhiteListView::addToolBar(Evas_Object *parent)
 269 {
 270     Evas_Object *toolBar;
 271
 272     toolBar = elm_toolbar_add(parent);
 273     if (!toolBar)
 274         return NULL;
 275     elm_object_style_set(toolBar, "naviframe");
 276     elm_toolbar_shrink_mode_set(toolBar, ELM_TOOLBAR_SHRINK_EXPAND);
 277     m_editModeBtn = elm_toolbar_item_append(toolBar,
 278                                             ICON_EDIT,
 279                                             NULL,
 280                                             onEditModeBtnClicked,
 281                                             this);
 282     m_optBtn = elm_toolbar_item_append(toolBar,
 283                                        ICON_ADD,
 284                                        NULL,
 285                                        onOptBtnClicked,
 286                                        this);
 287     if (!m_uriCnt) {
 288         elm_object_item_disabled_set(m_editModeBtn, EINA_TRUE);
 289         elm_object_signal_emit(getBase(), SIG_SHOW_NOCONTENT, SRC_PROG);
 290     }
 291
 292     return toolBar;
 293 }
 294
 295 bool WhiteListView::pushToNaviFrame(void)
 296 {
 297     Evas_Object *btn;
 298     Evas_Object *toolBar;
 299     Elm_Object_Item *it;
 300
 301     Assert(m_naviFrame);
 302
 303     btn = elm_button_add(m_naviFrame);
 304     if (!btn)
 305         return false;
 306
 307     toolBar = addToolBar(m_naviFrame);
 308     if (!toolBar) {
 309         evas_object_del(btn);
 310         return false;
 311     }
 312     elm_object_style_set(btn, "naviframe/end_btn/default");
 313     evas_object_smart_callback_add(btn, "clicked", onBackBtnClicked, this);
 314     it = elm_naviframe_item_push(m_naviFrame,
 315                                  "White list",
 316                                  btn,
 317                                  NULL,
 318                                  getBase(),
 319                                  NULL);
 320     if (!it) {
 321         evas_object_del(btn);
 322         evas_object_del(toolBar);
 323         return false;
 324     }
 325
 326     elm_object_item_part_content_set(it, "controlbar", toolBar);
 327
 328     return true;
 329 }
 330
 331 void WhiteListView::popFromNaviFrame(void)
 332 {
 333     Assert(m_naviFrame);
 334     elm_naviframe_item_pop(m_naviFrame);
 335 }
 336
 337 bool WhiteListView::addNoContent(Evas_Object *ly)
 338 {
 339     Evas_Object *eo;
 340
 341     Assert(ly);
 342
 343     eo = elm_layout_add(ly);
 344     if (!eo)
 345         return NULL;
 346     elm_layout_theme_set(eo, "layout", "nocontents", "full");
 347     elm_object_part_text_set(eo, "elm.text", D_("IDS_COM_BODY_NO_CONTENTS"));
 348     elm_object_part_content_set(ly, PART_NOCONTENT, eo);
 349
 350     return true;
 351 }
 352
 353 bool WhiteListView::addContents(Evas_Object *ly)
 354 {
 355     Assert(ly);
 356
 357     m_bx = elm_box_add(ly);
 358     if (!m_bx)
 359         return false;
 360
 361     m_gl = elm_genlist_add(m_bx);
 362     if (!m_gl) {
 363         evas_object_del(m_bx);
 364         m_bx = NULL;
 365         return false;
 366     }
 367     evas_object_size_hint_align_set(m_gl, EVAS_HINT_FILL, EVAS_HINT_FILL);
 368     evas_object_size_hint_weight_set(m_gl, EVAS_HINT_EXPAND, 1.0);
 369     evas_object_show(m_gl);
 370     elm_box_pack_end(m_bx, m_gl);
 371     elm_object_part_content_set(ly, PART_CONTENT, m_bx);
 372
 373     return true;
 374 }
 375
 376 bool WhiteListView::loadView(void)
 377 {
 378     Evas_Object *ly;
 379     WrtDB::WidgetAccessInfoList uriList;
 380
 381     Assert(m_naviFrame);
 382     resetBase();
 383
 384     ly = elm_layout_add(m_naviFrame);
 385     if (!ly)
 386         return false;
 387     elm_layout_file_set(ly, EDJFILE, GRP_CONTENT);
 388
 389     if (!addNoContent(ly)) {
 390         evas_object_del(ly);
 391         return false;
 392     }
 393
 394     if (!addContents(ly)) {
 395         evas_object_del(ly);
 396         return false;
 397     }
 398     resetBase(ly);
 399
 400     uriList = WrtDB::GlobalDAOReadOnly::GetWhiteURIList();
 401     FOREACH(uri, uriList)
 402         addUri(uri->strIRI);
 403
 404     if (!pushToNaviFrame()) {
 405         resetBase();
 406         return false;
 407     }
 408
 409     return true;
 410 }
 411
 412 void WhiteListView::loadWhiteUriView(std::string *uri)
 413 {
 414     Assert(m_naviFrame);
 415
 416     try {
 417         if (uri)
 418             m_whiteUriView.Reset(new WhiteUriView(m_naviFrame, *uri));
 419         else
 420             m_whiteUriView.Reset(new WhiteUriView(m_naviFrame));
 421
 422         if (!m_whiteUriView->loadView()) {
 423             m_whiteUriView.Reset();
 424             return;
 425         }
 426         m_whiteUriView->setUnloadCb(onWhiteUriViewUnload, this);
 427     } catch (const std::bad_alloc &) {
 428     }
 429 }
 430
 431 void WhiteListView::delWhiteUriView(void)
 432 {
 433     m_whiteUriView.Reset();
 434 }
 435
 436 void WhiteListView::reloadUri(void)
 437 {
 438     WrtDB::WidgetAccessInfoList uriList;
 439
 440     if (getBase() && m_gl) {
 441         elm_genlist_clear(m_gl);
 442         uriList = WrtDB::GlobalDAOReadOnly::GetWhiteURIList();
 443         m_uriCnt = 0;
 444         FOREACH(uri, uriList)
 445             addUri(uri->strIRI);
 446
 447         if (!m_uriCnt) {
 448             elm_object_item_disabled_set(m_editModeBtn, EINA_TRUE);
 449             elm_object_signal_emit(getBase(), SIG_SHOW_NOCONTENT, SRC_PROG);
 450         } else {
 451             elm_object_item_disabled_set(m_editModeBtn, EINA_FALSE);
 452             elm_object_signal_emit(getBase(), SIG_SHOW_CONTENT, SRC_PROG);
 453         }
 454     }
 455 }
 456
 457 void WhiteListView::handleEditModeBtn(void)
 458 {
 459     Evas_Object *chk;
 460
 461     Assert(m_editModeBtn && m_optBtn);
 462     Assert(m_bx);
 463
 464     if (!elm_genlist_decorate_mode_get(m_gl)) {
 465         m_selectAll = elm_layout_add(m_gl);
 466         if (!m_selectAll)
 467             return;
 468         elm_layout_theme_set(m_selectAll,
 469                              "genlist",
 470                              "item",
 471                              "select_all/default");
 472         chk = elm_check_add(m_gl);
 473         if (!chk) {
 474             evas_object_del(m_selectAll);
 475             m_selectAll = NULL;
 476             return;
 477         }
 478         evas_object_propagate_events_set(chk, EINA_FALSE);
 479         evas_object_smart_callback_add(chk,
 480                                        "changed",
 481                                        onSelectAllChkClicked,
 482                                        this);
 483         evas_object_event_callback_add(m_selectAll,
 484                                        EVAS_CALLBACK_MOUSE_DOWN,
 485                                        onSelectAllClicked,
 486                                        this);
 487         elm_object_part_content_set(m_selectAll, "elm.icon", chk);
 488         elm_object_part_text_set(m_selectAll, "elm.text", "Select all");
 489         evas_object_size_hint_align_set(m_selectAll,
 490                                         EVAS_HINT_FILL,
 491                                         0.0);
 492         evas_object_show(m_selectAll);
 493         elm_box_pack_start(m_bx, m_selectAll);
 494         elm_object_item_disabled_set(m_editModeBtn, EINA_TRUE);
 495         elm_toolbar_item_icon_file_set(m_optBtn, ICON_DELETE, NULL);
 496         elm_object_item_disabled_set(m_optBtn, EINA_TRUE);
 497         elm_genlist_decorate_mode_set(m_gl, EINA_TRUE);
 498     }
 499 }
 500
 501 void WhiteListView::handleOptBtn(void)
 502 {
 503     Assert(m_gl);
 504     if (elm_genlist_decorate_mode_get(m_gl)) {
 505         showPopup("Do you really want to remove selected white URL?",
 506                   onRemoveWhiteUriPopupOk,
 507                   onRemoveWhiteUriPopupCancel,
 508                   this);
 509     } else {
 510         loadWhiteUriView();
 511     }
 512 }
 513
 514 void WhiteListView::handleBackBtn(void)
 515 {
 516     if (!elm_genlist_decorate_mode_get(m_gl)) {
 517         popFromNaviFrame();
 518     } else {
 519         selectAll(EINA_FALSE);
 520         Assert(m_bx);
 521         elm_box_unpack(m_bx, m_selectAll);
 522         evas_object_del(m_selectAll);
 523         m_selectAll = NULL;
 524         m_selectCnt = 0;
 525         Assert(m_editModeBtn && m_optBtn);
 526         if (!m_uriCnt) {
 527            elm_object_item_disabled_set(m_editModeBtn, EINA_TRUE);
 528            elm_object_signal_emit(getBase(), SIG_SHOW_NOCONTENT, SRC_PROG);
 529         } else {
 530            elm_object_item_disabled_set(m_editModeBtn, EINA_FALSE);
 531            elm_object_signal_emit(getBase(), SIG_SHOW_CONTENT, SRC_PROG);
 532         }
 533         elm_toolbar_item_icon_file_set(m_optBtn, ICON_ADD, NULL);
 534         elm_object_item_disabled_set(m_optBtn, EINA_FALSE);
 535         elm_genlist_decorate_mode_set(m_gl, EINA_FALSE);
 536     }
 537 }
 538
 539 void WhiteListView::removeWhiteUri(void)
 540 {
 541     UriData *uriData;
 542     Elm_Object_Item *it;
 543     Elm_Object_Item *trailIt;
 544
 545     Assert(m_gl);
 546
 547     it = elm_genlist_first_item_get(m_gl);
 548     while (it) {
 549         uriData = static_cast<UriData *>(elm_object_item_data_get(it));
 550         Assert(uriData);
 551
 552         trailIt = elm_genlist_item_next_get(it);
 553         if (uriData->m_selected) {
 554             WrtDB::GlobalDAO::RemoveWhiteURI(uriData->m_uri);
 555             /* TODO: deprecated API */
 556             //elm_object_item_del(it);
 557             elm_object_item_del(it);
 558             m_uriCnt--;
 559             decreaseSelectCnt();
 560         }
 561         it = trailIt;
 562     }
 563     if (!m_uriCnt)
 564         handleBackBtn();
 565 }
 566
 567 void WhiteListView::increaseSelectCnt(void)
 568 {
 569     Evas_Object *chk;
 570
 571     Assert(m_selectAll);
 572     chk = elm_object_part_content_get(m_selectAll, "elm.icon");
 573     Assert(chk);
 574
 575     if (!m_selectCnt)
 576         elm_object_item_disabled_set(m_optBtn, EINA_FALSE);
 577     m_selectCnt++;
 578     if (m_selectCnt >= m_uriCnt) {
 579         m_selectCnt = m_uriCnt;
 580         elm_check_state_set(chk, EINA_TRUE);
 581     }
 582 }
 583
 584 void WhiteListView::decreaseSelectCnt(void)
 585 {
 586     Evas_Object *chk;
 587
 588     Assert(m_selectAll);
 589     chk = elm_object_part_content_get(m_selectAll, "elm.icon");
 590     Assert(chk);
 591
 592     if (m_selectCnt > 0)
 593         m_selectCnt--;
 594
 595     if (m_selectCnt <= 0)
 596         elm_object_item_disabled_set(m_optBtn, EINA_TRUE);
 597     elm_check_state_set(chk, EINA_FALSE);
 598 }
 599
 600 void WhiteListView::selectAll(Eina_Bool select)
 601 {
 602     Elm_Object_Item *it;
 603     UriData *uriData;
 604
 605     Assert(m_gl);
 606     it = elm_genlist_first_item_get(m_gl);
 607
 608     while (it) {
 609         uriData = static_cast<UriData *>(elm_object_item_data_get(it));
 610         Assert(uriData);
 611         uriData->m_selected = select;
 612         it = elm_genlist_item_next_get(it);
 613     }
 614
 615     elm_object_item_disabled_set(m_optBtn, !select);
 616     if (select)
 617         m_selectCnt = m_uriCnt;
 618     else
 619         m_selectCnt = 0;
 620     elm_genlist_realized_items_update(m_gl);
 621 }
 622
 623 bool WhiteListView::showPopup(const char *desc,
 624                               Evas_Smart_Cb ok_cb,
 625                               Evas_Smart_Cb cancel_cb,
 626                               void *data)
 627 {
 628     return m_popup.showPopup(desc, ok_cb, cancel_cb, data);
 629 }
 630
 631 void WhiteListView::hidePopup(void)
 632 {
 633     m_popup.hidePopup();
 634 }
 635
 636 WhiteListView::WhiteListView(Evas_Object *naviFrame) :
 637     m_naviFrame(naviFrame),
 638     m_bx(NULL),
 639     m_gl(NULL),
 640     m_selectAll(NULL),
 641     m_selectCnt(0),
 642     m_uriCnt(0),
 643     m_editModeBtn(NULL),
 644     m_optBtn(NULL)
 645 {
 646     m_whiteUriView.Reset();
 647 }
 648
 649 WhiteListView::~WhiteListView(void)
 650 {
 651 }
 652
 653 } /* WebAppCommonSetting */