X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Ftext%2Ftext-visual.cpp;h=55b1478dffdb4a23e646325eb149b04b8bed3b06;hp=b67617abc47626da49f796314efd0cb8eb8784b6;hb=5a2a5883422f4d114902ac57d57d7d1e973fbb2e;hpb=a68dbe03813fd3db34c81f4e6960572e8882930b

diff --git a/dali-toolkit/internal/visuals/text/text-visual.cpp b/dali-toolkit/internal/visuals/text/text-visual.cpp
index b67617a..55b1478 100644
--- a/dali-toolkit/internal/visuals/text/text-visual.cpp
+++ b/dali-toolkit/internal/visuals/text/text-visual.cpp
@@ -19,7 +19,6 @@
 #include <dali-toolkit/internal/visuals/text/text-visual.h>
 
 // INTERNAL HEADER
-#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
@@ -41,8 +40,7 @@ namespace Internal
 namespace
 {
 
-// Property names.
-const char * const TEXT_PROPERTY( "text" );
+// Property names - common properties defined in visual-string-constants.h/cpp
 const char * const FONT_FAMILY_PROPERTY( "fontFamily" );
 const char * const FONT_STYLE_PROPERTY( "fontStyle" );
 const char * const POINT_SIZE_PROPERTY( "pointSize" );
@@ -52,8 +50,6 @@ const char * const VERTICAL_ALIGNMENT_PROPERTY( "verticalAlignment" );
 const char * const TEXT_COLOR_PROPERTY( "textColor" );
 const char * const ENABLE_MARKUP_PROPERTY( "enableMarkup" );
 
-const std::string PIXEL_AREA_UNIFORM_NAME = "pixelArea";
-
 const Scripting::StringEnum HORIZONTAL_ALIGNMENT_STRING_TABLE[] =
 {
   { "BEGIN",  Toolkit::Text::Layout::HORIZONTAL_ALIGN_BEGIN  },
@@ -95,9 +91,13 @@ const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
   uniform mediump mat4 uMvpMatrix;\n
   uniform mediump vec3 uSize;\n
   uniform mediump vec4 pixelArea;
+
+  uniform mediump mat4 uModelMatrix;\n
+  uniform mediump mat4 uViewMatrix;\n
+  uniform mediump mat4 uProjection;\n
+
   varying mediump vec2 vTexCoord;\n
   \n
-
   //Visual size and offset
   uniform mediump vec2 offset;\n
   uniform mediump vec2 size;\n
@@ -114,7 +114,10 @@ const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
 
   void main()\n
   {\n
-    mediump vec4 vertexPosition = uMvpMatrix *ComputeVertexPosition();\n
+    mediump vec4 nonAlignedVertex = uViewMatrix*uModelMatrix*ComputeVertexPosition();\n
+    mediump vec4 pixelAlignedVertex = vec4 ( floor(nonAlignedVertex.xyz), 1.0 );\n
+    mediump vec4 vertexPosition = uProjection*pixelAlignedVertex;\n
+
     vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) );\n
     gl_Position = vertexPosition;\n
   }\n
@@ -125,22 +128,101 @@ const char* FRAGMENT_SHADER_ATLAS_CLAMP = DALI_COMPOSE_SHADER(
     uniform sampler2D sTexture;\n
     uniform mediump vec4 uAtlasRect;\n
     uniform lowp vec4 uColor;\n
+    uniform lowp vec3 mixColor;\n
+    uniform lowp float opacity;\n
     \n
     void main()\n
     {\n
       mediump vec2 texCoord = clamp( mix( uAtlasRect.xy, uAtlasRect.zw, vTexCoord ), uAtlasRect.xy, uAtlasRect.zw );\n
-      gl_FragColor = texture2D( sTexture, texCoord ) * uColor;\n
+      gl_FragColor = texture2D( sTexture, texCoord ) * uColor * vec4( mixColor, opacity );\n
     }\n
 );
 
