X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=internal%2Fwidget_view%2Fwidget_view_impl.cpp;h=166da2d505448d506e2aaf27467264b6e63de82f;hb=83a51b89cb51a0e1c56972647d7280aae05d8400;hp=448e8d9b7f624356ff47d92b0837984437547131;hpb=bdbfb0ac72698073eb5cbdaa9c54d79a23f877ea;p=platform%2Fcore%2Fuifw%2Fwidget-viewer-dali.git diff --git a/internal/widget_view/widget_view_impl.cpp b/internal/widget_view/widget_view_impl.cpp index 448e8d9..166da2d 100644 --- a/internal/widget_view/widget_view_impl.cpp +++ b/internal/widget_view/widget_view_impl.cpp @@ -21,11 +21,24 @@ // INTERNAL INCLUDES // EXTERNAL INCLUDES +#include +#include +#include +#include +#include +#include +#include +#include #include #include +#include #include #include #include +#include +#include +#include +#include namespace Dali { @@ -39,15 +52,120 @@ namespace Internal namespace { -#define WIDGET_VIEW_RESOURCE_DEFAULT_IMG "/widget_viewer_dali/images/unknown.png" +const int DEFAULT_FONT_PIXEL_SIZE = 30; // Referred platform widget viewer evas + +#define GET_LOCALE_TEXT(string) dgettext(PKGNAME, string) #if defined(DEBUG_ENABLED) Integration::Log::Filter* gWidgetViewLogging = Integration::Log::Filter::New( Debug::Verbose, false, "LOG_WIDGET_VIEW" ); #endif +BaseHandle Create() +{ + return Dali::BaseHandle(); +} + +// Setup properties, signals and actions using the type-registry. +DALI_TYPE_REGISTRATION_BEGIN( Dali::WidgetView::WidgetView, Toolkit::Control, Create ); +DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "widgetId", BOOLEAN, WIDGET_ID ) +DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "instanceId", BOOLEAN, INSTANCE_ID ) +DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "contentInfo", BOOLEAN, CONTENT_INFO ) +DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "title", BOOLEAN, TITLE ) +DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "updatePeriod", BOOLEAN, UPDATE_PERIOD ) +DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "preview", MAP, PREVIEW ) +DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "loadingText", MAP, LOADING_TEXT ) +DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "widgetStateFaulted", BOOLEAN, WIDGET_STATE_FAULTED ) +DALI_PROPERTY_REGISTRATION( Dali::WidgetView, WidgetView, "permanentDelete", BOOLEAN, PERMANENT_DELETE ) + +// Internal property +// ToDo it should be changed public property. +const int TERMINATE_WIDGET = Dali::WidgetView::WidgetView::Property::PERMANENT_DELETE+1; +const int RETRY_TEXT = TERMINATE_WIDGET+1; +const int WIDGET_IMAGE = RETRY_TEXT+1; + +Dali::PropertyRegistration internalProperty1( typeRegistration, "terminateWidget", TERMINATE_WIDGET, Property::BOOLEAN, Dali::WidgetView::Internal::WidgetView::SetProperty, Dali::WidgetView::Internal::WidgetView::GetProperty ); +Dali::PropertyRegistration internalProperty2( typeRegistration, "retryText", RETRY_TEXT, Property::MAP, Dali::WidgetView::Internal::WidgetView::SetProperty, Dali::WidgetView::Internal::WidgetView::GetProperty ); +Dali::PropertyRegistration internalProperty3( typeRegistration, "widgetImage", WIDGET_IMAGE, Property::MAP, Dali::WidgetView::Internal::WidgetView::SetProperty, Dali::WidgetView::Internal::WidgetView::GetProperty ); + +// Signals +DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetAdded", SIGNAL_WIDGET_ADDED ) +DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetDeleted", SIGNAL_WIDGET_DELETED ) +DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetCreationAborted", SIGNAL_WIDGET_CREATION_ABORTED ) +DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetContentUpdated", SIGNAL_WIDGET_CONTENT_UPDATED ) +DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetUpdatePeriodChanged", SIGNAL_WIDGET_UPDATE_PERIOD_CHANGED ) +DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetFaulted", SIGNAL_WIDGET_FAULTED ) +DALI_SIGNAL_REGISTRATION( Dali::WidgetView, WidgetView, "widgetTerminated", SIGNAL_WIDGET_TERMINATED ) + +// Actions +DALI_ACTION_REGISTRATION( Dali::WidgetView, WidgetView, "pauseWidget", ACTION_WIDGETVIEW_PAUSE_WIDGET ); +DALI_ACTION_REGISTRATION( Dali::WidgetView, WidgetView, "resumeWidget", ACTION_WIDGETVIEW_RESUME_WIDGET ); +DALI_ACTION_REGISTRATION( Dali::WidgetView, WidgetView, "cancelTouchEvent", ACTION_WIDGETVIEW_CANCEL_TOUCH_EVENT ); +DALI_ACTION_REGISTRATION( Dali::WidgetView, WidgetView, "activateFaultedWidget", ACTION_WIDGETVIEW_ACTIVATE_FAULTED_WIDGET ); + +DALI_TYPE_REGISTRATION_END() + +struct wl_buffer* preBuffer; +struct tizen_remote_surface* remoteSurface; + +const char* const STATE_TEXT( "stateText" ); +const char* const FONT_STYLE( "fontStyle" ); +const char* const TEXT_POINT_SIZE( "textPointSize" ); +const char* const TEXT_COLOR( "textColor" ); +const char* const TEXT_VISIBLE( "textVisible" ); //ToDo: it should be removed after retry text property is public one + +static void OnBufferUpdated( struct tizen_remote_surface *surface, uint32_t type, struct wl_buffer *buffer, + int32_t img_file_fd, uint32_t img_file_size, uint32_t time, struct wl_array *keys, + const char *appid, const char *instance_id, const int pid, void *data) +{ + Dali::WidgetView::Internal::WidgetView* widgetView = static_cast< Dali::WidgetView::Internal::WidgetView* >( data ); + + if( widgetView ) + { + if( !widgetView->IsWidgetImageView() ) + { + tizen_remote_surface_transfer_visibility( surface, TIZEN_REMOTE_SURFACE_VISIBILITY_TYPE_VISIBLE); + + widgetView->CreateWidgetImageView(); + widgetView->ConnectSignal( surface ); + } + + //get tbm surface from buffer + tbm_surface_h tbmSurface = static_cast< tbm_surface_h >( wl_buffer_get_user_data( buffer ) ); + widgetView->UpdateImageSource( tbmSurface ); + } + + if( preBuffer != NULL && tizen_remote_surface_get_version( surface ) >= TIZEN_REMOTE_SURFACE_RELEASE_SINCE_VERSION ) + { + tizen_remote_surface_release( surface, preBuffer ); + tbm_surface_h preTbmSurface = (tbm_surface_h)wl_buffer_get_user_data( preBuffer ); + tbm_surface_internal_unref( preTbmSurface ); + wl_buffer_destroy( preBuffer ); + } + + remoteSurface = surface; + preBuffer = buffer; + + close( img_file_fd ); +} + +static void OnBufferAdded( const char *appid, const char *instance_id, const int pid, void *data ) +{ +} + +static void OnSurfaceRemoved( const char *appid, const char *instance_id, const int pid, void *data ) +{ + Dali::WidgetView::Internal::WidgetView* widgetView = static_cast< Dali::WidgetView::Internal::WidgetView* >( data ); + + if( widgetView && !widgetView->IsWidgetFaulted() ) + { + widgetView->CloseRemoteSurface(); + widgetView->RemoveWidgetImage(); + } +} + } // unnamed namespace -Dali::WidgetView::WidgetView WidgetView::New( const std::string& widgetId, const std::string& contentInfo, int width, int height, double updatePeriod ) +Dali::WidgetView::WidgetView WidgetView::New( const std::string& widgetId, const std::string& contentInfo, int width, int height, float updatePeriod ) { // Create the implementation, temporarily owned on stack IntrusivePtr< WidgetView > internalWidgetView = new WidgetView( widgetId, contentInfo, width, height, updatePeriod ); @@ -68,50 +186,46 @@ WidgetView::WidgetView() mInstanceId(), mContentInfo(), mTitle(), - mBundle( NULL ), mWidth( 0 ), mHeight( 0 ), mPid( 0 ), mUpdatePeriod( 0.0 ), - mPreviewEnabled( true ), - mStateTextEnabled( true ), - mPermanentDelete( true ) + mPreviewVisible( true ), + mLoadingTextVisible( true ), + mLoadingTextString(), + mRetryTextVisible( true ), + mRetryTextString(), + mRetryState( false ), + mPermanentDelete( false ), + mWatcherHandle( NULL ), + mRemoteSurface( NULL ) { } -WidgetView::WidgetView( const std::string& widgetId, const std::string& contentInfo, int width, int height, double updatePeriod ) +WidgetView::WidgetView( const std::string& widgetId, const std::string& contentInfo, int width, int height, float updatePeriod ) : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS ) ), mWidgetId( widgetId ), mInstanceId(), mContentInfo( contentInfo ), mTitle(), - mBundle( NULL ), mWidth( width ), mHeight( height ), mPid( 0 ), mUpdatePeriod( updatePeriod ), - mPreviewEnabled( true ), - mStateTextEnabled( true ), - mPermanentDelete( true ) + mPreviewVisible( true ), + mLoadingTextVisible( true ), + mLoadingTextString(), + mRetryTextVisible( true ), + mRetryTextString(), + mRetryState( false ), + mPermanentDelete( false ), + mWatcherHandle( NULL ), + mRemoteSurface( NULL ) { } WidgetView::~WidgetView() { - if( !mWidgetId.empty() && !mInstanceId.empty() ) - { - widget_instance_terminate( mInstanceId.c_str() ); - - if( mPermanentDelete ) - { - widget_instance_destroy( mInstanceId.c_str() ); - } - } - - if( mBundle ) - { - bundle_free( mBundle ); - } } bool WidgetView::PauseWidget() @@ -185,13 +299,10 @@ const std::string& WidgetView::GetContentInfo() const std::string& WidgetView::GetTitle() { - if( mObjectView ) + //ToDo: We should add some codes by considering widget_viewer_evas + if( mTitle.empty() ) { - mTitle = mObjectView.GetTitle(); - if( mTitle.empty() ) - { - mTitle = widget_service_get_name( mWidgetId.c_str(), NULL ); - } + mTitle = widget_service_get_name( mWidgetId.c_str(), NULL ); } DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::GetTitle: title = %s\n", mTitle.c_str() ); @@ -199,81 +310,83 @@ const std::string& WidgetView::GetTitle() return mTitle; } -double WidgetView::GetUpdatePeriod() const +float WidgetView::GetUpdatePeriod() const { return mUpdatePeriod; } -void WidgetView::Show() +bool WidgetView::CancelTouchEvent() { - if( mObjectView ) + if( mRemoteSurface ) { - mObjectView.Show(); + tizen_remote_surface_transfer_touch_cancel( mRemoteSurface ); + return true; } + + return false; } -void WidgetView::Hide() +void WidgetView::SetPreviewVisible( bool visible ) { - if( mObjectView ) + if( mPreviewImage && mPreviewVisible != visible ) { - mObjectView.Hide(); + mPreviewVisible = visible; + mPreviewImage.SetVisible( visible ); } } -bool WidgetView::CancelTouchEvent() +bool WidgetView::IsPreviewVisible() { - if( mObjectView ) - { - return mObjectView.CancelTouchEvent(); - } - - return false; + return mPreviewVisible; } -void WidgetView::SetPreviewEnabled( bool enabled ) +void WidgetView::SetLoadingTextVisible( bool visible ) { - mPreviewEnabled = enabled; - - if( mPreviewImage ) + if( mLoadingText && mLoadingTextVisible != visible ) { - mPreviewImage.SetVisible( enabled ); + mLoadingTextVisible = visible; + + if( visible ) + { + mLoadingText.SetProperty( Toolkit::TextLabel::Property::TEXT, + ( mLoadingTextString.empty() )? GET_LOCALE_TEXT( "IDS_ST_POP_LOADING_ING" ) : mLoadingTextString ); + } + mLoadingText.SetVisible( visible ); } } -bool WidgetView::GetPreviewEnabled() const +void WidgetView::SetRetryTextVisible( bool visible ) { - return mPreviewEnabled; + if( mRetryText && mRetryTextVisible != visible ) + { + mRetryTextVisible = visible; + + if( visible ) + { + mRetryText.SetProperty( Toolkit::TextLabel::Property::TEXT, + ( mRetryTextString.empty() )? GET_LOCALE_TEXT( "IDS_HS_BODY_UNABLE_TO_LOAD_DATA_TAP_TO_RETRY" ) : mRetryTextString ); + } + mRetryText.SetVisible( visible ); + } } -void WidgetView::SetStateTextEnabled( bool enabled ) +bool WidgetView::IsLoadingTextVisible() { - mStateTextEnabled = enabled; - - if( mStateText ) - { - mStateText.SetVisible( enabled ); - } + return mLoadingTextVisible; } -bool WidgetView::GetStateTextEnabled() const +bool WidgetView::IsRetryTextVisible() { - return mStateTextEnabled; + return mRetryTextVisible; } void WidgetView::ActivateFaultedWidget() { if( mPid < 0 ) { - // Esable preview and text - if( mPreviewEnabled ) - { - mPreviewImage.SetVisible( true ); - } - - if( mStateTextEnabled ) - { - mStateText.SetVisible( true ); - } + // Enable preview and loading text + ShowRetryState( false ); + ShowLoadingState( true ); // launch widget again mPid = widget_instance_launch( mInstanceId.c_str(), (char *)mContentInfo.c_str(), mWidth, mHeight ); @@ -281,6 +394,9 @@ void WidgetView::ActivateFaultedWidget() { DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::ActivateFaultedWidget: widget_instance_launch is failed. [%s]\n", mWidgetId.c_str() ); + ShowLoadingState( false ); + ShowRetryState( true ); + // Emit signal Dali::WidgetView::WidgetView handle( GetOwner() ); mWidgetCreationAbortedSignal.Emit( handle ); @@ -288,6 +404,12 @@ void WidgetView::ActivateFaultedWidget() return; } + screen_connector_toolkit_ops ops; + ops.updated_cb = OnBufferUpdated; + ops.removed_cb = OnSurfaceRemoved; + ops.added_cb = OnBufferAdded; + mWatcherHandle = screen_connector_toolkit_add(&ops, (char *)mInstanceId.c_str(), SCREEN_CONNECTOR_SCREEEN_TYPE_WIDGET, this); + DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::ActivateFaultedWidget: widget_instance_launch is called. [%s, mPid = %d]\n", mWidgetId.c_str(), mPid ); } } @@ -302,53 +424,82 @@ void WidgetView::SetPermanentDelete( bool permanentDelete ) mPermanentDelete = permanentDelete; } -void WidgetView::AddObjectView( Pepper::ObjectView objectView ) +bool WidgetView::IsPermanentDelete() { - mObjectView = objectView; + return mPermanentDelete; +} - mObjectView.SetParentOrigin( ParentOrigin::CENTER ); - mObjectView.SetAnchorPoint( AnchorPoint::CENTER ); +void WidgetView::CreateWidgetImageView() +{ + Any source; + mImageSource = Dali::NativeImageSource::New( source ); + Dali::NativeImage image = Dali::NativeImage::New( *mImageSource ); - Self().Add( mObjectView ); + mWidgetImageView = Dali::Toolkit::ImageView::New( image ); - // Disable preview and text - if( mPreviewEnabled ) - { - mPreviewImage.SetVisible( false ); - } + mWidgetImageView.SetParentOrigin( ParentOrigin::CENTER ); + mWidgetImageView.SetAnchorPoint( AnchorPoint::CENTER ); + mWidgetImageView.SetSize( mWidth, mHeight ); - if( mStateTextEnabled ) + if( !mWidgetImagePropertyMap.Empty() ) { - mStateText.SetVisible( false ); + mWidgetImageView.SetProperty( Toolkit::ImageView::Property::IMAGE, mWidgetImagePropertyMap ); } + Self().Add( mWidgetImageView ); + + //EFL app should be pre multiplied image. + mWidgetImageView.SetProperty( Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA, true ); + + // Disable preview and text + ShowLoadingState( false ); + // Emit signal Dali::WidgetView::WidgetView handle( GetOwner() ); mWidgetAddedSignal.Emit( handle ); - DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::AddObjectView: ObjectView is added.\n" ); + DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::CreateWidgetImageView: Widget image is added.\n" ); } -void WidgetView::RemoveObjectView() +void WidgetView::RemoveWidgetImage() { - // Enable preview and text - if( mPreviewEnabled ) + if( mWidgetImageView ) { - mPreviewImage.SetVisible( true ); + mWidgetImageView.SetVisible( false ); + mWidgetImageView.Reset(); + + ShowRetryState( true ); + + Dali::WidgetView::WidgetView handle( GetOwner() ); + mWidgetDeletedSignal.Emit( handle ); } - if( mStateTextEnabled ) + DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::RemoveWidgetImage: Widget image is removed.\n" ); +} + +void WidgetView::TerminateWidget() +{ + if( !mWidgetId.empty() && !mInstanceId.empty() ) { - mStateText.SetVisible( true ); - } + widget_instance_terminate( mInstanceId.c_str() ); - // Emit signal - Dali::WidgetView::WidgetView handle( GetOwner() ); - mWidgetDeletedSignal.Emit( handle ); + if( mPermanentDelete ) + { + widget_instance_destroy( mInstanceId.c_str() ); + } + + Dali::WidgetView::WidgetView handle( GetOwner() ); + mWidgetTerminatedSignal.Emit( handle ); + mWidgetDeletedSignal.Emit( handle ); + + mWidgetId.clear(); + mInstanceId.clear(); + + CloseRemoteSurface(); + } - mObjectView.Reset(); + DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::TerminateWidget: Widget is terminated/destroyed and deleted signal is emitted.\n" ); - DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::RemoveObjectView: ObjectView is removed.\n" ); } void WidgetView::SendWidgetEvent( int event ) @@ -361,6 +512,7 @@ void WidgetView::SendWidgetEvent( int event ) switch( event ) { case WIDGET_INSTANCE_EVENT_UPDATE: + case WIDGET_INSTANCE_EVENT_EXTRA_UPDATED: { mWidgetContentUpdatedSignal.Emit( handle ); break; @@ -370,26 +522,234 @@ void WidgetView::SendWidgetEvent( int event ) mWidgetUpdatePeriodChangedSignal.Emit( handle ); break; } - case WIDGET_INSTANCE_EVENT_SIZE_CHANGED: + case WIDGET_INSTANCE_EVENT_FAULT: { - mWidgetResizedSignal.Emit( handle ); + mWidgetFaultedSignal.Emit( handle ); + CloseRemoteSurface(); + RemoveWidgetImage(); break; } - case WIDGET_INSTANCE_EVENT_EXTRA_UPDATED: + default: { - mWidgetExtraInfoUpdatedSignal.Emit( handle ); break; } - case WIDGET_INSTANCE_EVENT_FAULT: + } +} + +bool WidgetView::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor ) +{ + Dali::BaseHandle handle( object ); + + bool connected( true ); + Dali::WidgetView::WidgetView widgetView = Dali::WidgetView::WidgetView::DownCast( handle ); + + if( strcmp( signalName.c_str(), SIGNAL_WIDGET_ADDED ) == 0 ) + { + widgetView.WidgetAddedSignal().Connect( tracker, functor ); + } + else if( strcmp( signalName.c_str(), SIGNAL_WIDGET_DELETED ) == 0 ) + { + widgetView.WidgetDeletedSignal().Connect( tracker, functor ); + } + else if( strcmp( signalName.c_str(), SIGNAL_WIDGET_CREATION_ABORTED ) == 0 ) + { + widgetView.WidgetCreationAbortedSignal().Connect( tracker, functor ); + } + else if( strcmp( signalName.c_str(), SIGNAL_WIDGET_CONTENT_UPDATED ) == 0 ) + { + widgetView.WidgetContentUpdatedSignal().Connect( tracker, functor ); + } + else if( strcmp( signalName.c_str(), SIGNAL_WIDGET_UPDATE_PERIOD_CHANGED ) == 0 ) + { + widgetView.WidgetUpdatePeriodChangedSignal().Connect( tracker, functor ); + } + else if( strcmp( signalName.c_str(), SIGNAL_WIDGET_FAULTED ) == 0 ) + { + widgetView.WidgetFaultedSignal().Connect( tracker, functor ); + } + else + { + // signalName does not match any signal + connected = false; + } + + return connected; +} + +bool WidgetView::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& attributes ) +{ + bool ret = true; + + Dali::BaseHandle handle( object ); + Dali::WidgetView::WidgetView widgetView = Dali::WidgetView::WidgetView::DownCast( handle ); + + if( !widgetView ) + { + return false; + } + + WidgetView& impl = GetImplementation( widgetView ); + + if( strcmp( actionName.c_str(), ACTION_WIDGETVIEW_PAUSE_WIDGET ) == 0 ) + { + impl.PauseWidget(); + } + else if( strcmp( actionName.c_str(), ACTION_WIDGETVIEW_RESUME_WIDGET ) == 0 ) + { + impl.ResumeWidget(); + } + else if( strcmp( actionName.c_str(), ACTION_WIDGETVIEW_CANCEL_TOUCH_EVENT ) == 0 ) + { + impl.CancelTouchEvent(); + } + else if( strcmp( actionName.c_str(), ACTION_WIDGETVIEW_ACTIVATE_FAULTED_WIDGET ) == 0 ) + { + impl.ActivateFaultedWidget(); + } + else + { + ret = false; + } + + return ret; +} + +void WidgetView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value ) +{ + Dali::WidgetView::WidgetView widgetView = Dali::WidgetView::WidgetView::DownCast( Dali::BaseHandle( object ) ); + + if( widgetView ) + { + WidgetView& impl = GetImplementation( widgetView ); + + switch( index ) { - mWidgetFaultedSignal.Emit( handle ); - break; + case Dali::WidgetView::WidgetView::Property::PREVIEW: + { + bool previewEnabled; + + if( value.Get( previewEnabled ) ) + { + impl.SetPreviewVisible( previewEnabled ); + } + break; + } + case Dali::WidgetView::WidgetView::Property::LOADING_TEXT: + { + bool textEnabled; + Property::Map map; + + if( value.Get( textEnabled ) ) + { + impl.SetLoadingTextVisible( textEnabled ); + } + else if( value.Get( map ) ) + { + impl.SetLoadingTextPropertyMap( map ); + } + break; + } + case Dali::WidgetView::WidgetView::Property::PERMANENT_DELETE: + { + bool permanent; + if( value.Get( permanent ) ) + { + impl.SetPermanentDelete( permanent ); + } + break; + } + case TERMINATE_WIDGET: + { + bool del = false; + if( value.Get( del ) && del ) + { + impl.TerminateWidget(); + } + break; + } + case RETRY_TEXT: + { + Property::Map map; + + if( value.Get( map ) ) + { + impl.SetRetryTextPropertyMap( map ); + } + break; + } + case WIDGET_IMAGE: + { + Property::Map map; + if( value.Get( map ) ) + { + impl.SetWidgetImagePropertyMap( map ); + } + break; + } } - default: + } +} + +Property::Value WidgetView::GetProperty( BaseObject* object, Property::Index index ) +{ + Property::Value value; + Dali::WidgetView::WidgetView widgetView = Dali::WidgetView::WidgetView::DownCast( Dali::BaseHandle( object ) ); + + if( widgetView ) + { + WidgetView& impl = GetImplementation( widgetView ); + + switch( index ) { - break; + case Dali::WidgetView::WidgetView::Property::WIDGET_ID: + { + value = impl.GetWidgetId(); + break; + } + case Dali::WidgetView::WidgetView::Property::INSTANCE_ID: + { + value = impl.GetInstanceId(); + break; + } + case Dali::WidgetView::WidgetView::Property::CONTENT_INFO: + { + value = impl.GetContentInfo(); + break; + } + case Dali::WidgetView::WidgetView::Property::TITLE: + { + value = impl.GetTitle(); + break; + } + case Dali::WidgetView::WidgetView::Property::UPDATE_PERIOD: + { + value = impl.GetUpdatePeriod(); + break; + } + case Dali::WidgetView::WidgetView::Property::PREVIEW: + { + value = impl.IsPreviewVisible(); + break; + } + case Dali::WidgetView::WidgetView::Property::LOADING_TEXT: + { + value = impl.IsLoadingTextVisible(); + break; + } + case Dali::WidgetView::WidgetView::Property::WIDGET_STATE_FAULTED: + { + value = impl.IsWidgetFaulted(); + break; + } + case Dali::WidgetView::WidgetView::Property::PERMANENT_DELETE: + { + value = impl.IsPermanentDelete(); + break; + } } } + + return value; } Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetAddedSignal() @@ -407,21 +767,11 @@ Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetCreationAb return mWidgetCreationAbortedSignal; } -Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetResizedSignal() -{ - return mWidgetResizedSignal; -} - Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetContentUpdatedSignal() { return mWidgetContentUpdatedSignal; } -Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetExtraInfoUpdatedSignal() -{ - return mWidgetExtraInfoUpdatedSignal; -} - Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetUpdatePeriodChangedSignal() { return mWidgetUpdatePeriodChangedSignal; @@ -432,12 +782,18 @@ Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetFaultedSig return mWidgetFaultedSignal; } +Dali::WidgetView::WidgetView::WidgetViewSignalType& WidgetView::WidgetTerminatedSignal() +{ + return mWidgetTerminatedSignal; +} + void WidgetView::OnInitialize() { char* instanceId = NULL; char* previewPath = NULL; std::string previewImage; widget_size_type_e sizeType; + screen_connector_toolkit_ops ops; int ret = widget_instance_create( mWidgetId.c_str(), &instanceId ); if( ret < 0 || !instanceId ) @@ -462,40 +818,67 @@ void WidgetView::OnInitialize() } else { - previewImage = tzplatform_getenv( TZ_SYS_SHARE ); - previewImage.append( WIDGET_VIEW_RESOURCE_DEFAULT_IMG ); + previewImage = WIDGET_VIEW_RESOURCE_DEFAULT_IMG; } DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::OnInitialize: preview image path = %s\n", previewImage.c_str() ); - mPreviewImage = Toolkit::ImageView::New( previewImage ); + mPreviewActor = Dali::Actor::New(); + mPreviewActor.SetParentOrigin( ParentOrigin::CENTER ); + mPreviewActor.SetAnchorPoint( AnchorPoint::CENTER ); + mPreviewActor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS ); + + mPreviewImage = Toolkit::ImageView::New( previewImage ); mPreviewImage.SetParentOrigin( ParentOrigin::CENTER ); mPreviewImage.SetAnchorPoint( AnchorPoint::CENTER ); - - if( !previewPath ) - { - mPreviewImage.SetSize( mWidth, mHeight ); - } - - Self().SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::ALL_DIMENSIONS ); - Self().Add( mPreviewImage ); - - // State text - // TODO: use po files - mStateText = Toolkit::TextLabel::New( "Loading..." ); - - mStateText.SetParentOrigin( ParentOrigin::CENTER ); - mStateText.SetAnchorPoint( AnchorPoint::CENTER ); - mStateText.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" ); - mStateText.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" ); - - mPreviewImage.Add( mStateText ); + mPreviewImage.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS ); + + Self().SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS ); + Self().SetSize( mWidth, mHeight ); + + Self().Add( mPreviewActor ); + mPreviewActor.Add( mPreviewImage ); + + mStateTextActor = Dali::Actor::New(); + mStateTextActor.SetParentOrigin( ParentOrigin::CENTER ); + mStateTextActor.SetAnchorPoint( AnchorPoint::CENTER ); + mStateTextActor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS ); + + // Loading text + mLoadingText = Toolkit::TextLabel::New( ( mLoadingTextString.empty() )? GET_LOCALE_TEXT( "IDS_ST_POP_LOADING_ING" ) : mLoadingTextString ); + mLoadingText.SetParentOrigin( ParentOrigin::CENTER ); + mLoadingText.SetAnchorPoint( AnchorPoint::CENTER ); + mLoadingText.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" ); + mLoadingText.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" ); + mLoadingText.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, Dali::Color::WHITE ); + mLoadingText.SetProperty( Toolkit::TextLabel::Property::FONT_STYLE, "Bold" ); + mLoadingText.SetProperty( Toolkit::TextLabel::Property::POINT_SIZE, TextPixelToPointSize( DEFAULT_FONT_PIXEL_SIZE ) ); + + mPreviewActor.Add( mStateTextActor ); + mStateTextActor.Add( mLoadingText ); + + // Retry text + mRetryText = Toolkit::TextLabel::New( ( mRetryTextString.empty() )? GET_LOCALE_TEXT( "IDS_HS_BODY_UNABLE_TO_LOAD_DATA_TAP_TO_RETRY" ) : mRetryTextString ); + mRetryText.SetParentOrigin( ParentOrigin::CENTER ); + mRetryText.SetAnchorPoint( AnchorPoint::CENTER ); + mRetryText.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" ); + mRetryText.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" ); + mRetryText.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, Dali::Color::WHITE ); + mRetryText.SetProperty( Toolkit::TextLabel::Property::FONT_STYLE, "Bold" ); + mRetryText.SetProperty( Toolkit::TextLabel::Property::POINT_SIZE, TextPixelToPointSize( DEFAULT_FONT_PIXEL_SIZE ) ); + + mStateTextActor.Add( mRetryText ); + mRetryText.SetVisible( false ); // launch widget mPid = widget_instance_launch( instanceId, (char *)mContentInfo.c_str(), mWidth, mHeight ); if( mPid < 0) { + + ShowLoadingState( false ); + ShowRetryState( true ); + DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::OnInitialize: widget_instance_launch is failed. [%s]\n", mWidgetId.c_str() ); // Emit signal @@ -505,17 +888,336 @@ void WidgetView::OnInitialize() return; } + ops.updated_cb = OnBufferUpdated; + ops.removed_cb = OnSurfaceRemoved; + ops.added_cb = OnBufferAdded; + mWatcherHandle = screen_connector_toolkit_add(&ops, (char *)instanceId, SCREEN_CONNECTOR_SCREEEN_TYPE_WIDGET, this); DALI_LOG_INFO( gWidgetViewLogging, Debug::Verbose, "WidgetView::OnInitialize: widget_instance_launch is called. [%s, mPid = %d]\n", mWidgetId.c_str(), mPid ); + +} + +void WidgetView::OnStageConnection( int depth ) +{ + Control::OnStageConnection( depth ); +} + +void WidgetView::OnStageDisconnection() +{ + Control::OnStageDisconnection(); } void WidgetView::OnSizeSet( const Vector3& targetSize ) { - if( mObjectView ) + if( mWidgetImageView ) + { + mWidgetImageView.SetSize( targetSize ); + } +} + +bool WidgetView::IsWidgetImageView() +{ + return ( mWidgetImageView )? true: false; +} + +void WidgetView::UpdateImageSource( tbm_surface_h source ) +{ + mImageSource->SetSource( source ); + Dali::Stage::GetCurrent().KeepRendering( 0.0f ); +} + +void WidgetView::ConnectSignal( tizen_remote_surface* surface ) +{ + if( mWidgetImageView && surface ) + { + mRemoteSurface = surface; + + Self().TouchSignal().Connect( this, &WidgetView::OnTouch ); + Self().WheelEventSignal().Connect( this, &WidgetView::OnWheelEvent ); + } + +} + +bool WidgetView::OnTouch( Dali::Actor actor, const Dali::TouchData& event ) +{ + tizen_remote_surface_event_type type = TIZEN_REMOTE_SURFACE_EVENT_TYPE_NONE; + + if( event.GetPointCount() == 0 ) + { + return false; + } + + switch( event.GetState( 0 ) ) + { + case Dali::PointState::UP: + { + type = TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_UP; + + if( mRetryState ) + { + ActivateFaultedWidget(); + return false; + } + + break; + } + case Dali::PointState::DOWN: + { + type = TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_DOWN; + break; + } + case Dali::PointState::MOTION: + { + type = TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_MOVE; + break; + } + default: + { + return false; + } + } + + if( mRemoteSurface == NULL ) + { + return false; + } + + int button = 1; + + if( type == TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_MOVE ) + { + button = 0 ; + } + + Vector2 localPos = event.GetLocalPosition( 0 ); + + tizen_remote_surface_transfer_mouse_event( mRemoteSurface, + type, + 0, + button, + (int)localPos.x, + (int)localPos.y, + wl_fixed_from_double( event.GetEllipseRadius( 0 ).x ), + wl_fixed_from_double( event.GetEllipseRadius( 0 ).y ), + wl_fixed_from_double( event.GetPressure( 0 ) ), + wl_fixed_from_double( event.GetAngle( 0 ).degree ), + TIZEN_INPUT_DEVICE_CLAS_TOUCHSCREEN, + TIZEN_INPUT_DEVICE_SUBCLAS_NONE, + "", + event.GetTime() + ); + return true; +} + +bool WidgetView::OnWheelEvent( Dali::Actor actor, const Dali::WheelEvent& event ) +{ + if( mRemoteSurface == NULL ) + { + return false; + } + //ToDo: We should check TIZEN_INPUT_DEVICE_CLAS_MOUSE + tizen_remote_surface_transfer_mouse_wheel( mRemoteSurface, + event.direction, + event.z, + TIZEN_INPUT_DEVICE_CLAS_MOUSE, + TIZEN_INPUT_DEVICE_SUBCLAS_NONE, + "", + event.timeStamp + ); + return true; +} + +Vector3 WidgetView::GetNaturalSize() +{ + Vector3 size; + size.x = mWidth; + size.y = mHeight; + + if( size.x > 0 && size.y > 0 ) + { + size.z = std::min( size.x, size.y ); + return size; + } + else + { + return Control::GetNaturalSize(); + } +} + +float WidgetView::GetHeightForWidth( float width ) +{ + if( mWidth > 0 && mHeight > 0 ) + { + return GetHeightForWidthBase( width ); + } + else + { + return Control::GetHeightForWidthBase( width ); + } +} + +float WidgetView::GetWidthForHeight( float height ) +{ + if( mWidth > 0 && mHeight > 0 ) + { + return GetWidthForHeightBase( height ); + } + else + { + return Control::GetWidthForHeightBase( height ); + } +} + +void WidgetView::CloseRemoteSurface() +{ + if( mWatcherHandle != NULL ) + { + if( remoteSurface != NULL && preBuffer != NULL && tizen_remote_surface_get_version( remoteSurface ) >= TIZEN_REMOTE_SURFACE_RELEASE_SINCE_VERSION ) + { + tizen_remote_surface_release( remoteSurface, preBuffer ); + tbm_surface_h preTbmSurface = (tbm_surface_h)wl_buffer_get_user_data( preBuffer ); + tbm_surface_internal_unref( preTbmSurface ); + wl_buffer_destroy( preBuffer ); + preBuffer = NULL; + } + + screen_connector_toolkit_remove( mWatcherHandle ); + mWatcherHandle = NULL; + mRemoteSurface = NULL; + mPid = -1; + } +} + +void WidgetView::ShowLoadingState( bool show ) +{ + if( mPreviewImage && mPreviewVisible ) + { + mPreviewImage.SetVisible( show ); + } + + if( mLoadingText && mLoadingTextVisible ) + { + mLoadingText.SetProperty( Toolkit::TextLabel::Property::TEXT, + ( mLoadingTextString.empty() )? GET_LOCALE_TEXT( "IDS_ST_POP_LOADING_ING" ) : mLoadingTextString ); + mLoadingText.SetVisible( show ); + } +} + +void WidgetView::ShowRetryState( bool show ) +{ + if( mPreviewImage && mPreviewVisible ) { - mObjectView.SetSize( targetSize ); + mPreviewImage.SetVisible( false ); + } + + if( mRetryText && mRetryTextVisible ) + { + mRetryText.SetProperty( Toolkit::TextLabel::Property::TEXT, + ( mRetryTextString.empty() )? GET_LOCALE_TEXT( "IDS_HS_BODY_UNABLE_TO_LOAD_DATA_TAP_TO_RETRY" ) : mRetryTextString ); + mRetryText.SetVisible( show ); + mRetryState = show; } } +void WidgetView::SetLoadingTextPropertyMap( Property::Map map ) +{ + if( mLoadingText ) + { + Property::Value* loadingText = map.Find( STATE_TEXT ); + std::string text; + if( loadingText && loadingText->Get( text ) ) + { + mLoadingText.SetProperty( Toolkit::TextLabel::Property::TEXT, text ); + mLoadingTextString = text; + } + + Property::Value* fontStyle = map.Find( FONT_STYLE ); + std::string style; + + if( fontStyle && fontStyle->Get( style ) ) + { + mLoadingText.SetProperty( Toolkit::TextLabel::Property::FONT_STYLE, style ); + } + + Property::Value* textPointSize = map.Find( TEXT_POINT_SIZE ); + float size = 0.f; + + if( textPointSize && textPointSize->Get( size ) ) + { + mLoadingText.SetProperty( Toolkit::TextLabel::Property::POINT_SIZE, size ); + } + + Property::Value* textColor = map.Find( TEXT_COLOR ); + Vector4 color; + + if( textColor && textColor->Get( color ) ) + { + mLoadingText.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, color ); + } + } +} + +void WidgetView::SetRetryTextPropertyMap( Property::Map map ) +{ + if( mRetryText ) + { + Property::Value* retryText = map.Find( STATE_TEXT ); + std::string text; + if( retryText && retryText->Get( text ) ) + { + mRetryText.SetProperty( Toolkit::TextLabel::Property::TEXT, text ); + mRetryTextString = text; + } + + Property::Value* fontStyle = map.Find( FONT_STYLE ); + std::string style; + + if( fontStyle && fontStyle->Get( style ) ) + { + mRetryText.SetProperty( Toolkit::TextLabel::Property::FONT_STYLE, style ); + } + + Property::Value* textPointSize = map.Find( TEXT_POINT_SIZE ); + float size = 0.f; + + if( textPointSize && textPointSize->Get( size ) ) + { + mRetryText.SetProperty( Toolkit::TextLabel::Property::POINT_SIZE, size ); + } + + Property::Value* textColor = map.Find( TEXT_COLOR ); + Vector4 color; + + if( textColor && textColor->Get( color ) ) + { + mRetryText.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, color ); + } + + Property::Value* textVisible = map.Find( TEXT_VISIBLE ); + bool visible = true; + if( textVisible && textVisible->Get( visible ) ) + { + SetRetryTextVisible( visible ); + } + } +} + +void WidgetView::SetWidgetImagePropertyMap( Property::Map map ) +{ + mWidgetImagePropertyMap = map; + if( mWidgetImageView ) + { + mWidgetImageView.SetProperty( Toolkit::ImageView::Property::IMAGE, map ); + } +} + +float WidgetView::TextPixelToPointSize( int pixelSize ) +{ + Dali::Vector2 dpi = Dali::Stage::GetCurrent().GetDpi(); + float meanDpi = (dpi.height + dpi.width) / 2.0f; + + return (pixelSize * 72.0f) / meanDpi; +} + } // namespace Internal } // namespace WidgetView