#include <dali/public-api/rendering/texture-set.h>
#include <dali/public-api/rendering/shader.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/dali-toolkit.h>
#include "dummy-control.h"
#include <dali/public-api/object/property-map.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
namespace Dali
{
Property::Map customShader;
customShader[ Visual::Shader::Property::VERTEX_SHADER ] = vertexShader;
- map[ Visual::Property::SHADER ] = customShader;
+ map[ VisualProperty::SHADER ] = customShader;
return map;
}
--- /dev/null
+#ifndef DALI_TOOLKIT_DEVEL_VISUAL_PROPERTIES_H
+#define DALI_TOOLKIT_DEVEL_VISUAL_PROPERTIES_H
+
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/toolkit-property-index-ranges.h>
+#include <dali-toolkit/public-api/visuals/visual-properties.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace Visual
+{
+
+// Mirror of public API Property namespace with addition of enums that are not yet
+// public. A namespace alias is used below to reduce implementation cruft.
+
+namespace DevelProperty
+{
+
+enum Type
+{
+ TYPE = Dali::Toolkit::Visual::Property::TYPE,
+ SHADER = Dali::Toolkit::Visual::Property::SHADER,
+
+ /**
+ * @brief The transform used by the visual.
+ * @details Name "transform", type Property::Map.
+
+ * @note Optional.
+ * @see Transform::Property
+ */
+ TRANSFORM = SHADER+1//Dali::Toolkit::Visual::Property::SHADER+1
+};
+
+} // namespace DevelProperty
+
+} // namespace Visual
+
+namespace VisualProperty = Visual::DevelProperty;
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+
+#endif // DALI_TOOLKIT_DEVEL_VISUAL_PROPERTIES_H
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
#include <dali-toolkit/devel-api/controls/bloom-view/bloom-view.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/controls/gaussian-blur-view/gaussian-blur-view-impl.h>
namespace Dali
Property::Map customShader;
customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = BLOOM_EXTRACT_FRAGMENT_SOURCE;
Property::Map visualMap;
- visualMap.Insert( Toolkit::Visual::Property::SHADER, customShader );
+ visualMap.Insert( Toolkit::VisualProperty::SHADER, customShader );
mBloomExtractImageView.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
// set GaussianBlurView to blur our extracted bloom
mCompositeImageView.SetImage( mRenderTargetForRenderingChildren );
// Create shader used to composite bloom and original image to output render target
customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = COMPOSITE_FRAGMENT_SOURCE;
- visualMap[ Toolkit::Visual::Property::SHADER ] = customShader;
+ visualMap[ Toolkit::VisualProperty::SHADER ] = customShader;
mCompositeImageView.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
TextureSet textureSet = mCompositeImageView.GetRendererAt(0).GetTextures();
TextureSetImage( textureSet, 1u, mBlurExtractTarget );
#include <dali/public-api/object/property-map.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#define DALI_COMPOSE_SHADER(STR) #STR
customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = fragmentShader;
Property::Map map;
- map[ Toolkit::Visual::Property::SHADER ] = customShader;
+ map[ Toolkit::VisualProperty::SHADER ] = customShader;
return map;
}
#include <dali-toolkit/public-api/controls/text-controls/text-label.h>
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
#include <dali-toolkit/public-api/visuals/color-visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
Toolkit::Visual::Base visual;
Property::Map map;
- map[ Toolkit::Visual::Property::TYPE ] = Toolkit::Visual::COLOR;
+ map[ Toolkit::VisualProperty::TYPE ] = Toolkit::Visual::COLOR;
map[ Toolkit::ColorVisual::Property::MIX_COLOR ] = color;
visual = visualFactory.CreateVisual( map );
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
// TODO:
// pixel format / size - set from JSON
horizFragmentShaderStringStream << GAUSSIAN_BLUR_FRAGMENT_SOURCE;
Property::Map source;
source[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = horizFragmentShaderStringStream.str();
- mCustomShader[ Toolkit::Visual::Property::SHADER ] = source;
+ mCustomShader[ Toolkit::VisualProperty::SHADER ] = source;
//////////////////////////////////////////////////////
// Create actors
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
#include <dali-toolkit/internal/visuals/visual-base-impl.h>
// if its not a string then get a Property::Map from the property if possible.
else if( value.Get( map ) )
{
- Property::Value* shaderValue = map.Find( Toolkit::Visual::Property::SHADER, CUSTOM_SHADER );
+ Property::Value* shaderValue = map.Find( Toolkit::VisualProperty::SHADER, CUSTOM_SHADER );
// set image only if property map contains image information other than custom shader
if( map.Count() > 1u || !shaderValue )
{
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/border-visual-properties.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
namespace Dali
{
Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
Property::Map map;
- map[ Toolkit::Visual::Property::TYPE ] = Toolkit::Visual::BORDER;
+ map[ Toolkit::VisualProperty::TYPE ] = Toolkit::Visual::BORDER;
map[ Toolkit::BorderVisual::Property::COLOR ] = Color::WHITE;
map[ Toolkit::BorderVisual::Property::SIZE ] = IMAGE_BORDER_INDENT;
Toolkit::Visual::Base borderVisual = visualFactory.CreateVisual( map );
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#define DALI_COMPOSE_SHADER(STR) #STR
customShader[ Toolkit::Visual::Shader::Property::VERTEX_SHADER ] = vertexSource;
customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = fragmentSource;
- map[ Toolkit::Visual::Property::SHADER ] = customShader;
+ map[ Toolkit::VisualProperty::SHADER ] = customShader;
return map;
}
#include <dali/public-api/object/property-map.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/controls/page-turn-view/page-turn-effect.h>
using namespace Dali;
customShader[ Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X ] = 20;
customShader[ Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y ] = 20;
- map[ Toolkit::Visual::Property::SHADER ] = customShader;
+ map[ Toolkit::VisualProperty::SHADER ] = customShader;
return map;
}
-
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/controls/page-turn-view/page-turn-effect.h>
#include <dali-toolkit/internal/controls/page-turn-view/page-turn-book-spine-effect.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
Shader PageTurnView::CreateShader( const Property::Map& shaderMap )
{
Shader shader;
- Property::Value* shaderValue = shaderMap.Find( Toolkit::Visual::Property::SHADER, CUSTOM_SHADER );
+ Property::Value* shaderValue = shaderMap.Find( Toolkit::VisualProperty::SHADER, CUSTOM_SHADER );
Property::Map shaderSource;
if( shaderValue && shaderValue->Get( shaderSource ) )
{
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/controls/shadow-view/shadow-view-impl.h>
#include <dali-toolkit/internal/filters/blur-two-pass-filter.h>
customShader[ Toolkit::Visual::Shader::Property::HINTS ] = Shader::Hint::OUTPUT_IS_TRANSPARENT;
- mShadowVisualMap[ Toolkit::Visual::Property::SHADER ] = customShader;
+ mShadowVisualMap[ Toolkit::VisualProperty::SHADER ] = customShader;
// Create render targets needed for rendering from light's point of view
mSceneFromLightRenderTarget = FrameBufferImage::New( stageSize.width, stageSize.height, Pixel::RGBA8888 );
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/text/rendering-backend.h>
#include <dali-toolkit/public-api/visuals/text-visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/text/text-effects-style.h>
#include <dali-toolkit/internal/styling/style-manager-impl.h>
// Creates the text's visual.
Property::Map visualMap;
- visualMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::TEXT;
+ visualMap[Toolkit::VisualProperty::TYPE] = Toolkit::Visual::TEXT;
visualMap[Toolkit::TextVisual::Property::RENDERING_BACKEND] = static_cast<int>( DEFAULT_RENDERING_BACKEND );
mVisual = Toolkit::VisualFactory::Get().CreateVisual( visualMap );
#include <dali/devel-api/images/texture-set-image.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
namespace Dali
{
Property::Map customShader;
customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = fragmentSource.str();
Property::Map visualMap;
- visualMap.Insert( Toolkit::Visual::Property::SHADER, customShader );
+ visualMap.Insert( Toolkit::VisualProperty::SHADER, customShader );
mActorForInput.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
mActorForHorz.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
// Set up blend-two-image custom shader
customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = BLEND_TWO_IMAGES_FRAGMENT_SOURCE;
- visualMap[ Toolkit::Visual::Property::SHADER ] = customShader;
+ visualMap[ Toolkit::VisualProperty::SHADER ] = customShader;
mActorForBlending.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
mRootActor.Add( mActorForInput );
#include <dali/devel-api/images/texture-set-image.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-base-impl.h>
namespace Dali
Property::Map customShader;
customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = EMBOSS_FRAGMENT_SOURCE;
Property::Map visualMap;
- visualMap.Insert( Toolkit::Visual::Property::SHADER, customShader );
+ visualMap.Insert( Toolkit::VisualProperty::SHADER, customShader );
// create actor to render input with applied emboss effect
mActorForInput1 = Toolkit::ImageView::New(mInputImage);
#include <dali/public-api/render-tasks/render-task-list.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
namespace Dali
{
Property::Map customShader;
customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = SPREAD_FRAGMENT_SOURCE;
Property::Map visualMap;
- visualMap.Insert( Toolkit::Visual::Property::SHADER, customShader );
+ visualMap.Insert( Toolkit::VisualProperty::SHADER, customShader );
// set SPREAD custom shader
mActorForInput.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/border-visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
void BorderVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::BORDER );
+ map.Insert( VisualProperty::TYPE, Toolkit::Visual::BORDER );
map.Insert( Toolkit::BorderVisual::Property::COLOR, mBorderColor );
map.Insert( Toolkit::BorderVisual::Property::SIZE, mBorderSize );
map.Insert( Toolkit::BorderVisual::Property::ANTI_ALIASING, mAntiAliasing );
//INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/color-visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
void ColorVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::COLOR );
+ map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::Visual::COLOR );
map.Insert( Toolkit::ColorVisual::Property::MIX_COLOR, mMixColor );
}
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/gradient-visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
void GradientVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::GRADIENT );
+ map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::Visual::GRADIENT );
map.Insert( Toolkit::GradientVisual::Property::UNITS, mGradient->GetGradientUnits() );
map.Insert( Toolkit::GradientVisual::Property::SPREAD_METHOD, mGradient->GetSpreadMethod() );
// INTERNAL HEADER
#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-base-impl.h>
void BatchImageVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE );
+ map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::Visual::IMAGE );
if( !mImageUrl.empty() )
{
// INTERNAL HEADER
#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE );
+ map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::Visual::IMAGE );
bool sync = IsSynchronousResourceLoading();
map.Insert( SYNCHRONOUS_LOADING, sync );
#include <fstream>
//INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace Dali
void MeshVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::MESH );
+ map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::Visual::MESH );
map.Insert( Toolkit::MeshVisual::Property::OBJECT_URL, mObjectUrl );
map.Insert( Toolkit::MeshVisual::Property::MATERIAL_URL, mMaterialUrl );
map.Insert( Toolkit::MeshVisual::Property::TEXTURES_PATH, mTexturesPath );
// INTERNAL IINCLUDES
#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
void NPatchVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE );
+ map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::Visual::IMAGE );
if( !mImageUrl.empty() )
{
map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl );
#include <dali/devel-api/scripting/scripting.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace Dali
void PrimitiveVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::PRIMITIVE );
+ map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::Visual::PRIMITIVE );
map.Insert( Toolkit::PrimitiveVisual::Property::SHAPE, mPrimitiveType );
map.Insert( Toolkit::PrimitiveVisual::Property::MIX_COLOR, mColor );
map.Insert( Toolkit::PrimitiveVisual::Property::SLICES, mSlices );
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/third-party/nanosvg/nanosvg.h>
#include <dali-toolkit/internal/visuals/svg/svg-rasterize-thread.h>
#include <dali-toolkit/internal/visuals/image/image-visual.h>
void SvgVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE );
+ map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::Visual::IMAGE );
if( !mImageUrl.empty() )
{
map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl );
// INTERNAL HEADER
#include <dali-toolkit/public-api/text/rendering-backend.h>
#include <dali-toolkit/public-api/visuals/text-visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
#include <dali-toolkit/internal/text/rendering/text-backend.h>
#include <dali-toolkit/internal/text/text-view.h>
Property::Value value;
map.Clear();
- map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT );
+ map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::Visual::TEXT );
map.Insert( Toolkit::TextVisual::Property::RENDERING_BACKEND, mRenderingBackend );
{
case Property::Key::INDEX:
{
- if( Toolkit::Visual::Property::TYPE != keyValue.first.indexKey ) // Toolkit::Visual::Property::TYPE is not a TextVisual's property.
+ if( Toolkit::VisualProperty::TYPE != keyValue.first.indexKey ) // Toolkit::VisualProperty::TYPE is not a TextVisual's property.
{
DoSetProperty( keyValue.first.indexKey, keyValue.second );
}
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
namespace Dali
customShader.Insert( Toolkit::Visual::Shader::Property::HINTS, static_cast< int >( mHints ) );
}
- map.Insert( Toolkit::Visual::Property::SHADER, customShader );
+ map.Insert( Toolkit::VisualProperty::SHADER, customShader );
}
}
#include <dali/integration-api/debug.h>
//INTERNAL HEARDER
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
void Visual::Base::SetProperties( const Property::Map& propertyMap )
{
- Property::Value* customShaderValue = propertyMap.Find( Toolkit::Visual::Property::SHADER, CUSTOM_SHADER );
+ Property::Value* customShaderValue = propertyMap.Find( VisualProperty::SHADER, CUSTOM_SHADER );
if( customShaderValue )
{
Property::Map shaderMap;
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/border/border-visual.h>
#include <dali-toolkit/internal/visuals/color/color-visual.h>
#include <dali-toolkit/internal/visuals/gradient/gradient-visual.h>
Visual::BasePtr visualPtr;
- Property::Value* typeValue = propertyMap.Find( Toolkit::Visual::Property::TYPE, VISUAL_TYPE );
+ Property::Value* typeValue = propertyMap.Find( Toolkit::VisualProperty::TYPE, VISUAL_TYPE );
Toolkit::Visual::Type visualType = Toolkit::Visual::IMAGE; // Default to IMAGE type.
if( typeValue )
{
#include "wireframe-visual.h"
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
void WireframeVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::WIREFRAME );
+ map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::Visual::WIREFRAME );
}
void WireframeVisual::DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue )
#include <dali-toolkit/public-api/styling/style-manager.h>
#include <dali-toolkit/public-api/visuals/color-visual-properties.h>
#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
#include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
#include <dali-toolkit/internal/styling/style-manager-impl.h>
index(aIndex), visual(aVisual), placementActor(aPlacementActor), enabled(aEnabled) {}
};
-struct VisualProperty
+struct HandleIndex
{
Handle handle; ///< a handle to the target object
Property::Index index; ///< The index of a property provided by the referenced object
- VisualProperty( )
+ HandleIndex( )
: handle(),
index( Property::INVALID_INDEX )
{
}
- VisualProperty( Handle& handle, Property::Index index )
+ HandleIndex( Handle& handle, Property::Index index )
: handle( handle ),
index( index )
{
return false;
}
-VisualProperty GetVisualProperty(
+HandleIndex GetVisualProperty(
Internal::Control& controlImpl,
RegisteredVisualContainer& visuals,
const std::string& visualName,
{
#if defined(DEBUG_ENABLED)
std::ostringstream oss;
- oss << "Control::GetVisualProperty(" << visualName << ", " << propertyKey << ")" << std::endl;
+ oss << "Control::GetHandleIndex(" << visualName << ", " << propertyKey << ")" << std::endl;
DALI_LOG_INFO( gLogFilter, Debug::General, oss.str().c_str() );
#endif
if( index != Property::INVALID_INDEX )
{
// It's a placement actor property:
- return VisualProperty( placementActor, index );
+ return HandleIndex( placementActor, index );
}
else
{
if( index != Property::INVALID_INDEX )
{
// It's a renderer property:
- return VisualProperty( renderer, index );
+ return HandleIndex( renderer, index );
}
}
else
{
std::ostringstream oss;
oss << propertyKey;
- DALI_LOG_WARNING( "Control::GetVisualProperty(%s, %s) No renderers\n", visualName.c_str(), oss.str().c_str() );
+ DALI_LOG_WARNING( "Control::GetHandleIndex(%s, %s) No renderers\n", visualName.c_str(), oss.str().c_str() );
}
}
}
Handle handle;
- return VisualProperty( handle, Property::INVALID_INDEX );
+ return HandleIndex( handle, Property::INVALID_INDEX );
}
Actor self( Self() );
mImpl->mBackgroundColor = color;
Property::Map map;
- map[ Toolkit::Visual::Property::TYPE ] = Toolkit::Visual::COLOR;
+ map[ Toolkit::VisualProperty::TYPE ] = Toolkit::Visual::COLOR;
map[ Toolkit::ColorVisual::Property::MIX_COLOR ] = color;
mImpl->mBackgroundVisual = Toolkit::VisualFactory::Get().CreateVisual( map );
RegisterVisual( Toolkit::Control::Property::BACKGROUND, self, mImpl->mBackgroundVisual );
iter != end; ++iter )
{
TransitionData::Animator* animator = (*iter);
- VisualProperty visualProperty;
+ HandleIndex handleIndex;
// Attempt to find the object name as a child actor
Actor child = Self().FindChildByName( animator->objectName );
if( child )
{
Property::Index propertyIndex = child.GetPropertyIndex( animator->propertyKey );
- visualProperty = VisualProperty( child, propertyIndex );
+ handleIndex = HandleIndex( child, propertyIndex );
}
else
{
// Is it a placement actor/visual pair?;
- visualProperty = GetVisualProperty( *this, mImpl->mVisuals,
+ handleIndex = GetVisualProperty( *this, mImpl->mVisuals,
animator->objectName,
animator->propertyKey );
}
- if( visualProperty.handle && visualProperty.index != Property::INVALID_INDEX )
+ if( handleIndex.handle && handleIndex.index != Property::INVALID_INDEX )
{
if( animator->animate == false )
{
if( animator->targetValue.GetType() != Property::NONE )
{
- visualProperty.handle.SetProperty( visualProperty.index, animator->targetValue );
+ handleIndex.handle.SetProperty( handleIndex.index, animator->targetValue );
}
}
else
{
if( animator->initialValue.GetType() != Property::NONE )
{
- visualProperty.handle.SetProperty( visualProperty.index, animator->initialValue );
+ handleIndex.handle.SetProperty( handleIndex.index, animator->initialValue );
}
if( ! transition )
transition = Dali::Animation::New( 0.1f );
}
- transition.AnimateTo( Property( visualProperty.handle, visualProperty.index ),
+ transition.AnimateTo( Property( handleIndex.handle, handleIndex.index ),
animator->targetValue,
animator->alphaFunction,
TimePeriod( animator->timePeriodDelay,
return transition;
}
-
bool Control::OnAccessibilityActivated()
{
return false; // Accessibility activation is not handled by default
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 2;
-const unsigned int TOOLKIT_MICRO_VERSION = 11;
+const unsigned int TOOLKIT_MICRO_VERSION = 12;
const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/public-api/toolkit-property-index-ranges.h>
namespace Dali
{
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/public-api/toolkit-property-index-ranges.h>
namespace Dali
{
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/public-api/toolkit-property-index-ranges.h>
namespace Dali
{
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/public-api/toolkit-property-index-ranges.h>
namespace Dali
{
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/public-api/toolkit-property-index-ranges.h>
namespace Dali
{
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/public-api/toolkit-property-index-ranges.h>
namespace Dali
{
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/public-api/toolkit-property-index-ranges.h>
namespace Dali
{
* @note Will override the existing shaders.
* @see Shader::Property
*/
- SHADER,
+ SHADER
};
} // namespace Property
Name: dali-addon
Summary: DALi module for Node.JS
-Version: 1.2.11
+Version: 1.2.12
Release: 1
Group: Development/Libraries
License: Apache License, Version 2.0
Name: NDalic
Summary: dali wrapper
-Version: 1.2.11
+Version: 1.2.12
Release: 1
Group: uifw/graphic
License: TO_BE_FILLED_IN
Name: dali-toolkit
Summary: The OpenGLES Canvas Core Library Toolkit
-Version: 1.2.11
+Version: 1.2.12
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-2-Clause and MIT
}
}
+ ///< name "Size", type Dali.Size (Stage Size value)
+ //@since 1.0.0
public Dali.Size Size
{
get
}
}
+ ///< name "BackgroundColor", type Dali.Color (Stage background color value)
+ //@since 1.0.0
public Dali.Color BackgroundColor
{
set
handle.GetProperty(myPropertyIndex).Get(ref myProperty);
Console.WriteLine( "myProperty value: " + myProperty );
- int myPropertyIndex2 = handle.RegisterProperty("myProperty2", new Property.Value(new Vector2(5.0f, 5.0f)), Property.AccessMode.READ_WRITE);
- Vector2 myProperty2 = new Vector2(0.0f, 0.0f);
+ int myPropertyIndex2 = handle.RegisterProperty("myProperty2", new Property.Value(new Size(5.0f, 5.0f)), Property.AccessMode.READ_WRITE);
+ Size myProperty2 = new Size(0.0f, 0.0f);
handle.GetProperty(myPropertyIndex2).Get(myProperty2);
Console.WriteLine( "myProperty2 value: " + myProperty2.x + ", " + myProperty2.y );
Actor actor = new Actor();
- actor.Size = new Vector3(200.0f, 200.0f, 0.0f);
+ actor.Size = new Position(200.0f, 200.0f, 0.0f);
actor.Name = "MyActor";
- actor.Color = new Vector4(1.0f, 0.0f, 1.0f, 0.8f);
+ actor.Color = new Color(1.0f, 0.0f, 1.0f, 0.8f);
Console.WriteLine("Actor id: {0}", actor.GetId());
Console.WriteLine("Actor size: " + actor.Size.x + ", " + actor.Size.y);
Console.WriteLine("Actor name: " + actor.Name);
Console.WriteLine( " Size width = " + Size[0] + ", height = " + Size[1] );
Console.WriteLine( " *************************" );
- Vector3 vector3 = new Vector3(20, 100, 50);
- Console.WriteLine( " Created " + vector3 );
- Console.WriteLine( " Vector3 x = " + vector3.x + ", y = " + vector3.y + ", z = " + vector3.z );
- vector3 += new Vector3(20, 20, 20);
- Console.WriteLine( " Vector3 x = " + vector3[0] + ", y = " + vector3[1] + ", z = " + vector3[2] );
- vector3.x += 10;
- vector3.y += 10;
- vector3.z += 10;
- Console.WriteLine( " Vector3 width = " + vector3.width + ", height = " + vector3.height + ", depth = " + vector3.depth );
- Vector3 parentOrigin = NDalic.ParentOriginBottomRight;
+ Position Position = new Position(20, 100, 50);
+ Console.WriteLine( " Created " + Position );
+ Console.WriteLine( " Position x = " + Position.x + ", y = " + Position.y + ", z = " + Position.z );
+ Position += new Position(20, 20, 20);
+ Console.WriteLine( " Position x = " + Position[0] + ", y = " + Position[1] + ", z = " + Position[2] );
+ Position.x += 10;
+ Position.y += 10;
+ Position.z += 10;
+ Console.WriteLine( " Position width = " + Position.width + ", height = " + Position.height + ", depth = " + Position.depth );
+ Position parentOrigin = new Dali.Position(NDalic.ParentOriginBottomRight);
Console.WriteLine( " parentOrigin x = " + parentOrigin.x + ", y = " + parentOrigin.y + ", z = " + parentOrigin.z );
Console.WriteLine( " *************************" );
- Vector4 vector4 = new Vector4(20, 100, 50, 200);
- Console.WriteLine( " Created " + vector4 );
- Console.WriteLine( " Vector4 x = " + vector4.x + ", y = " + vector4.y + ", z = " + vector4.z + ", w = " + vector4.w );
- vector4 += new Vector4(20, 20, 20, 20);
- Console.WriteLine( " Vector4 x = " + vector4[0] + ", y = " + vector4[1] + ", z = " + vector4[2] + ", w = " + vector4[3] );
- vector4.x += 10;
- vector4.y += 10;
- vector4.z += 10;
- vector4.w += 10;
- Console.WriteLine( " Vector4 r = " + vector4.r + ", g = " + vector4.g + ", b = " + vector4.b + ", a = " + vector4.a );
+ Color Color = new Color(20, 100, 50, 200);
+ Console.WriteLine( " Created " + Color );
+ Console.WriteLine( " Color x = " + Color.x + ", y = " + Color.y + ", z = " + Color.z + ", w = " + Color.w );
+ Color += new Color(20, 20, 20, 20);
+ Console.WriteLine( " Color x = " + Color[0] + ", y = " + Color[1] + ", z = " + Color[2] + ", w = " + Color[3] );
+ Color.x += 10;
+ Color.y += 10;
+ Color.z += 10;
+ Color.w += 10;
+ Console.WriteLine( " Color r = " + Color.r + ", g = " + Color.g + ", b = " + Color.b + ", a = " + Color.a );
}
public Color(float red, float green, float blue, float alpha)
: base(red, green, blue, alpha)
{ }
-
+
/**
* @brief constructor
*
* @since 1.0.0
- * @param [in] o The Vector Position r, g, b, a.
+ * @param [in] o The Vector4 having r g b a components
*/
public Color(Vector4 o)
: base(o.x, o.y, o.z, o.w)
a = alpha;
}
- ///< name "R", type float (Color R value)
- //@since 1.0.0
+ /**
+ * @brief name "R", type float (Color's Red component)
+ * @SINCE_1_0.0
+ */
+
public float R
{
get { return r; }
set { r = value; }
}
- ///< name "G", type float (Color G value)
- //@since 1.0.0
+ /**
+ * @brief name "G", type float (Color's Green component)
+ * @SINCE_1_0.0
+ */
public float G
{
get { return g; }
set { g = value; }
}
- ///< name "B", type float (Color B value)
- //@since 1.0.0
+ /**
+ * @brief name "B", type float (Color's Blue component)
+ * @SINCE_1_0.0
+ */
public float B
{
get { return b; }
set { b = value; }
}
- ///< name "A", type float (Color A value)
- //@since 1.0.0
+ /**
+ * @brief name "A", type float (Color's Alpha value)
+ * @SINCE_1_0.0
+ */
public float A
{
get { return a; }
}
/**
+ * @brief operator+
+ *
+ * @since 1.0.0
+ * @param [in] l The Color to add.
+ * @param [in] r The Color to add
+ * @return A reference to this
+ */
+ public static Color operator +(Color l, Color r)
+ {
+ return new Color(l.R + r.R, l.G + r.G, l.B + r.B, l.A + r.A);
+ }
+
+ /**
+ * @brief operator-
+ *
+ * @since 1.0.0
+ * @param [in] l The Color to substract.
+ * @param [in] r The Color to substract
+ * @return A reference to this
+ */
+ public static Color operator -(Color l, Color r)
+ {
+ return new Color(l.R - r.R, l.G - r.G, l.B - r.B, l.A - r.A);
+ }
+
+ /**
+ * @brief operator*
+ *
+ * @since 1.0.0
+ * @param [in] a The Color to multiply.
+ * @param [in] b The Color to multiply
+ * @return A reference to this
+ */
+ public static Color operator *(Color a, double b)
+ {
+ return new Color((int)(a.R * b), (int)(a.G * b), (int)(a.B * b), (int)(a.A * b));
+ }
+
+ /**
+ * @brief operator/
+ *
+ * @since 1.0.0
+ * @param [in] a The Color to divide.
+ * @param [in] b The Color to divide
+ * @return float value of division operation
+ */
+ public static float operator /(Color a, Color b)
+ {
+ return (float)System.Math.Sqrt((a.R / b.R) * (a.G / b.G) * (a.B / b.B) * (a.A / b.A));
+ }
+
+ /**
* @brief Equals
*
* @since 1.0.0
* @brief operator-
*
* @since 1.0.0
- * @param [in] l The Position to add.
- * @param [in] r The Position to add
+ * @param [in] l The Position to substract.
+ * @param [in] r The Position to substract
* @return A reference to this
*/
public static Position operator -(Position l, Position r)
* @brief operator*
*
* @since 1.0.0
- * @param [in] l The Position to add.
- * @param [in] r The Position to add
+ * @param [in] a The Position to multiply.
+ * @param [in] b The Position to multiply
* @return A reference to this
*/
public static Position operator *(Position a, double b)
* @brief operator/
*
* @since 1.0.0
- * @param [in] l The Position to add.
- * @param [in] r The Position to add
- * @return A reference to this
+ * @param [in] a The Position to divide.
+ * @param [in] b The Position to divide
+ * @return float value of division operation
*/
public static float operator /(Position a, Position b)
{
*
* @since 1.0.0
* @param [in] o The Position object to compare.
- * @param [in] r The Position to add
* @return bool, whether object equal or not
*/
public override bool Equals(object obj)
* @brief Clone
*
* @since 1.0.0
- * @return Positin object
+ * @return Position object
*/
public Position Clone()
{
* @brief constructor
*
* @since 1.0.0
- * @param [in] a The Size X.
- * @param [in] b The Size Y.
+ * @param [in] a Width value .
+ * @param [in] b Height value.
*/
public Size(float a, float b)
: base(a, b)
{
}
/**
- * @brief constructor
+ * @brief default constructor
*
* @since 1.0.0
*/
}
/**
- * @brief constructor
+ * @brief constructor with base class object
*
* @since 1.0.0
- * @param [in] o The Vector Size X, Y.
+ * @param [in] o The Vector2 with Width, Height values.
*/
public Size(Vector2 o)
: base(o.x, o.y)
}
/**
- * @brief constructor
+ * @brief Copy constructor
*
* @since 1.0.0
- * @param [in] o The Size X, Y.
+ * @param [in] o The Size having Width & Y.
*/
public Size(Size a)
: base(a.width, a.height)
{
}
- ///< name "W", type float (Size W value)
+ ///< name "W", type float (Size Width value)
//@since 1.0.0
public float W
{
set { width = value; }
}
- ///< name "H", type float (Size W value)
+ ///< name "H", type float (Size Height value)
//@since 1.0.0
public float H
{
* @brief operator-
*
* @since 1.0.0
- * @param [in] l The Size to add.
- * @param [in] r The Size to add
+ * @param [in] l The Size to substract.
+ * @param [in] r The Size to substract
* @return A reference to this
*/
public static Size operator -(Size l, Size r)
* @brief operator*
*
* @since 1.0.0
- * @param [in] l The Size to add.
- * @param [in] r The Size to add
+ * @param [in] a The Size to multiply
+ * @param [in] b The Size to multiply
* @return A reference to this
*/
public static Size operator *(Size a, double b)
* @brief operator/
*
* @since 1.0.0
- * @param [in] l The Size to add.
- * @param [in] r The Size to add
- * @return A reference to this
+ * @param [in] a The Size to divide.
+ * @param [in] b The Size to divide
+ * @return float of the size division
*/
public static float operator /(Size a, Size b)
{
* @brief Equals
*
* @since 1.0.0
- * @param [in] o The Size object to compare.
- * @param [in] r The Size to add
+ * @param [in] obj The Size object to compare.
* @return bool, whether object equal or not
*/
public override bool Equals(object obj)
* @brief Clone
*
* @since 1.0.0
- * @return Size object
+ * @return returns a copy of Size object
*/
public Size Clone()
{