+/**
+ * Return Property index for the given string key
+ * param[in] stringKey the string index key
+ * return the key as an index
+ */
+
+Dali::Property::Index StringKeyToIndexKey( const std::string& stringKey )
+{
+  Dali::Property::Index result = Property::INVALID_KEY;
+
+  if( stringKey == VISUAL_TYPE )
+  {
+    result = Toolkit::Visual::Property::TYPE;
+  }
+  else if( stringKey == TEXT_PROPERTY )
+  {
+    result = Toolkit::TextVisual::Property::TEXT;
+  }
+  else if( stringKey == FONT_FAMILY_PROPERTY )
+  {
+    result = Toolkit::TextVisual::Property::FONT_FAMILY;
+  }
+  else if( stringKey == FONT_STYLE_PROPERTY )
+  {
+    result = Toolkit::TextVisual::Property::FONT_STYLE;
+  }
+  else if( stringKey == POINT_SIZE_PROPERTY )
+  {
+    result = Toolkit::TextVisual::Property::POINT_SIZE;
+  }
+  else if( stringKey == MULTI_LINE_PROPERTY )
+  {
+    result = Toolkit::TextVisual::Property::MULTI_LINE;
+  }
+  else if( stringKey == HORIZONTAL_ALIGNMENT_PROPERTY )
+  {
+    result = Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
+  }
+  else if( stringKey == VERTICAL_ALIGNMENT_PROPERTY )
+  {
+    result = Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
+  }
+  else if( stringKey == TEXT_COLOR_PROPERTY )
+  {
+    result = Toolkit::TextVisual::Property::TEXT_COLOR;
+  }
+  else if( stringKey == ENABLE_MARKUP_PROPERTY )
+  {
+    result = Toolkit::TextVisual::Property::ENABLE_MARKUP;
+  }
+
+  return result;
+}
+
 } // unnamed namespace
 
-TextVisualPtr TextVisual::New( VisualFactoryCache& factoryCache )
+TextVisualPtr TextVisual::New( VisualFactoryCache& factoryCache, const Property::Map& properties )
 {
-  return new TextVisual( factoryCache );
+  TextVisualPtr TextVisualPtr( new TextVisual( factoryCache ) );
+  TextVisualPtr->SetProperties( properties );
+  return TextVisualPtr;
 }
 
-float TextVisual::GetHeightForWidth( float width ) const
+void TextVisual::ConvertStringKeysToIndexKeys( Property::Map& propertyMap )
+{
+  Property::Map outMap;
+
+  for( Property::Map::SizeType index = 0u, count = propertyMap.Count(); index < count; ++index )
+  {
+    const KeyValuePair& keyValue = propertyMap.GetKeyValue( index );
+
+    Property::Index indexKey = keyValue.first.indexKey;
+
+    if ( keyValue.first.type == Property::Key::STRING )
+    {
+      indexKey = StringKeyToIndexKey( keyValue.first.stringKey );
+    }
+
+    outMap.Insert( indexKey, keyValue.second );
+  }
+
+  propertyMap = outMap;
+}
+
+float TextVisual::GetHeightForWidth( float width )
 {
   return mController->GetHeightForWidth( width );
 }
@@ -155,7 +237,7 @@ void TextVisual::DoCreatePropertyMap( Property::Map& map ) const
   Property::Value value;
 
   map.Clear();
-  map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::DevelVisual::TEXT );
+  map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::DevelVisual::TEXT );
 
   std::string text;
   mController->GetText( text );
