dali-toolkit/internal/controls/renderers/renderer-factory-impl.cpp

   1  /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
   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 // CLASS HEADER
  18 #include "renderer-factory-impl.h"
  19
  20 // EXTERNAL INCLUDES
  21 #include <dali/integration-api/debug.h>
  22 #include <dali/public-api/images/image.h>
  23 #include <dali/public-api/object/property-array.h>
  24 #include <dali/public-api/object/type-registry.h>
  25 #include <dali/devel-api/object/type-registry-helper.h>
  26
  27 // Internal HEADER
  28 #include <dali-toolkit/internal/controls/renderers/color/color-renderer.h>
  29 #include <dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.h>
  30 #include <dali-toolkit/internal/controls/renderers/image/image-renderer.h>
  31 #include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
  32
  33 namespace
  34 {
  35 const char * const RENDERER_TYPE_NAME( "renderer-type" );
  36 const char * const COLOR_RENDERER("color-renderer");
  37 const char * const GRADIENT_RENDERER("gradient-renderer");
  38 const char * const IMAGE_RENDERER("image-renderer");
  39 }
  40
  41 namespace Dali
  42 {
  43
  44 namespace Toolkit
  45 {
  46
  47 namespace Internal
  48 {
  49
  50 namespace
  51 {
  52
  53 BaseHandle Create()
  54 {
  55   BaseHandle handle = Toolkit::RendererFactory::Get();
  56
  57   return handle;
  58 }
  59
  60 DALI_TYPE_REGISTRATION_BEGIN_CREATE( Toolkit::RendererFactory, Dali::BaseHandle, Create, true )
  61 DALI_TYPE_REGISTRATION_END()
  62
  63 } // namespace
  64
  65 RendererFactory::RendererFactory()
  66 {
  67 }
  68
  69 RendererFactory::~RendererFactory()
  70 {
  71 }
  72
  73 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Property::Map& propertyMap )
  74 {
  75   ControlRenderer* rendererPtr = NULL;
  76
  77   Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME );
  78   std::string typeValue ;
  79   if( type && type->Get( typeValue ))
  80   {
  81     if( typeValue ==  COLOR_RENDERER )
  82     {
  83       rendererPtr = new ColorRenderer();
  84     }
  85     else if( typeValue ==  GRADIENT_RENDERER )
  86     {
  87       rendererPtr = new GradientRenderer();
  88     }
  89     else if( typeValue ==  IMAGE_RENDERER )
  90     {
  91       rendererPtr = new ImageRenderer();
  92     }
  93   }
  94
  95   if( rendererPtr )
  96   {
  97     if( !mFactoryCache )
  98     {
  99       mFactoryCache = new RendererFactoryCache();
 100     }
 101     rendererPtr->Initialize( *( mFactoryCache.Get() ), propertyMap );
 102   }
 103   else
 104   {
 105     DALI_LOG_ERROR( "Renderer type unknown" );
 106   }
 107
 108   return Toolkit::ControlRenderer(rendererPtr);
 109 }
 110
 111 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Vector4& color )
 112 {
 113   ColorRenderer* rendererPtr = new ColorRenderer();
 114
 115   if( !mFactoryCache )
 116   {
 117     mFactoryCache = new RendererFactoryCache();
 118   }
 119   rendererPtr->Initialize( *( mFactoryCache.Get() ) );
 120
 121   rendererPtr->SetColor(color);
 122
 123   return Toolkit::ControlRenderer(rendererPtr);
 124 }
 125
 126 bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const Vector4& color )
 127 {
 128   ColorRenderer* rendererPtr = dynamic_cast<ColorRenderer*>(&GetImplementation(renderer));
 129   if( rendererPtr )
 130   {
 131     rendererPtr->SetColor(color);
 132     return false;
 133   }
 134   else
 135   {
 136     renderer = GetControlRenderer(color);
 137     return true;
 138   }
 139 }
 140
 141 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Image& image )
 142 {
 143   ImageRenderer* rendererPtr = new ImageRenderer();
 144   if( !mFactoryCache )
 145   {
 146     mFactoryCache = new RendererFactoryCache();
 147   }
 148   rendererPtr->Initialize( *( mFactoryCache.Get() ) );
 149   rendererPtr->SetImage( image );
 150
 151   return Toolkit::ControlRenderer(rendererPtr);
 152 }
 153
 154 bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const Image& image )
 155 {
 156   ImageRenderer* rendererPtr = dynamic_cast<ImageRenderer*>(&GetImplementation(renderer));
 157   if( rendererPtr )
 158   {
 159     rendererPtr->SetImage(image);
 160     return false;
 161   }
 162   else
 163   {
 164     renderer = GetControlRenderer(image);
 165     return true;
 166   }
 167 }
 168
 169 } // namespace Internal
 170
 171 } // namespace Toolkit
 172
 173 } // namespace Dali
 174