webapp-detail/detailview.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://www.tizenopensource.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 <sstream>
  18 #include <Elementary.h>
  19
  20 #include <dpl/wrt-dao-rw/widget_dao.h>
  21 #include <dpl/foreach.h>
  22 #include <dpl/assert.h>
  23 #include <dpl/utils/wrt_global_settings.h>
  24
  25 #include <ui-gadget-module.h>
  26
  27 #include "detailview.h"
  28 #include "advancedview.h"
  29 #include "util.h"
  30
  31 namespace WebAppDetailSetting {
  32 namespace {
  33 const int MAX_PATH_LENGTH  = 255;
  34 const int ERROR_READ_LINK = -1;
  35 // need to move widget_config.h
  36 const char* const WRT_LAUNCHER = "wrt-launcher";
  37 const char* const WRT_LAUNCHER_WK_MODE_CHANGE_OPTION = "-w";
  38 }
  39
  40 void DetailView::getLocalizedInfo(void)
  41 {
  42     DPL::OptionalString locale;
  43
  44     Assert(m_dao);
  45
  46     locale = m_dao->getDefaultlocale();
  47     if (locale.IsNull()) {
  48         DPL::String lang_tag(L"");
  49         m_localizedInfo = m_dao->getLocalizedInfo(lang_tag);
  50     } else {
  51         m_localizedInfo = m_dao->getLocalizedInfo(*locale);
  52     }
  53 }
  54
  55 void DetailView::addField(const char *title)
  56 {
  57     Evas_Object *ly;
  58
  59     Assert(m_bx && title);
  60
  61     ly = elm_layout_add(m_bx);
  62     if (!ly)
  63         return;
  64     elm_layout_theme_set(ly, "layout", "dialogue", "title");
  65     evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, 0.0);
  66     evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, 0.0);
  67     elm_object_part_text_set(ly, "elm.text", title);
  68     evas_object_show(ly);
  69     elm_box_pack_end(m_bx, ly);
  70 }
  71
  72 void DetailView::addField(const char *title, const char *str)
  73 {
  74     Evas_Object *ly;
  75     Evas_Object *field;
  76     Evas_Object *entry;
  77
  78     Assert(m_bx && title);
  79
  80     ly = elm_layout_add(m_bx);
  81     if (!ly)
  82         return;
  83     elm_layout_theme_set(ly, "layout", "dialogue", "1icon");
  84     evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, 0.0);
  85     evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, 0.0);
  86
  87     field = elm_layout_add(ly);
  88     if (!field) {
  89         evas_object_del(ly);
  90         return;
  91     }
  92     elm_layout_theme_set(field, "layout", "editfield", "title");
  93     elm_object_part_text_set(field, "elm.text", title);
  94     if (str) {
  95             entry = elm_entry_add(field);
  96             if (entry) {
  97                     elm_entry_editable_set(entry, EINA_FALSE);
  98 //                  elm_entry_single_line_set(entry, EINA_TRUE);
  99                     elm_object_text_set(entry, str);
 100                     elm_object_part_content_set(field,
 101                                     "elm.swallow.content", entry);
 102             }
 103     }
 104     elm_object_part_content_set(ly, "elm.icon", field);
 105     evas_object_show(ly);
 106     elm_box_pack_end(m_bx, ly);
 107 }
 108
 109 void DetailView::addDefInfo(void)
 110 {
 111     DPL::OptionalString ver;
 112
 113     Assert(m_dao);
 114
 115     addField(D_("IDS_COM_BODY_DETAILS_NAME"),
 116             m_localizedInfo.name.IsNull() ? NULL :
 117             DPL::ToUTF8String((*m_localizedInfo.name)).c_str());
 118
 119     ver = m_dao->getVersion();
 120     /* FIXME: i18n */
 121     addField("Version",
 122             ver.IsNull() ? NULL :
 123             DPL::ToUTF8String((*ver)).c_str());
 124
 125     /* FIXME: i18n */
 126     addField("Domain",
 127             m_dao->isTrusted() ? "Trusted" : "Untrusted");
 128
 129     addField(D_("IDS_COM_BODY_DESCRIPTION"),
 130             m_localizedInfo.description.IsNull() ? NULL :
 131             DPL::ToUTF8String((*m_localizedInfo.description)).c_str());
 132 }
 133
 134 void DetailView::addViewModes(void)
 135 {
 136     DPL::String mode;
 137     WrtDB::WindowModeList modes;
 138
 139     Assert(m_dao);
 140
 141     modes = m_dao->getWindowModes();
 142     if (modes.size() > 0) {
 143         FOREACH(it, modes)
 144             mode += *it + L",";
 145         /* remove comma */
 146         mode.resize(mode.length() - 1);
 147         /* FIXME: i18n */
 148         addField("View modes",
 149                 DPL::ToUTF8String(mode).c_str());
 150     } else {
 151         /* FIXME: i18n */
 152         addField("View modes", NULL);
 153     }
 154 }
 155
 156 void DetailView::addAuthorInfo(void)
 157 {
 158     DPL::OptionalString name;
 159     DPL::OptionalString email;
 160     DPL::OptionalString homepage;
 161
 162     Assert(m_dao);
 163
 164     addField(D_("IDS_COM_BODY_AUTHOR"));
 165
 166     name = m_dao->getAuthorName();
 167     addField(D_("IDS_COM_BODY_DETAILS_NAME"),
 168             name.IsNull() ? NULL :
 169             DPL::ToUTF8String((*name)).c_str());
 170
 171     email = m_dao->getAuthorEmail();
 172     if (!email.IsNull())
 173         addField(D_("IDS_COM_BODY_EMAIL"),
 174                 DPL::ToUTF8String((*email)).c_str());
 175
 176     homepage = m_dao->getAuthorHref();
 177     /* FIXME: i18n */
 178     if (!homepage.IsNull())
 179         addField("Homepage",
 180                 DPL::ToUTF8String((*homepage)).c_str());
 181 }
 182
 183 void DetailView::addSaveLoginInfo()
 184 {
 185     Assert(m_bx);
 186
 187     Evas_Object *ly = elm_layout_add(m_bx);
 188     if (!ly)
 189         return;
 190     elm_layout_theme_set(ly, "layout", "dialogue", "1text.1icon");
 191     evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, 0.0);
 192     evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, 0.0);
 193     elm_object_part_text_set(ly, "elm.text", "Auto save ID/password");
 194
 195     check_login = elm_check_add(ly);
 196     if (!check_login) {
 197         evas_object_del(ly);
 198         return;
 199     }
 200
 201     elm_object_style_set(check_login, "on&off");
 202     evas_object_propagate_events_set(check_login, EINA_FALSE);
 203     elm_object_part_content_set(ly, "elm.icon", check_login);
 204
 205     evas_object_event_callback_add(ly,
 206             EVAS_CALLBACK_MOUSE_DOWN,
 207             _mouse_down,
 208             NULL);
 209     evas_object_event_callback_add(ly,
 210             EVAS_CALLBACK_MOUSE_MOVE,
 211             _mouse_move,
 212             NULL);
 213     evas_object_event_callback_add(ly,
 214             EVAS_CALLBACK_MOUSE_UP,
 215             _mouse_up_save_login_info,
 216             this);
 217
 218     evas_object_show(ly);
 219     elm_box_pack_end(m_bx, ly);
 220 }
 221
 222 void DetailView::addClearData()
 223 {
 224     Assert(m_bx);
 225
 226     Evas_Object *ly = elm_layout_add(m_bx);
 227     if (!ly)
 228         return;
 229     elm_layout_theme_set(ly, "layout", "dialogue", "1text");
 230     elm_object_text_set(ly, "Clear Data");
 231     evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, EVAS_HINT_FILL);
 232     evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 233
 234     evas_object_event_callback_add(ly,
 235             EVAS_CALLBACK_MOUSE_DOWN,
 236             _mouse_down,
 237             NULL);
 238     evas_object_event_callback_add(ly,
 239             EVAS_CALLBACK_MOUSE_MOVE,
 240             _mouse_move,
 241             NULL);
 242     evas_object_event_callback_add(ly,
 243             EVAS_CALLBACK_MOUSE_UP,
 244             _mouse_up_clear_data,
 245             this);
 246
 247     evas_object_show(ly);
 248     elm_box_pack_end(m_bx, ly);
 249
 250 }
 251
 252 void DetailView::addAdvancedSettings()
 253 {
 254     Assert(m_bx);
 255
 256     Evas_Object *ly = elm_layout_add(m_bx);
 257     if (!ly)
 258         return;
 259     elm_layout_theme_set(ly, "layout", "dialogue", "1text");
 260     elm_object_text_set(ly, "Advanced Settings");
 261     evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, EVAS_HINT_FILL);
 262     evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 263
 264     evas_object_event_callback_add(ly,
 265             EVAS_CALLBACK_MOUSE_DOWN,
 266             _mouse_down,
 267             NULL);
 268     evas_object_event_callback_add(ly,
 269             EVAS_CALLBACK_MOUSE_MOVE,
 270             _mouse_move,
 271             NULL);
 272     evas_object_event_callback_add(ly,
 273             EVAS_CALLBACK_MOUSE_UP,
 274             _mouse_up_advanced_settings,
 275             this);
 276
 277     evas_object_show(ly);
 278     elm_box_pack_end(m_bx, ly);
 279
 280 }
 281
 282 void DetailView::addSeperator()
 283 {
 284     Evas_Object *ly;
 285
 286     Assert(m_bx);
 287
 288     ly = elm_layout_add(m_bx);
 289     if (!ly)
 290         return;
 291     elm_layout_theme_set(ly, "layout", "dialogue", "separator/hd33/with_line");
 292
 293     evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, 0.0);
 294     evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, 0.0);
 295     evas_object_show(ly);
 296     elm_box_pack_end(m_bx, ly);
 297 }
 298
 299 void DetailView::addLicense(void)
 300 {
 301     DPL::OptionalString license;
 302     DPL::OptionalString href;
 303
 304     std::string strLicense;
 305     std::string strHref;
 306
 307     std::string lrepdf = "\xE2\x80\xAA\xE2\x80\xAC";
 308     std::string rlepdf = "\xE2\x80\xAB\xE2\x80\xAC";
 309     std::string lropdf = "\xE2\x80\xAD\xE2\x80\xAC";
 310     std::string rlopdf = "\xE2\x80\xAE\xE2\x80\xAC";
 311
 312     Evas_Object* layout;
 313
 314     Assert(m_dao);
 315
 316     license = m_localizedInfo.license;
 317     if (!license.IsNull())
 318         strLicense = DPL::ToUTF8String((*license));
 319
 320     href = m_localizedInfo.licenseHref;
 321     if (!href.IsNull())
 322         strHref = DPL::ToUTF8String((*href));
 323
 324     m_licenseInfo = new LicenseInfo();
 325     if (!m_licenseInfo)
 326         return;
 327
 328     if (!strLicense.empty() &&
 329         strLicense.compare(lrepdf) != 0 &&
 330         strLicense.compare(rlepdf) != 0 &&
 331         strLicense.compare(lropdf) != 0 &&
 332         strLicense.compare(rlopdf) != 0) {
 333         m_licenseInfo->license = strLicense;
 334     }
 335
 336     if (!strHref.empty()) {
 337         m_licenseInfo->href = strHref;
 338     }
 339
 340     addSeperator();
 341
 342     layout = elm_layout_add(m_bx);
 343     if (!layout)
 344         return;
 345     elm_layout_theme_set(layout, "layout", "dialogue", "1text");
 346     evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, 0.0);
 347     evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, 0.0);
 348     elm_object_part_text_set(layout, "elm.text", "License Information");
 349
 350     if (m_licenseInfo->license.empty() && m_licenseInfo->href.empty()) {
 351         elm_object_signal_emit(layout, "elm,state,disabled", "elm");
 352     } else {
 353         m_licenseInfo->evasObj = layout;
 354
 355     evas_object_event_callback_add(layout,
 356             EVAS_CALLBACK_MOUSE_DOWN,
 357             _mouse_down,
 358             NULL);
 359     evas_object_event_callback_add(layout,
 360             EVAS_CALLBACK_MOUSE_MOVE,
 361             _mouse_move,
 362             NULL);
 363     evas_object_event_callback_add(layout,
 364             EVAS_CALLBACK_MOUSE_UP,
 365             _mouse_up_license,
 366             m_licenseInfo);
 367     }
 368
 369     elm_box_pack_end(m_bx, layout);
 370     evas_object_show(layout);
 371 }
 372
 373 void DetailView::clearDataCallback(void *data,
 374         Evas_Object *obj,
 375         void* event_info )
 376 {
 377     //TODO : implementation here.
 378     Evas_Object *popup = static_cast<Evas_Object *>(data);
 379     evas_object_del(popup);
 380 }
 381
 382 void DetailView::viewlicenseCallback(void *data,
 383         Evas_Object *obj,
 384         void *event_info)
 385 {
 386     //TODO : implementation here.
 387     Evas_Object *popup = static_cast<Evas_Object *>(data);
 388     evas_object_del(popup);
 389 }
 390
 391 void DetailView::closeCallback(void *data,
 392         Evas_Object *obj,
 393         void *event_info)
 394 {
 395     evas_object_del(static_cast<Evas_Object *>(data));
 396 }
 397
 398 void DetailView::_mouse_down(void *data,
 399         Evas *e,
 400         Evas_Object *obj,
 401         void *event_info)
 402 {
 403     elm_object_signal_emit(obj, "elm,state,selected", "elm");
 404 }
 405
 406 void DetailView::_mouse_move(void *data,
 407         Evas *e,
 408         Evas_Object *obj,
 409         void *event_info)
 410 {
 411     Evas_Event_Mouse_Move *event;
 412     Evas_Coord ox, oy, ow, oh;
 413
 414     event = static_cast<Evas_Event_Mouse_Move*>(event_info);
 415     if (!event)
 416         return;
 417
 418     evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
 419
 420     if (event->cur.canvas.x < ox || (ox + ow) < event->cur.canvas.x ||
 421         event->cur.canvas.y < oy || (oy + oh) < event->cur.canvas.y) {
 422         elm_object_signal_emit(obj, "elm,state,unselected", "elm");
 423     }
 424
 425 }
 426
 427 void DetailView::_mouse_up_license(void *data,
 428         Evas *e,
 429         Evas_Object *obj,
 430         void* event_info)
 431 {
 432     Evas_Event_Mouse_Up *event;
 433     Evas_Object *win;
 434     Evas_Object *popup;
 435     Evas_Object *box;
 436     Evas_Object *web;
 437     Evas_Object *btn;
 438     Evas_Object *l_button;
 439     Evas_Object *r_button;
 440     LicenseInfo *licenseInfo;
 441     Evas_Coord ox, oy, ow, oh;
 442     std::string label;
 443
 444     licenseInfo = static_cast<LicenseInfo *>(data);
 445     if (!licenseInfo)
 446         return;
 447
 448     event = static_cast<Evas_Event_Mouse_Up*>(event_info);
 449     if (!event)
 450         return;
 451
 452     evas_object_geometry_get(licenseInfo->evasObj, &ox, &oy, &ow, &oh);
 453     if (event->output.x < ox || (ox + ow) < event->canvas.x ||
 454         event->output.y < oy || (oy + oh) < event->canvas.y) {
 455         return;
 456     }
 457     elm_object_signal_emit(licenseInfo->evasObj, "elm,state,unselected", "elm");
 458
 459     win = static_cast<Evas_Object *>(ug_get_window());
 460     if (!win)
 461         return;
 462
 463     popup = elm_popup_add(win);
 464     if (!popup)
 465         return;
 466
 467     evas_object_size_hint_align_set(popup, EVAS_HINT_FILL, EVAS_HINT_FILL);
 468     evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 469     elm_object_part_text_set(popup, "title,text", "License Information");
 470
 471     label += licenseInfo->license.c_str();
 472     if (!licenseInfo->href.empty()) {
 473         if (!label.empty())
 474             label += "<br>";
 475         label += "More license, see <br>";
 476         label += licenseInfo->href.c_str();
 477     }
 478     elm_object_part_text_set(popup, "default", label.c_str());
 479     evas_object_show(popup);
 480
 481     l_button = elm_button_add(popup);
 482     if (!l_button) {
 483         evas_object_del(popup);
 484         return;
 485     }
 486
 487     evas_object_size_hint_align_set(l_button, EVAS_HINT_FILL, EVAS_HINT_FILL);
 488     evas_object_size_hint_weight_set(l_button, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 489     elm_object_text_set(l_button, "YES");
 490     elm_object_part_content_set(popup, "button1", l_button);
 491     evas_object_smart_callback_add(l_button,
 492             "clicked",
 493             viewlicenseCallback,
 494             (void *)popup);
 495     evas_object_show(r_button);
 496
 497     r_button = elm_button_add(popup);
 498     if (!r_button) {
 499         evas_object_del(popup);
 500         return;
 501     }
 502
 503     evas_object_size_hint_align_set(r_button, EVAS_HINT_FILL, EVAS_HINT_FILL);
 504     evas_object_size_hint_weight_set(r_button, EVAS_HINT_FILL, EVAS_HINT_FILL);
 505     elm_object_text_set(r_button, "NO");
 506     elm_object_part_content_set(popup, "button2", r_button);
 507     evas_object_smart_callback_add(r_button,
 508             "clicked",
 509             closeCallback,
 510             (void *)popup);
 511     evas_object_show(l_button);
 512     elm_object_focus_allow_set(popup, EINA_TRUE);
 513     elm_object_focus_set(popup, EINA_TRUE);
 514 }
 515
 516 void DetailView::_mouse_up_save_login_info(void *data,
 517         Evas */*e*/,
 518         Evas_Object *obj,
 519         void *event_info)
 520 {
 521     Assert(obj && data && event_info);
 522
 523     Evas_Event_Mouse_Up *event;
 524     Evas_Coord ox, oy, ow, oh;
 525
 526     event = static_cast<Evas_Event_Mouse_Up*>(event_info);
 527     evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
 528
 529     if (event->output.x < ox || (ox + ow) < event->output.x ||
 530         event->output.y < oy || (oy + oh) < event->output.y) {
 531         return;
 532     }
 533
 534     DetailView *This = static_cast<DetailView *>(data);
 535     elm_check_state_set(This->check_login, !elm_check_state_get(This->check_login));
 536     elm_object_signal_emit(obj, "elm,state,unselected", "elm");
 537 }
 538
 539 void DetailView::_mouse_up_clear_data(void *data,
 540         Evas */*e*/,
 541         Evas_Object *obj,
 542         void *event_info)
 543 {
 544     Evas_Event_Mouse_Up *event;
 545     Evas_Coord ox, oy, ow, oh;
 546     Evas_Object *popup;
 547     Evas_Object *l_button;
 548     Evas_Object *r_button;
 549
 550     event = static_cast<Evas_Event_Mouse_Up *>(event_info);
 551     if (!event)
 552         return;
 553
 554     evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
 555
 556     if (event->output.x < ox || (ox + ow) < event->output.x ||
 557             event->output.y < oy || (oy + oh) < event->output.y) {
 558         return;
 559     }
 560
 561     DetailView *This = static_cast<DetailView *>(data);
 562
 563     Assert(This->m_bx);
 564     elm_object_signal_emit(obj, "elm,state,unselected", "elm");
 565
 566     popup = elm_popup_add(This->m_bx);
 567     if(!popup)
 568        return;
 569     evas_object_size_hint_align_set(popup, EVAS_HINT_FILL, EVAS_HINT_FILL);
 570     evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 571     elm_object_part_text_set(popup, "default", "Do you want to clear data?");
 572
 573     l_button = elm_button_add(popup);
 574     elm_object_text_set(l_button, "YES");
 575     evas_object_smart_callback_add(l_button, "clicked", clearDataCallback, (void*)popup);
 576     elm_object_part_content_set(popup, "button1", l_button);
 577     evas_object_show(l_button);
 578
 579     r_button = elm_button_add(popup);
 580     elm_object_text_set(r_button, "NO");
 581     evas_object_smart_callback_add(r_button, "clicked", closeCallback, (void*)popup);
 582     elm_object_part_content_set(popup, "button2", r_button);
 583     evas_object_show(r_button);
 584
 585     evas_object_show(popup);
 586 }
 587
 588 void DetailView::_mouse_up_advanced_settings(void* data,
 589                                              Evas* /*e*/,
 590                                              Evas_Object* obj,
 591                                              void* eventInfo)
 592 {
 593     Evas_Event_Mouse_Up *event;
 594     Evas_Coord ox, oy, ow, oh;
 595
 596     event = static_cast<Evas_Event_Mouse_Up *>(eventInfo);
 597     if (!event)
 598         return;
 599
 600     evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
 601
 602     if (event->output.x < ox || (ox + ow) < event->output.x ||
 603         event->output.y < oy || (oy + oh) < event->output.y)
 604     {
 605         return;
 606     }
 607
 608     elm_object_signal_emit(obj, "elm,state,unselected", "elm");
 609     Assert(data);
 610     DetailView* This = static_cast<DetailView*>(data);
 611
 612     This->m_advancedView.Reset(
 613         new AdvancedView(This->m_naviframe, This->m_appID));
 614     if (!This->m_advancedView->loadView()) {
 615         This->m_advancedView.Reset();
 616     }
 617 }
 618
 619 void DetailView:: clearDataPopupCallback(void *data, Evas_Object *obj,
 620         void *event_info)
 621 {
 622     Evas_Object *popup;
 623     Evas_Object *btn1;
 624     Evas_Object *btn2;
 625     DetailData *detailData;
 626
 627     Elm_Object_Item *it;
 628     it = static_cast<Elm_Object_Item *>(event_info);
 629     Assert(it);
 630     elm_genlist_item_selected_set(it, EINA_FALSE);
 631     detailData = static_cast<DetailData *>(data);
 632
 633     popup = elm_popup_add(detailData->m_detailView->m_naviframe);
 634     evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 635     elm_object_text_set(popup,"Do you want to clear data?");
 636     btn1 = elm_button_add(popup);
 637     elm_object_text_set(btn1, "OK");
 638     elm_object_part_content_set(popup, "button1", btn1);
 639     evas_object_smart_callback_add(btn1, "clicked", clearDataCallback, popup);
 640     btn2 = elm_button_add(popup);
 641     elm_object_text_set(btn2, "Cancel");
 642     elm_object_part_content_set(popup, "button2", btn2);
 643     evas_object_smart_callback_add(btn2, "clicked", closeCallback, popup);
 644     evas_object_show(popup);
 645 }
 646
 647 void DetailView::advancedSettingsCallback(void* data,
 648                                              Evas_Object* obj,
 649                                              void* eventInfo)
 650 {
 651     DetailData *detailData;
 652     Assert(data);
 653
 654     Elm_Object_Item *it;
 655     it = static_cast<Elm_Object_Item *>(eventInfo);
 656     Assert(it);
 657     elm_genlist_item_selected_set(it, EINA_FALSE);
 658     detailData = static_cast<DetailData *>(data);
 659     detailData->m_detailView->m_advancedView.Reset(
 660         new AdvancedView(detailData->m_detailView->m_naviframe,
 661         detailData->m_detailView->m_appID));
 662     if (!detailData->m_detailView->m_advancedView->loadView()) {
 663         detailData->m_detailView->m_advancedView.Reset();
 664     }
 665 }
 666 char *DetailView::getText(void *data,
 667                         Evas_Object */*obj*/,
 668                         const char *part)
 669 {
 670     DetailData *detailData;
 671     const char *str;
 672
 673     detailData = static_cast<DetailData *>(data);
 674     Assert(detailData);
 675     if (!strcmp(part, "elm.text"))
 676         str = detailData->m_title.c_str();
 677     else if (!strcmp(part, "elm.text.1"))
 678         str = detailData->m_subtitle.c_str();
 679     else if(!strcmp(part, "elm.text.2"))
 680         str = detailData->m_title.c_str();
 681     else
 682         str = NULL;
 683     return strdup(str);
 684 }
 685
 686 char *DetailView::getTitle(void *data,
 687                         Evas_Object */*obj*/,
 688                         const char *part)
 689 {
 690     DetailData *detailData;
 691     const char *str;
 692
 693     detailData = static_cast<DetailData *>(data);
 694     Assert(detailData);
 695
 696     if (!strcmp(part, "elm.text"))
 697         str = detailData->m_title.c_str();
 698     else if (!strcmp(part, "elm.text.1"))
 699         str = detailData->m_title.c_str();
 700     else
 701         str = "";
 702     return strdup(str);
 703 }
 704
 705 void DetailView::addDefInfo(Evas_Object *gl)
 706 {
 707     DPL::OptionalString ver;
 708
 709     Assert(m_dao);
 710
 711     ver = m_dao->getVersion();
 712     bindtextdomain("ug-webapp-common-efl", "/usr/ug/res/locale");
 713     addTitleText(gl,D_("IDS_COM_BODY_DETAILS_NAME"),
 714             m_localizedInfo.name.IsNull() ? "" :
 715             DPL::ToUTF8String((*m_localizedInfo.name)).c_str());
 716     addTitleText(gl,U_("IDS_ST_BODY_VERSION"), ver.IsNull() ? "" :
 717             DPL::ToUTF8String((*ver)).c_str());
 718     //addTitleText(gl,U_("IDS_ST_BODY_DOMAIN_SECURITY_STATUS"),
 719     //    m_dao->isTrusted() ? "Trusted" : "Untrusted");
 720     addTitleText(gl,D_("IDS_COM_BODY_DESCRIPTION"),
 721             m_localizedInfo.description.IsNull() ? "" :
 722             DPL::ToUTF8String((*m_localizedInfo.description)).c_str());
 723 }
 724
 725 void DetailView::addViewModes(Evas_Object *gl)
 726 {
 727     DPL::String mode;
 728     WrtDB::WindowModeList modes;
 729
 730     Assert(m_dao);
 731     bindtextdomain("ug-webapp-common-efl", "/usr/ug/res/locale");
 732     modes = m_dao->getWindowModes();
 733     if (modes.size() > 0) {
 734         FOREACH(it, modes)
 735             mode += *it + L",";
 736         /* remove comma */
 737         mode.resize(mode.length() - 1);
 738         /* FIXME: i18n */
 739         addTitleText(gl,U_("IDS_WRT_BODY_VIEW_M_MODE"),
 740             DPL::ToUTF8String(mode).c_str());
 741     } else {
 742         /* FIXME: i18n */
 743       addTitleText(gl,U_("IDS_WRT_BODY_VIEW_M_MODE"), "");
 744     }
 745 }
 746
 747 void DetailView::addAuthorInfo(Evas_Object *gl)
 748 {
 749     DPL::OptionalString name;
 750     DPL::OptionalString email;
 751     DPL::OptionalString homepage;
 752
 753     Assert(m_dao);
 754     addTitle(gl,D_("IDS_COM_BODY_AUTHOR"));
 755
 756     name = m_dao->getAuthorName();
 757     addTitleText(gl,D_("IDS_COM_BODY_DETAILS_NAME"),
 758             name.IsNull() ? "" :
 759             DPL::ToUTF8String((*name)).c_str());
 760
 761     email = m_dao->getAuthorEmail();
 762     if (!email.IsNull())
 763         addTitleText(gl,D_("IDS_COM_BODY_EMAIL"),
 764                 DPL::ToUTF8String((*email)).c_str());
 765
 766     homepage = m_dao->getAuthorHref();
 767     /* FIXME: i18n */
 768     if (!homepage.IsNull())
 769         addTitleText(gl,"Homepage",
 770                 DPL::ToUTF8String((*homepage)).c_str());
 771 }
 772
 773 void DetailView::addDepth(Evas_Object *gl)
 774 {
 775     static Elm_Genlist_Item_Class itc;
 776     Elm_Object_Item *it;
 777     Assert(gl);
 778
 779     try {
 780         itc.item_style = "dialogue/separator/21/with_line";
 781         itc.func.text_get = NULL;
 782         itc.func.content_get = NULL;
 783         itc.func.state_get = NULL;
 784         itc.func.del = NULL;
 785         it = elm_genlist_item_append(gl,
 786                                 &itc,
 787                                 NULL,
 788                                 NULL,
 789                                 ELM_GENLIST_ITEM_NONE,
 790                                 NULL,
 791                                 NULL);
 792         elm_genlist_item_select_mode_set(it,
 793         ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 794     } catch (const std::bad_alloc &) {
 795     }
 796 }
 797
 798 void DetailView::addTitle(Evas_Object *gl, const char* title)
 799 {
 800     static Elm_Genlist_Item_Class itc;
 801     Elm_Object_Item *it;
 802
 803     DetailData *detailData;
 804     Assert(gl);
 805     try {
 806
 807     detailData = new DetailData(this,
 808                               title,
 809                               title);
 810     itc.item_style = "dialogue/title";
 811     itc.func.text_get = getTitle ;
 812     itc.func.content_get = NULL;
 813     itc.func.state_get = NULL;
 814     itc.func.del = NULL;
 815
 816     it = elm_genlist_item_append(gl,
 817                             &itc,
 818                             static_cast<void *>(detailData),
 819                             NULL,
 820                             ELM_GENLIST_ITEM_NONE,
 821                             NULL,
 822                             NULL);
 823     elm_genlist_item_select_mode_set(it,
 824         ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 825     } catch (const std::bad_alloc &) {
 826     }
 827 }
 828
 829 void DetailView::addTitleText(
 830     Evas_Object *gl, const char* title, const char* subtitle)
 831 {
 832     static Elm_Genlist_Item_Class itc;
 833     Elm_Object_Item *it;
 834     DetailData *detailData;
 835     Assert(gl);
 836     try {
 837     detailData = new DetailData(this,
 838                               title,
 839                               subtitle);
 840     itc.item_style = "dialogue/2text.2";
 841     itc.func.text_get =getText ;
 842     itc.func.content_get = NULL;
 843     itc.func.state_get = NULL;
 844     itc.func.del = NULL;
 845     it = elm_genlist_item_append(gl,
 846                             &itc,
 847                             static_cast<void *>(detailData),
 848                             NULL,
 849                             ELM_GENLIST_ITEM_NONE,
 850                             NULL,
 851                             NULL);
 852     elm_genlist_item_select_mode_set(it,
 853         ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 854     } catch (const std::bad_alloc &) {
 855     }
 856 }
 857
 858 void DetailView::addLicenseInfo(Evas_Object *gl, const char* title)
 859 {
 860     static Elm_Genlist_Item_Class itc;
 861     DetailData *detailData;
 862     Elm_Object_Item *it;
 863
 864     Assert(gl);
 865     try {
 866     detailData = new DetailData(this,
 867                               title,
 868                               title);
 869     itc.item_style = "dialogue/1text";
 870     itc.func.text_get =getTitle ;
 871     itc.func.content_get = NULL;
 872     itc.func.state_get = NULL;
 873     itc.func.del = NULL;
 874
 875     it = elm_genlist_item_append(gl,
 876                             &itc,
 877                             static_cast<void *>(detailData),
 878                             NULL,
 879                             ELM_GENLIST_ITEM_NONE,
 880                             NULL,
 881                             NULL);
 882     elm_object_item_disabled_set(it, EINA_TRUE);
 883     } catch (const std::bad_alloc &) {
 884     }
 885 }
 886
 887 void DetailView::addClearData(Evas_Object *gl, const char* title)
 888 {
 889     static Elm_Genlist_Item_Class itc;
 890     DetailData *detailData;
 891     Elm_Object_Item *it;
 892
 893     Assert(gl);
 894     try {
 895     detailData = new DetailData(this,
 896                               title,
 897                               title);
 898     itc.item_style = "dialogue/1text";
 899     itc.func.text_get =getTitle ;
 900     itc.func.content_get = NULL;
 901     itc.func.state_get = NULL;
 902     itc.func.del = NULL;
 903     it = elm_genlist_item_append(gl,
 904                             &itc,
 905                             static_cast<void *>(detailData),
 906                             NULL,
 907                             ELM_GENLIST_ITEM_NONE,
 908                             clearDataPopupCallback,
 909                             static_cast<void *>(detailData));
 910     elm_genlist_item_select_mode_set(it,
 911         ELM_OBJECT_SELECT_MODE_ALWAYS);
 912     } catch (const std::bad_alloc &) {
 913     }
 914 }
 915
 916 void DetailView::addAdvancedSetting(Evas_Object *gl, const char* title)
 917 {
 918     static Elm_Genlist_Item_Class itc;
 919     DetailData *detailData;
 920     Elm_Object_Item *it;
 921
 922     Assert(gl);
 923     try {
 924     detailData = new DetailData(this,
 925                               title,
 926                               title);
 927     itc.item_style = "dialogue/1text";
 928     itc.func.text_get =getTitle ;
 929     itc.func.content_get = NULL;
 930     itc.func.state_get = NULL;
 931     itc.func.del = NULL;
 932     it = elm_genlist_item_append(gl,
 933                             &itc,
 934                             static_cast<void *>(detailData),
 935                             NULL,
 936                             ELM_GENLIST_ITEM_NONE,
 937                             advancedSettingsCallback,
 938                             static_cast<void *>(detailData));
 939     elm_genlist_item_select_mode_set(it,
 940         ELM_OBJECT_SELECT_MODE_ALWAYS);
 941     } catch (const std::bad_alloc &) {
 942     }
 943 }
 944
 945 Evas_Object *DetailView::loadView(void)
 946 {
 947     Evas_Object *win;
 948     resetBase();
 949     try {
 950         win = static_cast<Evas_Object *>(ug_get_window());
 951         Assert(win);
 952         m_gl = elm_genlist_add(m_naviframe);
 953         elm_object_style_set(m_gl, "dialogue");
 954
 955         m_dao.Reset(new WrtDB::WidgetDAO(m_appID));
 956         getLocalizedInfo();
 957
 958         if (!m_gl) {
 959             evas_object_del(m_naviframe);
 960             return NULL;
 961         }
 962         addDepth(m_gl);
 963         addDefInfo(m_gl);
 964         addViewModes(m_gl);
 965         addAuthorInfo(m_gl);
 966         bindtextdomain("ug-webapp-common-efl", "/usr/ug/res/locale");
 967         if (!GlobalSettings::TestModeEnabled())
 968             addLicenseInfo(m_gl,U_("IDS_WRT_BODY_LICENCE_INFORMATION"));
 969         addClearData(m_gl, U_("IDS_ST_BODY_CLEAR_DATA"));
 970         addAdvancedSetting(m_gl, U_("IDS_ST_HEADER_ADVANCED_SETTINGS"));
 971         pushToNaviFrame();
 972
 973     return win;
 974     } catch (const std::bad_alloc &) {
 975          return NULL;
 976     }
 977 }
 978
 979 void DetailView::onBackBtnClicked(void *data,
 980                                 Evas_Object */*obj*/,
 981                                 void */*event_info*/)
 982 {
 983     DetailView* This;
 984
 985     This= static_cast<DetailView *>(data);
 986     Assert(This);
 987     ug_destroy_me(This->m_ug);
 988 }
 989 bool DetailView::pushToNaviFrame(void)
 990 {
 991     Evas_Object *btn;
 992
 993     Assert(m_naviframe);
 994     btn = elm_button_add(m_naviframe);
 995     if (!btn)
 996         return false;
 997
 998     elm_object_style_set(btn, "naviframe/end_btn/default");
 999     evas_object_smart_callback_add(btn, "clicked", onBackBtnClicked, this);
1000     bindtextdomain("ug-webapp-common-efl", "/usr/ug/res/locale");
1001     elm_naviframe_item_push(m_naviframe,
1002                             U_("IDS_ST_BODY_MORE_DETAILS"),
1003                             btn,
1004                             NULL,
1005                             m_gl,
1006                             NULL);
1007     return true;
1008 }
1009
1010 DetailView::DetailView(Evas_Object* navi, ui_gadget_h ug, int appID) :
1011     m_naviframe(navi),
1012     m_bx(NULL),
1013     m_appID(appID),
1014     m_licenseInfo(NULL),
1015     m_ug(ug)
1016 {
1017     Assert(navi);
1018     m_dao.Reset();
1019 }
1020
1021 DetailView::~DetailView(void)
1022 {
1023     if (m_licenseInfo)
1024         delete m_licenseInfo;
1025 }
1026 }