@@ -196,57 +278,14 @@ void TextVisual::DoSetProperties( const Property::Map& propertyMap )
   {
     const KeyValuePair& keyValue = propertyMap.GetKeyValue( index );
 
-    switch( keyValue.first.type )
+    Property::Index indexKey = keyValue.first.indexKey;
+
+    if( keyValue.first.type == Property::Key::STRING )
     {
-      case Property::Key::INDEX:
-      {
-        if( Toolkit::VisualProperty::TYPE != keyValue.first.indexKey ) // Toolkit::VisualProperty::TYPE is not a TextVisual's property.
-        {
-          DoSetProperty( keyValue.first.indexKey, keyValue.second );
-        }
-        break;
-      }
-      case Property::Key::STRING:
-      {
-        if( keyValue.first.stringKey == TEXT_PROPERTY )
-        {
-          DoSetProperty( Toolkit::TextVisual::Property::TEXT, keyValue.second );
-        }
-        else if( keyValue.first.stringKey == FONT_FAMILY_PROPERTY )
-        {
-          DoSetProperty( Toolkit::TextVisual::Property::FONT_FAMILY, keyValue.second );
-        }
-        else if( keyValue.first.stringKey == FONT_STYLE_PROPERTY )
-        {
-          DoSetProperty( Toolkit::TextVisual::Property::FONT_STYLE, keyValue.second );
-        }
-        else if( keyValue.first.stringKey == POINT_SIZE_PROPERTY )
-        {
-          DoSetProperty( Toolkit::TextVisual::Property::POINT_SIZE, keyValue.second );
-        }
-        else if( keyValue.first.stringKey == MULTI_LINE_PROPERTY )
-        {
-          DoSetProperty( Toolkit::TextVisual::Property::MULTI_LINE, keyValue.second );
-        }
-        else if( keyValue.first.stringKey == HORIZONTAL_ALIGNMENT_PROPERTY )
-        {
-          DoSetProperty( Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT, keyValue.second );
-        }
-        else if( keyValue.first.stringKey == VERTICAL_ALIGNMENT_PROPERTY )
-        {
-          DoSetProperty( Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT, keyValue.second );
-        }
-        else if( keyValue.first.stringKey == TEXT_COLOR_PROPERTY )
-        {
-          DoSetProperty( Toolkit::TextVisual::Property::TEXT_COLOR, keyValue.second );
-        }
-        else if( keyValue.first.stringKey == ENABLE_MARKUP_PROPERTY )
-        {
-          DoSetProperty( Toolkit::TextVisual::Property::ENABLE_MARKUP, keyValue.second );
-        }
-        break;
-      }
+      indexKey = StringKeyToIndexKey( keyValue.first.stringKey );
     }
+
+    DoSetProperty( indexKey, keyValue.second );
   }
 
   // Elide the text if it exceeds the boundaries.
@@ -263,7 +302,21 @@ void TextVisual::DoSetOnStage( Actor& actor )
 {
   mControl = actor;
 
-  CreateRenderer();
+  Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
+
+  Shader shader = mFactoryCache.GetShader( VisualFactoryCache::TEXT_SHADER );
+  if( ! shader )
+  {
+    shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_CLAMP );
+    shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+
+    mFactoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER, shader );
+  }
+
+  mImpl->mRenderer = Renderer::New( geometry, shader );
+  mImpl->mRenderer.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::CONTENT );
+
+  UpdateRenderer( true ); // Renderer needs textures and to be added to control
 }
 
 void TextVisual::DoSetOffStage( Actor& actor )
@@ -273,17 +326,31 @@ void TextVisual::DoSetOffStage( Actor& actor )
     // Removes the renderer from the actor.
     actor.RemoveRenderer( mImpl->mRenderer );
 
-    DestroyRenderer();
+    RemoveTextureSet();
+
+    // Resets the renderer.
+    mImpl->mRenderer.Reset();
   }
 
   // Resets the control handle.
   mControl.Reset();
 }
 
