internal/widget_view/widget_view_impl.cpp

   1 /*
   2  * Samsung API
   3  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Flora License, Version 1.1 (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://floralicense.org/license/
  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 // CLASS HEADER
  19 #include <internal/widget_view/widget_view_impl.h>
  20
  21 // INTERNAL INCLUDES
  22
  23 // EXTERNAL INCLUDES
  24 #include <dali/public-api/common/stage.h>
  25 #include <dali/public-api/events/touch-data.h>
  26 #include <dali/public-api/events/wheel-event.h>
  27 #include <dali/public-api/images/native-image.h>
  28 #include <dali/public-api/object/type-registry.h>
  29 #include <dali/public-api/object/type-registry-helper.h>
  30 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  31 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  32 #include <dali/integration-api/debug.h>
  33 #include <string.h>
  34 #include <Ecore_Input.h>
  35 #include <widget_service.h>
  36 #include <widget_instance.h>
  37 #include <tzplatform_config.h>
  38 #include <wayland-extension/tizen-extension-client-protocol.h>
  39 #include <aul_rsm_viewer.h>
  40
  41 namespace Dali
  42 {
  43
  44 namespace WidgetView
  45 {
  46
  47 namespace Internal
  48 {
  49
  50 namespace
  51 {
  52
  53 #define WIDGET_VIEW_RESOURCE_DEFAULT_IMG "/widget_viewer_dali/images/unknown.png"
  54
  55 #if defined(DEBUG_ENABLED)
  56 Integration::Log::Filter* gWidgetViewLogging  = Integration::Log::Filter::New( Debug::Verbose, false, "LOG_WIDGET_VIEW" );
  57 #endif
  58
  59 BaseHandle Create()
  60 {
  61   return Dali::BaseHandle();
  62 }
  63
  64 // Setup properties, signals and actions using the type-registry.
  65 DALI_TYPE_REGISTRATION_BEGIN( Dali::WidgetView::WidgetView, Toolkit::Control, Create );
  66 DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "widgetId", BOOLEAN, WIDGET_ID )
  67 DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "instanceId", BOOLEAN, INSTANCE_ID )
  68 DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "contentInfo", BOOLEAN, CONTENT_INFO )
  69 DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "title", BOOLEAN, TITLE )
  70 DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "updatePeriod", BOOLEAN, UPDATE_PERIOD )
  71 DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "preview", MAP, PREVIEW )
  72 DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "loadingText", MAP, LOADING_TEXT )
  73 DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "widgetStateFaulted", BOOLEAN, WIDGET_STATE_FAULTED )
  74 DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "permanentDelete", BOOLEAN, PERMANENT_DELETE )
  75
  76 // Signals
  77 DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetAdded", SIGNAL_WIDGET_ADDED )
  78 DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetDeleted", SIGNAL_WIDGET_DELETED )
  79 DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetCreationAborted", SIGNAL_WIDGET_CREATION_ABORTED )
  80 DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetContentUpdated", SIGNAL_WIDGET_CONTENT_UPDATED )
  81 DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetUpdatePeriodChanged", SIGNAL_WIDGET_UPDATE_PERIOD_CHANGED )
  82 DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetFaulted", SIGNAL_WIDGET_FAULTED )
  83
  84 // Actions
  85 DALI_ACTION_REGISTRATION( Dali::WidgetView, WidgetView, "pauseWidget", ACTION_WIDGETVIEW_PAUSE_WIDGET );
  86 DALI_ACTION_REGISTRATION( Dali::WidgetView, WidgetView, "resumeWidget", ACTION_WIDGETVIEW_RESUME_WIDGET );
  87 DALI_ACTION_REGISTRATION( Dali::WidgetView, WidgetView, "cancelTouchEvent", ACTION_WIDGETVIEW_CANCEL_TOUCH_EVENT );
  88 DALI_ACTION_REGISTRATION( Dali::WidgetView, WidgetView, "activateFaultedWidget", ACTION_WIDGETVIEW_ACTIVATE_FAULTED_WIDGET );
  89
  90 DALI_TYPE_REGISTRATION_END()
  91
  92 static Eina_Bool OnKeyDown( void* data, int type, void* eventInfo )
  93 {
  94   Ecore_Event_Key *event = static_cast< Ecore_Event_Key* >( eventInfo );
  95   tizen_remote_surface* surface = static_cast< tizen_remote_surface* >( data );
  96
  97   tizen_remote_surface_transfer_key_event( surface,
  98                                            TIZEN_REMOTE_SURFACE_EVENT_TYPE_KEY_DOWN,
  99                                            event->keycode,
 100                                            ecore_device_class_get(event->dev),
 101                                            ecore_device_subclass_get(event->dev),
 102                                            ecore_device_identifier_get(event->dev),
 103                                            event->timestamp
 104                                          );
 105
 106   return EINA_TRUE;
 107 }
 108
 109 static Eina_Bool OnKeyUp(void* data, int type, void* eventInfo)
 110 {
 111   Ecore_Event_Key *event = static_cast< Ecore_Event_Key* >( eventInfo );
 112   tizen_remote_surface* surface = static_cast< tizen_remote_surface* >( data );
 113
 114   tizen_remote_surface_transfer_key_event( surface,
 115                                            TIZEN_REMOTE_SURFACE_EVENT_TYPE_KEY_UP,
 116                                            event->keycode,
 117                                            ecore_device_class_get(event->dev),
 118                                            ecore_device_subclass_get(event->dev),
 119                                            ecore_device_identifier_get(event->dev),
 120                                            event->timestamp
 121                                          );
 122   return EINA_TRUE;
 123 }
 124
 125 static void OnSurfaceUpdate( struct tizen_remote_surface* surface, wl_buffer* buffer, uint32_t time, void* data )
 126 {
 127   Dali::WidgetView::Internal::WidgetView* widgetView = static_cast< Dali::WidgetView::Internal::WidgetView* >( data );
 128
 129   if( widgetView )
 130   {
 131     if( !widgetView->IsWidgetImageView() )
 132     {
 133       tizen_remote_surface_transfer_visibility( surface, TIZEN_REMOTE_SURFACE_VISIBILITY_TYPE_VISIBLE);
 134
 135       widgetView->CreateWidgetImageView();
 136       widgetView->ConnectSignal( surface );
 137       ecore_event_handler_add( ECORE_EVENT_KEY_DOWN, OnKeyDown, surface );
 138       ecore_event_handler_add( ECORE_EVENT_KEY_UP, OnKeyUp, surface );
 139     }
 140
 141     //get tbm surface from buffer
 142     tbm_surface_h tbmSurface = static_cast< tbm_surface_h >( wl_buffer_get_user_data( buffer ) );
 143     widgetView->UpdateImageSource( tbmSurface );
 144   }
 145 }
 146
 147 static void OnSurfaceMissing( struct tizen_remote_surface* surface, void* data )
 148 {
 149   //ToDo: WidgetDeletedSignal
 150 }
 151
 152
 153 static struct aul_rsm_handler_s remoteSurfaceHandler = {
 154   OnSurfaceUpdate,
 155   OnSurfaceMissing,
 156 };
 157
 158 } // unnamed namespace
 159
 160 Dali::WidgetView::WidgetView WidgetView::New( const std::string& widgetId, const std::string& contentInfo, int width, int height, float updatePeriod )
 161 {
 162   // Create the implementation, temporarily owned on stack
 163   IntrusivePtr< WidgetView > internalWidgetView = new WidgetView( widgetId, contentInfo, width, height, updatePeriod );
 164
 165   // Pass ownership to CustomActor
 166   Dali::WidgetView::WidgetView widgetView( *internalWidgetView );
 167
 168   // Second-phase init of the implementation
 169   // This can only be done after the CustomActor connection has been made...
 170   internalWidgetView->Initialize();
 171
 172   return widgetView;
 173 }
 174
 175 WidgetView::WidgetView()
 176 : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS ) ),
 177   mWidgetId(),
 178   mInstanceId(),
 179   mContentInfo(),
 180   mTitle(),
 181   mBundle( NULL ),
 182   mWidth( 0 ),
 183   mHeight( 0 ),
 184   mPid( 0 ),
 185   mUpdatePeriod( 0.0 ),
 186   mPreviewVisible( true ),
 187   mStateTextVisible( true ),
 188   mPermanentDelete( true ),
 189   mRemoteSurface( NULL )
 190 {
 191 }
 192
 193 WidgetView::WidgetView( const std::string& widgetId, const std::string& contentInfo, int width, int height, float updatePeriod )
 194 : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS ) ),
 195   mWidgetId( widgetId ),
 196   mInstanceId(),
 197   mContentInfo( contentInfo ),
 198   mTitle(),
 199   mBundle( NULL ),
 200   mWidth( width ),
 201   mHeight( height ),
 202   mPid( 0 ),
 203   mUpdatePeriod( updatePeriod ),
 204   mPreviewVisible( true ),
 205   mStateTextVisible( true ),
 206   mPermanentDelete( true ),
 207   mRemoteSurface( NULL )
 208 {
 209 }
 210
 211 WidgetView::~WidgetView()
 212 {
 213   if( !mWidgetId.empty() && !mInstanceId.empty() )
 214   {
 215     widget_instance_terminate( mInstanceId.c_str() );
 216
 217     if( mPermanentDelete )
 218     {
 219       widget_instance_destroy( mInstanceId.c_str() );
 220     }
 221   }
 222
 223   if( mBundle )
 224   {
 225     bundle_free( mBundle );
 226   }
 227 }
 228
 229 bool WidgetView::PauseWidget()
 230 {
 231   int ret = widget_instance_pause( mInstanceId.c_str() );
 232   if( ret < 0 )
 233   {
 234     DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::PauseWidget: Fail to pause widget(%s, %s) [%d]\n", mWidgetId.c_str(), mInstanceId.c_str(), ret );
 235     return false;
 236   }
 237
 238   DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::PauseWidget: Widget is paused (%s, %s)\n", mWidgetId.c_str(), mInstanceId.c_str() );
 239
 240   return true;
 241 }
 242
 243 bool WidgetView::ResumeWidget()
 244 {
 245   int ret = widget_instance_resume( mInstanceId.c_str() );
 246   if( ret < 0 )
 247   {
 248     DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::ResumeWidget: Fail to resume widget(%s, %s) [%d]\n", mWidgetId.c_str(), mInstanceId.c_str(), ret );
 249     return false;
 250   }
 251
 252   DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::ResumeWidget: Widget is resumed (%s, %s)\n", mWidgetId.c_str(), mInstanceId.c_str() );
 253
 254   return true;
 255 }
 256
 257 const std::string& WidgetView::GetWidgetId() const
 258 {
 259   return mWidgetId;
 260 }
 261
 262 const std::string& WidgetView::GetInstanceId() const
 263 {
 264   return mInstanceId;
 265 }
 266
 267 const std::string& WidgetView::GetContentInfo()
 268 {
 269   widget_instance_h instance;
 270   char* contentInfo = NULL;
 271
 272   mContentInfo.clear();
 273
 274   if( mWidgetId.empty() || mInstanceId.empty() )
 275   {
 276     DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::GetContentInfo: Widget id (%s) or instance id (%s) is invalid.\n", mWidgetId.c_str(), mInstanceId.c_str() );
 277     return mContentInfo;
 278   }
 279
 280   instance = widget_instance_get_instance( mWidgetId.c_str(), mInstanceId.c_str() );
 281   if( !instance )
 282   {
 283     DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::GetContentInfo: widget_instance_get_instance is failed. [%s]\n", mInstanceId.c_str() );
 284     return mContentInfo;
 285   }
 286
 287   if( widget_instance_get_content( instance, &contentInfo ) < 0 )
 288   {
 289     DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::GetContentInfo: Failed to get content of widget. [%s]\n", mInstanceId.c_str() );
 290     return mContentInfo;
 291   }
 292
 293   mContentInfo = reinterpret_cast< char* >( contentInfo );
 294
 295   return mContentInfo;
 296 }
 297
 298 const std::string& WidgetView::GetTitle()
 299 {
 300   //ToDo: We should add some codes by considering widget_viewer_evas
 301   if( mTitle.empty() )
 302   {
 303     mTitle = widget_service_get_name( mWidgetId.c_str(), NULL );
 304   }
 305
 306   DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::GetTitle: title = %s\n", mTitle.c_str() );
 307
 308   return mTitle;
 309 }
 310
 311 float WidgetView::GetUpdatePeriod() const
 312 {
 313   return mUpdatePeriod;
 314 }
 315
 316 bool WidgetView::CancelTouchEvent()
 317 {
 318   if( mRemoteSurface )
 319   {
 320     tizen_remote_surface_transfer_touch_cancel( mRemoteSurface );
 321     return true;
 322   }
 323
 324   return false;
 325 }
 326
 327 void WidgetView::ShowPreview( bool show )
 328 {
 329   if( mPreviewImage && show != mPreviewVisible )
 330   {
 331     mPreviewVisible = show;
 332     mPreviewImage.SetVisible( show );
 333   }
 334 }
 335
 336 bool WidgetView::IsPreviewVisible()
 337 {
 338   return mPreviewVisible;
 339 }
 340
 341 void WidgetView::ShowStateText( bool show )
 342 {
 343   if( mStateText && mStateTextVisible != show )
 344   {
 345     mStateTextVisible = show;
 346     mStateText.SetVisible( show );
 347   }
 348 }
 349
 350 bool WidgetView::IsStateTextVisible()
 351 {
 352   return mStateTextVisible;
 353 }
 354
 355 void WidgetView::ActivateFaultedWidget()
 356 {
 357   if( mPid < 0 )
 358   {
 359     // Esable preview and text
 360     if( mPreviewVisible )
 361     {
 362       mPreviewImage.SetVisible( true );
 363     }
 364
 365     if( mStateTextVisible )
 366     {
 367       mStateText.SetVisible( true );
 368     }
 369
 370     // launch widget again
 371     mPid = widget_instance_launch( mInstanceId.c_str(), (char *)mContentInfo.c_str(), mWidth, mHeight );
 372     if( mPid < 0)
 373     {
 374       DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::ActivateFaultedWidget: widget_instance_launch is failed. [%s]\n", mWidgetId.c_str() );
 375
 376       // Emit signal
 377       Dali::WidgetView::WidgetView handle( GetOwner() );
 378       mWidgetCreationAbortedSignal.Emit( handle );
 379
 380       return;
 381     }
 382
 383     DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::ActivateFaultedWidget: widget_instance_launch is called. [%s, mPid = %d]\n", mWidgetId.c_str(), mPid );
 384   }
 385 }
 386
 387 bool WidgetView::IsWidgetFaulted()
 388 {
 389   return mPid < 0 ? true : false;
 390 }
 391
 392 void WidgetView::SetPermanentDelete( bool permanentDelete )
 393 {
 394   mPermanentDelete = permanentDelete;
 395 }
 396
 397 bool WidgetView::IsPermanentDelete()
 398 {
 399   return mPermanentDelete;
 400 }
 401
 402 void WidgetView::CreateWidgetImageView()
 403 {
 404   Any source;
 405   mImageSource = Dali::NativeImageSource::New( source );
 406   Dali::NativeImage image = Dali::NativeImage::New( *mImageSource );
 407
 408   mWidgetImageView = Dali::Toolkit::ImageView::New( image );
 409
 410   mWidgetImageView.SetParentOrigin( ParentOrigin::CENTER );
 411   mWidgetImageView.SetAnchorPoint( AnchorPoint::CENTER );
 412   mWidgetImageView.SetSize( mWidth, mHeight );
 413
 414   Self().Add( mWidgetImageView );
 415
 416   // Disable preview and text
 417   if( mPreviewVisible )
 418   {
 419     mPreviewImage.SetVisible( false );
 420   }
 421
 422   if( mStateTextVisible )
 423   {
 424     mStateText.SetVisible( false );
 425   }
 426
 427   // Emit signal
 428   Dali::WidgetView::WidgetView handle( GetOwner() );
 429   mWidgetAddedSignal.Emit( handle );
 430
 431   DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::AddObjectView: ObjectView is added.\n" );
 432 }
 433
 434 void WidgetView::RemoveObjectView()
 435 {
 436   // Enable preview and text
 437   if( mPreviewVisible )
 438   {
 439     mPreviewImage.SetVisible( true );
 440   }
 441
 442   if( mStateTextVisible )
 443   {
 444     mStateText.SetVisible( true );
 445   }
 446
 447   // Emit signal
 448   Dali::WidgetView::WidgetView handle( GetOwner() );
 449   mWidgetDeletedSignal.Emit( handle );
 450
 451   mWidgetImageView.Reset();
 452
 453   DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::RemoveObjectView: ObjectView is removed.\n" );
 454 }
 455
 456 void WidgetView::SendWidgetEvent( int event )
 457 {
 458   Dali::WidgetView::WidgetView handle( GetOwner() );
 459
 460   DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::SendWidgetEvent: event = %d widget = %s\n", event,  mWidgetId.c_str() );
 461
 462   // Emit signal
 463   switch( event )
 464   {
 465     case WIDGET_INSTANCE_EVENT_UPDATE:
 466     {
 467       mWidgetContentUpdatedSignal.Emit( handle );
 468       break;
 469     }
 470     case WIDGET_INSTANCE_EVENT_PERIOD_CHANGED:
 471     {
 472       mWidgetUpdatePeriodChangedSignal.Emit( handle );
 473       break;
 474     }
 475     case WIDGET_INSTANCE_EVENT_FAULT:
 476     {
 477       mWidgetFaultedSignal.Emit( handle );
 478       break;
 479     }
 480     default:
 481     {
 482       break;
 483     }
 484   }
 485 }
 486
 487 bool WidgetView::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 488 {
 489   Dali::BaseHandle handle( object );
 490
 491   bool connected( true );
 492   Dali::WidgetView::WidgetView widgetView = Dali::WidgetView::WidgetView::DownCast( handle );
 493
 494   if( strcmp( signalName.c_str(), SIGNAL_WIDGET_ADDED ) == 0 )
 495   {
 496     widgetView.WidgetAddedSignal().Connect( tracker, functor );
 497   }
 498   else if( strcmp( signalName.c_str(), SIGNAL_WIDGET_DELETED ) == 0 )
 499   {
 500     widgetView.WidgetDeletedSignal().Connect( tracker, functor );
 501   }
 502   else if( strcmp( signalName.c_str(), SIGNAL_WIDGET_CREATION_ABORTED ) == 0 )
 503   {
 504     widgetView.WidgetCreationAbortedSignal().Connect( tracker, functor );
 505   }
 506   else if( strcmp( signalName.c_str(), SIGNAL_WIDGET_CONTENT_UPDATED ) == 0 )
 507   {
 508     widgetView.WidgetContentUpdatedSignal().Connect( tracker, functor );
 509   }
 510   else if( strcmp( signalName.c_str(), SIGNAL_WIDGET_UPDATE_PERIOD_CHANGED ) == 0 )
 511   {
 512     widgetView.WidgetUpdatePeriodChangedSignal().Connect( tracker, functor );
 513   }
 514   else if( strcmp( signalName.c_str(), SIGNAL_WIDGET_FAULTED ) == 0 )
 515   {
 516     widgetView.WidgetFaultedSignal().Connect( tracker, functor );
 517   }
 518   else
 519   {
 520     // signalName does not match any signal
 521     connected = false;
 522   }
 523
 524   return connected;
 525 }
 526
 527 bool WidgetView::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& attributes )
 528 {
 529   bool ret = true;
 530
 531   Dali::BaseHandle handle( object );
 532   Dali::WidgetView::WidgetView widgetView = Dali::WidgetView::WidgetView::DownCast( handle );
 533
 534   if( !widgetView )
 535   {
 536     return false;
 537   }
 538
 539   WidgetView& impl = GetImplementation( widgetView );
 540
 541   if( strcmp( actionName.c_str(), ACTION_WIDGETVIEW_PAUSE_WIDGET ) == 0 )
 542   {
 543     impl.PauseWidget();
 544   }
 545   else if( strcmp( actionName.c_str(), ACTION_WIDGETVIEW_RESUME_WIDGET ) == 0 )
 546   {
 547     impl.ResumeWidget();
 548   }
 549   else if( strcmp( actionName.c_str(), ACTION_WIDGETVIEW_CANCEL_TOUCH_EVENT ) == 0 )
 550   {
 551     impl.CancelTouchEvent();
 552   }
 553   else if( strcmp( actionName.c_str(), ACTION_WIDGETVIEW_ACTIVATE_FAULTED_WIDGET ) == 0 )
 554   {
 555     impl.ActivateFaultedWidget();
 556   }
 557   else
 558   {
 559     ret = false;
 560   }
 561
 562   return ret;
 563 }
 564
 565 void WidgetView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
 566 {
 567   Dali::WidgetView::WidgetView widgetView = Dali::WidgetView::WidgetView::DownCast( Dali::BaseHandle( object ) );
 568
 569   if( widgetView )
 570   {
 571     WidgetView& impl = GetImplementation( widgetView );
 572
 573     switch( index )
 574     {
 575       case Dali::WidgetView::WidgetView::Property::PREVIEW:
 576       {
 577         bool previewEnabled;
 578         if( value.Get( previewEnabled ) )
 579         {
 580           impl.ShowPreview( previewEnabled );
 581         }
 582         break;
 583       }
 584       case Dali::WidgetView::WidgetView::Property::LOADING_TEXT:
 585       {
 586         bool textEnabled;
 587         if( value.Get( textEnabled ) )
 588         {
 589           impl.ShowStateText( textEnabled );
 590         }
 591         break;
 592       }
 593       case Dali::WidgetView::WidgetView::Property::PERMANENT_DELETE:
 594       {
 595         bool del;
 596         if( value.Get( del ) )
 597         {
 598           impl.SetPermanentDelete( del );
 599         }
 600         break;
 601       }
 602     }
 603   }
 604 }
 605
 606 Property::Value WidgetView::GetProperty( BaseObject* object, Property::Index index )
 607 {
 608   Property::Value value;
 609   Dali::WidgetView::WidgetView widgetView = Dali::WidgetView::WidgetView::DownCast( Dali::BaseHandle( object ) );
 610
 611   if( widgetView )
 612   {
 613     WidgetView& impl = GetImplementation( widgetView );
 614
 615     switch( index )
 616     {
 617       case Dali::WidgetView::WidgetView::Property::WIDGET_ID:
 618       {
 619         value = impl.GetWidgetId();
 620         break;
 621       }
 622       case Dali::WidgetView::WidgetView::Property::INSTANCE_ID:
 623       {
 624         value = impl.GetInstanceId();
 625         break;
 626       }
 627       case Dali::WidgetView::WidgetView::Property::CONTENT_INFO:
 628       {
 629         value = impl.GetContentInfo();
 630         break;
 631       }
 632       case Dali::WidgetView::WidgetView::Property::TITLE:
 633       {
 634         value = impl.GetTitle();
 635         break;
 636       }
 637       case Dali::WidgetView::WidgetView::Property::UPDATE_PERIOD:
 638       {
 639         value = impl.GetUpdatePeriod();
 640         break;
 641       }
 642       case Dali::WidgetView::WidgetView::Property::PREVIEW:
 643       {
 644         value = impl.IsPreviewVisible();
 645         break;
 646       }
 647       case Dali::WidgetView::WidgetView::Property::LOADING_TEXT:
 648       {
 649         value = impl.IsStateTextVisible();
 650         break;
 651       }
 652       case Dali::WidgetView::WidgetView::Property::WIDGET_STATE_FAULTED:
 653       {
 654         value = impl.IsWidgetFaulted();
 655         break;
 656       }
 657       case Dali::WidgetView::WidgetView::Property::PERMANENT_DELETE:
 658       {
 659         value = impl.IsPermanentDelete();
 660         break;
 661       }
 662     }
 663   }
 664
 665   return value;
 666 }
 667
 668 Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetAddedSignal()
 669 {
 670   return mWidgetAddedSignal;
 671 }
 672
 673 Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetDeletedSignal()
 674 {
 675   return mWidgetDeletedSignal;
 676 }
 677
 678 Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetCreationAbortedSignal()
 679 {
 680   return mWidgetCreationAbortedSignal;
 681 }
 682
 683 Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetContentUpdatedSignal()
 684 {
 685   return mWidgetContentUpdatedSignal;
 686 }
 687
 688 Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetUpdatePeriodChangedSignal()
 689 {
 690   return mWidgetUpdatePeriodChangedSignal;
 691 }
 692
 693 Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetFaultedSignal()
 694 {
 695   return mWidgetFaultedSignal;
 696 }
 697
 698 void WidgetView::OnInitialize()
 699 {
 700   char* instanceId = NULL;
 701   char* previewPath = NULL;
 702   std::string previewImage;
 703   widget_size_type_e sizeType;
 704
 705   int ret = widget_instance_create( mWidgetId.c_str(), &instanceId );
 706   if( ret < 0 || !instanceId )
 707   {
 708     DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::OnInitialize: widget_instance_create is failed [%s].\n", mWidgetId.c_str() );
 709     return;
 710   }
 711
 712   DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::OnInitialize: widget_instance_create is called. [widget id = %s, instance id = %s]\n",
 713                  mWidgetId.c_str(), instanceId );
 714
 715   mInstanceId = instanceId;
 716
 717   // Preview image
 718   widget_service_get_size_type( mWidth, mHeight, &sizeType );
 719
 720   previewPath = widget_service_get_preview_image_path( mWidgetId.c_str(), sizeType );
 721   if( previewPath )
 722   {
 723     previewImage = previewPath;
 724     free( previewPath );
 725   }
 726   else
 727   {
 728     previewImage = tzplatform_getenv( TZ_SYS_SHARE );
 729     previewImage.append( WIDGET_VIEW_RESOURCE_DEFAULT_IMG );
 730   }
 731
 732   DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::OnInitialize: preview image path = %s\n", previewImage.c_str() );
 733
 734   mPreviewImage = Toolkit::ImageView::New( previewImage );
 735
 736   mPreviewImage.SetParentOrigin( ParentOrigin::CENTER );
 737   mPreviewImage.SetAnchorPoint( AnchorPoint::CENTER );
 738
 739   if( !previewPath )
 740   {
 741     mPreviewImage.SetSize( mWidth, mHeight );
 742   }
 743
 744   Self().SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::ALL_DIMENSIONS );
 745   Self().Add( mPreviewImage );
 746
 747   // State text
 748   // TODO: use po files
 749   mStateText = Toolkit::TextLabel::New( "Loading..." );
 750
 751   mStateText.SetParentOrigin( ParentOrigin::CENTER );
 752   mStateText.SetAnchorPoint( AnchorPoint::CENTER );
 753   mStateText.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
 754   mStateText.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
 755
 756   mPreviewImage.Add( mStateText );
 757
 758   // launch widget
 759   mPid = widget_instance_launch( instanceId, (char *)mContentInfo.c_str(), mWidth, mHeight );
 760   if( mPid < 0)
 761   {
 762     DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::OnInitialize: widget_instance_launch is failed. [%s]\n", mWidgetId.c_str() );
 763
 764     // Emit signal
 765     Dali::WidgetView::WidgetView handle( GetOwner() );
 766     mWidgetCreationAbortedSignal.Emit( handle );
 767
 768     return;
 769   }
 770
 771   aul_rsm_viewer_set_surface_handler( mInstanceId.c_str(), &remoteSurfaceHandler, this );
 772
 773   DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::OnInitialize: widget_instance_launch is called. [%s, mPid = %d]\n", mWidgetId.c_str(), mPid );
 774
 775 }
 776
 777 void WidgetView::OnStageConnection( int depth )
 778 {
 779   Control::OnStageConnection( depth );
 780 }
 781
 782 void WidgetView::OnStageDisconnection()
 783 {
 784   Control::OnStageDisconnection();
 785 }
 786
 787 void WidgetView::OnSizeSet( const Vector3& targetSize )
 788 {
 789   if( mWidgetImageView )
 790   {
 791     mWidgetImageView.SetSize( targetSize );
 792   }
 793 }
 794
 795 bool WidgetView::IsWidgetImageView()
 796 {
 797   return ( mWidgetImageView )? true: false;
 798 }
 799
 800 void WidgetView::UpdateImageSource( tbm_surface_h source )
 801 {
 802   mImageSource->SetSource( source );
 803   Dali::Stage::GetCurrent().KeepRendering( 0.0f );
 804 }
 805
 806 void WidgetView::ConnectSignal( tizen_remote_surface* surface )
 807 {
 808   if( mWidgetImageView )
 809   {
 810     mRemoteSurface = surface;
 811
 812     Self().TouchSignal().Connect( this, &WidgetView::OnTouch );
 813     Self().WheelEventSignal().Connect( this, &WidgetView::OnWheelEvent );
 814   }
 815
 816 }
 817
 818 bool WidgetView::OnTouch( Dali::Actor actor, const Dali::TouchData& event )
 819 {
 820   tizen_remote_surface_event_type type = TIZEN_REMOTE_SURFACE_EVENT_TYPE_NONE;
 821
 822   if( event.GetPointCount() == 0 )
 823   {
 824     return false;
 825   }
 826
 827   switch( event.GetState( 0 ) )
 828   {
 829     case Dali::PointState::UP:
 830     {
 831       type = TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_UP;
 832       break;
 833     }
 834     case Dali::PointState::DOWN:
 835     {
 836       type = TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_DOWN;
 837       break;
 838     }
 839     case Dali::PointState::MOTION:
 840     {
 841       type = TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_MOVE;
 842       break;
 843     }
 844     default:
 845     {
 846       return false;
 847     }
 848   }
 849
 850   int button = 1;
 851
 852   if( type == TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_MOVE )
 853   {
 854     button = 0 ;
 855   }
 856
 857   Vector2 localPos = event.GetLocalPosition( 0 );
 858
 859   tizen_remote_surface_transfer_mouse_event( mRemoteSurface,
 860                                              type,
 861                                              0,
 862                                              button,
 863                                              (int)localPos.x,
 864                                              (int)localPos.y,
 865                                              wl_fixed_from_double( event.GetEllipseRadius( 0 ).x ),
 866                                              wl_fixed_from_double( event.GetEllipseRadius( 0 ).y ),
 867                                              wl_fixed_from_double( event.GetPressure( 0 ) ),
 868                                              wl_fixed_from_double( event.GetAngle( 0 ).degree ),
 869                                              TIZEN_INPUT_DEVICE_CLAS_TOUCHSCREEN,
 870                                              TIZEN_INPUT_DEVICE_SUBCLAS_NONE,
 871                                              "",
 872                                              event.GetTime()
 873                                            );
 874   return true;
 875 }
 876
 877 bool WidgetView::OnWheelEvent( Dali::Actor actor, const Dali::WheelEvent& event )
 878 {
 879   //ToDo: We should check TIZEN_INPUT_DEVICE_CLAS_MOUSE
 880   tizen_remote_surface_transfer_mouse_wheel( mRemoteSurface,
 881                                              event.direction,
 882                                              event.z,
 883                                              TIZEN_INPUT_DEVICE_CLAS_MOUSE,
 884                                              TIZEN_INPUT_DEVICE_SUBCLAS_NONE,
 885                                              "",
 886                                              event.timeStamp
 887                                            );
 888   return true;
 889 }
 890
 891 Vector3 WidgetView::GetNaturalSize()
 892 {
 893   Vector3 size;
 894   size.x = mWidth;
 895   size.y = mHeight;
 896
 897   if( size.x > 0 && size.y > 0 )
 898   {
 899     size.z = std::min( size.x, size.y );
 900     return size;
 901   }
 902   else
 903   {
 904     return Control::GetNaturalSize();
 905   }
 906 }
 907
 908 float WidgetView::GetHeightForWidth( float width )
 909 {
 910   if( mWidth > 0 && mHeight > 0 )
 911   {
 912     return GetHeightForWidthBase( width );
 913   }
 914   else
 915   {
 916     return Control::GetHeightForWidthBase( width );
 917   }
 918 }
 919
 920 float WidgetView::GetWidthForHeight( float height )
 921 {
 922   if( mWidth > 0 && mHeight > 0 )
 923   {
 924     return GetWidthForHeightBase( height );
 925   }
 926   else
 927   {
 928     return Control::GetWidthForHeightBase( height );
 929   }
 930 }
 931
 932 } // namespace Internal
 933
 934 } // namespace WidgetView
 935
 936 } // namespace Dali