+void TextVisual::OnSetTransform()
+{
+  UpdateRenderer( false );
+}
+
 void TextVisual::DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue )
 {
   switch( index )
   {
+    case Toolkit::TextVisual::Property::ENABLE_MARKUP:
+    {
+      const bool enableMarkup = propertyValue.Get<bool>();
+      mController->SetMarkupProcessorEnabled( enableMarkup );
+      break;
+    }
     case Toolkit::TextVisual::Property::TEXT:
     {
       mController->SetText( propertyValue.Get<std::string>() );
@@ -302,7 +369,6 @@ void TextVisual::DoSetProperty( Dali::Property::Index index, const Dali::Propert
     case Toolkit::TextVisual::Property::POINT_SIZE:
     {
       const float pointSize = propertyValue.Get<float>();
-
       if( !Equals( mController->GetDefaultPointSize(), pointSize ) )
       {
         mController->SetDefaultPointSize( pointSize );
@@ -347,101 +413,10 @@ void TextVisual::DoSetProperty( Dali::Property::Index index, const Dali::Propert
       }
       break;
     }
-    case Toolkit::TextVisual::Property::ENABLE_MARKUP:
-    {
-      const bool enableMarkup = propertyValue.Get<bool>();
-      mController->SetMarkupProcessorEnabled( enableMarkup );
-      break;
-    }
-    default:
-    {
-      // Should not arrive here.
-      DALI_ASSERT_DEBUG( false );
-    }
-  }
-}
-
-Dali::Property::Value TextVisual::DoGetProperty( Dali::Property::Index index )
-{
-  Dali::Property::Value value;
-
-  switch( index )
-  {
-    case Toolkit::TextVisual::Property::TEXT:
-    {
-      std::string text;
-      mController->GetText( text );
-      value = text;
-      break;
-    }
-    case Toolkit::TextVisual::Property::FONT_FAMILY:
-    {
-      value = mController->GetDefaultFontFamily();
-      break;
-    }
-    case Toolkit::TextVisual::Property::FONT_STYLE:
-    {
-      GetFontStyleProperty( mController, value, Text::FontStyle::DEFAULT );
-      break;
-    }
-    case Toolkit::TextVisual::Property::POINT_SIZE:
-    {
-      value = mController->GetDefaultPointSize();
-      break;
-    }
-    case Toolkit::TextVisual::Property::MULTI_LINE:
-    {
-      value = mController->IsMultiLineEnabled();
-      break;
-    }
-    case Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT:
-    {
-      const char* name = Scripting::GetEnumerationName< Toolkit::Text::Layout::HorizontalAlignment >( mController->GetHorizontalAlignment(),
-                                                                                                      HORIZONTAL_ALIGNMENT_STRING_TABLE,
-                                                                                                      HORIZONTAL_ALIGNMENT_STRING_TABLE_COUNT );
-      if( name )
-      {
-        value = std::string( name );
-      }
-      break;
-    }
-    case Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT:
-    {
-      const char* name = Scripting::GetEnumerationName< Toolkit::Text::Layout::VerticalAlignment >( mController->GetVerticalAlignment(),
-                                                                                                    VERTICAL_ALIGNMENT_STRING_TABLE,
-                                                                                                    VERTICAL_ALIGNMENT_STRING_TABLE_COUNT );
-      if( name )
-      {
-        value = std::string( name );
-      }
-      break;
-    }
-    case Toolkit::TextVisual::Property::TEXT_COLOR:
-    {
-      value = mController->GetDefaultColor();
-      break;
-    }
-    case Toolkit::TextVisual::Property::ENABLE_MARKUP:
-    {
-      value = mController->IsMarkupProcessorEnabled();
-      break;
-    }
-    default:
-    {
-      // Should not arrive here.
-      DALI_ASSERT_DEBUG( false );
-    }
   }
-
-  return value;
-}
-
-void TextVisual::OnSetTransform()
-{
-  CreateRenderer();
 }
 
-void TextVisual::CreateRenderer()
+void TextVisual::UpdateRenderer( bool initializeRendererAndTexture )
 {
   Actor control = mControl.GetHandle();
   if( !control )
@@ -462,12 +437,13 @@ void TextVisual::CreateRenderer()
 
   if( ( fabsf( relayoutSize.width ) < Math::MACHINE_EPSILON_1000 ) || ( fabsf( relayoutSize.height ) < Math::MACHINE_EPSILON_1000 ) )
   {
+    // Removes the texture set.
+    RemoveTextureSet();
+
     // Remove any renderer previously set.
     if( mImpl->mRenderer )
     {
       control.RemoveRenderer( mImpl->mRenderer );
-
-      DestroyRenderer();
     }
 
     // Nothing else to do if the relayout size is zero.
@@ -476,14 +452,15 @@ void TextVisual::CreateRenderer()
 
   const Text::Controller::UpdateTextType updateTextType = mController->Relayout( relayoutSize );
 
-  if( Text::Controller::NONE_UPDATED != ( Text::Controller::MODEL_UPDATED & updateTextType ) )
+  if( Text::Controller::NONE_UPDATED != ( Text::Controller::MODEL_UPDATED & updateTextType ) || initializeRendererAndTexture )
   {
+    // Removes the texture set.
+    RemoveTextureSet();
+
     // Remove any renderer previously set.
     if( mImpl->mRenderer )
     {
       control.RemoveRenderer( mImpl->mRenderer );
-
-      DestroyRenderer();
     }
 
     if( ( relayoutSize.width > Math::MACHINE_EPSILON_1000 ) &&
@@ -491,68 +468,59 @@ void TextVisual::CreateRenderer()
     {
       PixelData data = mTypesetter->Render( relayoutSize );
 
-      Geometry geometry;
-      Shader shader;
-      TextureSet textureSet;
-
-      Vector4 atlasRect;
+      Vector4 atlasRect = FULL_TEXTURE_RECT;
 
-      textureSet = mFactoryCache.GetAtlasManager()->Add( atlasRect, data );
-      mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
+      // Texture set not retrieved from Atlas Manager whilst pixel offset visible.
 
-      // Filter mode needs to be set to nearest to avoid blurry text.
-      Sampler sampler = Sampler::New();
-      sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
-      textureSet.SetSampler( 0u, sampler );
+      // It may happen the image atlas can't handle a pixel data it exceeds the maximum size.
+      // In that case, create a texture. TODO: should tile the text.
 
-      geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
-      if( !geometry )
-      {
-        geometry =  VisualFactoryCache::CreateQuadGeometry();
-        mFactoryCache.SaveGeometry( VisualFactoryCache::QUAD_GEOMETRY , geometry );
-      }
+      Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D,
+                                      data.GetPixelFormat(),
+                                      data.GetWidth(),
+                                      data.GetHeight() );
 
-      shader = mFactoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP );
-      if( !shader )
-      {
-        shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_CLAMP );
-        mFactoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP, shader );
-      }
-      shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+      texture.Upload( data );
 
-      mImpl->mRenderer = Renderer::New( geometry, shader );
-      mImpl->mRenderer.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::TEXT );
-      mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect );
+      TextureSet textureSet = TextureSet::New();
+      textureSet.SetTexture( 0u, texture );
 
-      mImpl->mRenderer.SetTextures( textureSet );
+      mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
 
-      control.AddRenderer( mImpl->mRenderer );
+      mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect );
 
       //Register transform properties
       mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 
-      mImpl->mFlags |= Impl::IS_FROM_CACHE;
+      // Filter mode needs to be set to nearest to avoid blurry text.
+      Sampler sampler = Sampler::New();
+      sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
+      textureSet.SetSampler( 0u, sampler );
+
+      mImpl->mRenderer.SetTextures( textureSet );
+
+      control.AddRenderer( mImpl->mRenderer );
     }
   }
 }
 
-void TextVisual::DestroyRenderer()
+void TextVisual::RemoveTextureSet()
 {
-  // Removes the text's image from the texture atlas.
-  Vector4 atlasRect;
-
-  const Property::Index index = mImpl->mRenderer.GetPropertyIndex( ATLAS_RECT_UNIFORM_NAME );
-  if( index != Property::INVALID_INDEX )
+  if( mImpl->mFlags & Impl::IS_ATLASING_APPLIED )
   {
-    const Property::Value& atlasRectValue = mImpl->mRenderer.GetProperty( index );
-    atlasRectValue.Get( atlasRect );
+    // Removes the text's image from the texture atlas.
+    Vector4 atlasRect;
 
-    const TextureSet& textureSet = mImpl->mRenderer.GetTextures();
-    mFactoryCache.GetAtlasManager()->Remove( textureSet, atlasRect );
-  }
+    const Property::Index index = mImpl->mRenderer.GetPropertyIndex( ATLAS_RECT_UNIFORM_NAME );
+    if( index != Property::INVALID_INDEX )
+    {
+      const Property::Value& atlasRectValue = mImpl->mRenderer.GetProperty( index );
+      atlasRectValue.Get( atlasRect );
 
-  // Resets the renderer.
-  mImpl->mRenderer.Reset();
+      const TextureSet& textureSet = mImpl->mRenderer.GetTextures();
+      mFactoryCache.GetAtlasManager()->Remove( textureSet, atlasRect );
+    }
+  }
 }
 
 } // namespace Internal