#define DALI_TOOLKIT_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
#include <dali-toolkit/public-api/controls/model3d-view/model3d-view.h>
#include <dali-toolkit/public-api/controls/progress-bar/progress-bar.h>
-#include <dali-toolkit/public-api/controls/scrollable/item-view/default-item-layout.h>
#include <dali-toolkit/public-api/controls/scrollable/item-view/default-item-layout-property.h>
+#include <dali-toolkit/public-api/controls/scrollable/item-view/default-item-layout.h>
#include <dali-toolkit/public-api/controls/scrollable/item-view/item-factory.h>
#include <dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h>
#include <dali-toolkit/public-api/controls/scrollable/item-view/item-view.h>
#include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
// EXTERNAL INCLUDES
-#include <dali/integration-api/debug.h>
#include <dali/devel-api/common/singleton-service.h>
+#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/accessibility-manager/accessibility-manager-impl.h>
namespace Dali
{
-
namespace Toolkit
{
-
AccessibilityManager::AccessibilityManager()
{
}
AccessibilityManager manager;
// Check whether the accessibility manager is already created
- SingletonService singletonService( SingletonService::Get() );
- if ( singletonService )
+ SingletonService singletonService(SingletonService::Get());
+ if(singletonService)
{
Dali::BaseHandle handle = singletonService.GetSingleton(typeid(AccessibilityManager));
if(handle)
{
// If not, create the accessibility manager and register it as a singleton
Internal::AccessibilityManager* internalManager = new Internal::AccessibilityManager();
- manager = AccessibilityManager( internalManager );
+ manager = AccessibilityManager(internalManager);
internalManager->Initialise();
- singletonService.Register( typeid(manager), manager );
+ singletonService.Register(typeid(manager), manager);
}
}
return manager;
}
-AccessibilityManager::AccessibilityManager(Internal::AccessibilityManager *impl)
- : BaseHandle(impl)
+AccessibilityManager::AccessibilityManager(Internal::AccessibilityManager* impl)
+: BaseHandle(impl)
{
}
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class AccessibilityManager;
class DALI_TOOLKIT_API AccessibilityManager : public BaseHandle
{
public:
-
// Typedefs
/**
* The connected signal callback should return true if handled.
* @SINCE_1_0.0
*/
- typedef Signal< bool ( AccessibilityManager& ) > AccessibilityActionSignalType; ///< Generic signal type @SINCE_1_0.0
- typedef Signal< bool ( AccessibilityManager&, const Dali::TouchEvent& )> AccessibilityActionScrollSignalType; ///< Scroll signal type @SINCE_1_0.0
+ typedef Signal<bool(AccessibilityManager&)> AccessibilityActionSignalType; ///< Generic signal type @SINCE_1_0.0
+ typedef Signal<bool(AccessibilityManager&, const Dali::TouchEvent&)> AccessibilityActionScrollSignalType; ///< Scroll signal type @SINCE_1_0.0
/**
* @brief Enumeration for accessibility that needs four information which will be read by screen-reader.
*/
enum AccessibilityAttribute
{
- ACCESSIBILITY_LABEL = 0, ///< Simple text which contained in ui-control @SINCE_1_0.0
- ACCESSIBILITY_TRAIT, ///< Description of ui-control trait @SINCE_1_0.0
- ACCESSIBILITY_VALUE, ///< Current value of ui-control (Optional) @SINCE_1_0.0
- ACCESSIBILITY_HINT, ///< Hint for action (Optional) @SINCE_1_0.0
+ ACCESSIBILITY_LABEL = 0, ///< Simple text which contained in ui-control @SINCE_1_0.0
+ ACCESSIBILITY_TRAIT, ///< Description of ui-control trait @SINCE_1_0.0
+ ACCESSIBILITY_VALUE, ///< Current value of ui-control (Optional) @SINCE_1_0.0
+ ACCESSIBILITY_HINT, ///< Hint for action (Optional) @SINCE_1_0.0
ACCESSIBILITY_ATTRIBUTE_NUM ///< Number of attributes @SINCE_1_0.0
};
- /**
+ /**
* @brief Enumeration for overshoot direction.
* @SINCE_1_0.0
*/
enum FocusOvershotDirection
{
OVERSHOT_PREVIOUS = -1, ///< Try to move previous of the first actor @SINCE_1_0.0
- OVERSHOT_NEXT = 1, ///< Try to move next of the last actor @SINCE_1_0.0
+ OVERSHOT_NEXT = 1, ///< Try to move next of the last actor @SINCE_1_0.0
};
- public:
-
+public:
/// @brief Focus changed signal
/// @SINCE_1_0.0
- typedef Signal< void ( Actor, Actor ) > FocusChangedSignalType;
+ typedef Signal<void(Actor, Actor)> FocusChangedSignalType;
/// @brief Focus overshooted signal
/// @SINCE_1_0.0
- typedef Signal< void ( Actor, FocusOvershotDirection ) > FocusOvershotSignalType;
+ typedef Signal<void(Actor, FocusOvershotDirection)> FocusOvershotSignalType;
/// @brief Focused actor activated signal
/// @SINCE_1_0.0
- typedef Signal< void ( Actor ) > FocusedActorActivatedSignalType;
+ typedef Signal<void(Actor)> FocusedActorActivatedSignalType;
/**
* @brief Creates an AccessibilityManager handle; this can be initialised with AccessibilityManager::New().
*/
Vector2 GetReadPosition() const;
- public: // Signals
-
+public: // Signals
/**
* @brief This signal is emitted when the current focused actor is changed.
*
*/
FocusedActorActivatedSignalType& FocusedActorActivatedSignal();
- public: // Accessibility action signals
-
+public: // Accessibility action signals
/**
* @brief This is emitted when accessibility(screen-reader) feature turned on or off.
*
AccessibilityActionScrollSignalType& ActionScrollSignal();
public:
-
- explicit DALI_INTERNAL AccessibilityManager( Internal::AccessibilityManager *impl );
+ explicit DALI_INTERNAL AccessibilityManager(Internal::AccessibilityManager* impl);
}; // class AccessibilityManager
namespace
{
-
#define TOKEN_STRING(x) #x
} // unnamed namespace
namespace Dali
{
-
namespace Toolkit
{
-
const std::string AssetManager::GetDaliImagePath()
{
/**
return (nullptr == DALI_DATA_READ_ONLY_DIR) ? EnvironmentVariable::GetEnvironmentVariable(TOKEN_STRING(DALI_DATA_READ_ONLY_DIR)) : DALI_DATA_READ_ONLY_DIR;
}
-} // Toolkit
+} // namespace Toolkit
-} // Dali
+} // namespace Dali
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @brief Retrieves the file system path of the assets.
*/
static const std::string GetDaliDataReadOnlyPath();
};
-} // Toolkit
-
-} // Dali
+} // namespace Toolkit
+} // namespace Dali
#endif // DALI_TOOLKIT_ASSET_MANAGER_DEVEL_H
-
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <sstream>
#include <iterator>
+#include <sstream>
-#include <dali/public-api/object/property-value.h>
-#include <dali/public-api/object/property-array.h>
#include <dali-toolkit/devel-api/builder/base64-encoding.h>
+#include <dali/public-api/object/property-array.h>
+#include <dali/public-api/object/property-value.h>
#include <dali-toolkit/third-party/base-n/basen.hpp>
namespace Dali
{
-
namespace Toolkit
{
-
namespace
{
const int MAX_PROPERTY_STRING_LENGTH(64); // Cuts larger strings into blocks of this size.
-bool GetStringFromProperty( const Property::Value& value, std::string& output )
+bool GetStringFromProperty(const Property::Value& value, std::string& output)
{
bool extracted = false;
- if( value.Get( output ) )
+ if(value.Get(output))
{
extracted = true;
}
else
{
Property::Array* array = value.GetArray();
- if( array )
+ if(array)
{
const unsigned int arraySize = array->Size();
- for( unsigned int i = 0; i < arraySize; ++i )
+ for(unsigned int i = 0; i < arraySize; ++i)
{
std::string element;
- if( array->GetElementAt( i ).Get( element ) )
+ if(array->GetElementAt(i).Get(element))
{
extracted = true;
output += element;
return extracted;
}
-}//anonymous namespace
+} //anonymous namespace
-bool DecodeBase64PropertyData( const Property::Value& value, std::vector<uint32_t>& outputData )
+bool DecodeBase64PropertyData(const Property::Value& value, std::vector<uint32_t>& outputData)
{
- bool decoded = false;
+ bool decoded = false;
std::string encodedString;
-
- if( GetStringFromProperty( value, encodedString ) )
+ if(GetStringFromProperty(value, encodedString))
{
std::vector<unsigned char> outputTmpData;
- outputTmpData.reserve( ceil( encodedString.size() * 0.75f ) );
- bn::decode_b64( encodedString.begin(), encodedString.end(), std::back_inserter(outputTmpData) );
+ outputTmpData.reserve(ceil(encodedString.size() * 0.75f));
+ bn::decode_b64(encodedString.begin(), encodedString.end(), std::back_inserter(outputTmpData));
outputData.clear();
- outputData.resize( outputTmpData.size() / sizeof(uint32_t) );
+ outputData.resize(outputTmpData.size() / sizeof(uint32_t));
// Treat as a block of data
- memcpy( &outputData[0], &outputTmpData[0], outputTmpData.size() );
+ memcpy(&outputData[0], &outputTmpData[0], outputTmpData.size());
decoded = true;
}
return decoded;
}
-void EncodeBase64PropertyData( Property::Value& value, const std::vector<uint32_t>& inputData )
+void EncodeBase64PropertyData(Property::Value& value, const std::vector<uint32_t>& inputData)
{
std::ostringstream oss;
- bn::encode_b64( reinterpret_cast<const char*>(&inputData[0]),
- reinterpret_cast<const char*>(&inputData[0]+inputData.size()),
- std::ostream_iterator<unsigned char>(oss, "") );
-
+ bn::encode_b64(reinterpret_cast<const char*>(&inputData[0]),
+ reinterpret_cast<const char*>(&inputData[0] + inputData.size()),
+ std::ostream_iterator<unsigned char>(oss, ""));
std::string encodedString = oss.str();
- if( encodedString.length() > MAX_PROPERTY_STRING_LENGTH)
+ if(encodedString.length() > MAX_PROPERTY_STRING_LENGTH)
{
// cut string up into blocks of MAX_PROPERTY_STRING_LENGTH and store to an array
auto numStrings = encodedString.length() / MAX_PROPERTY_STRING_LENGTH +
((encodedString.length() % MAX_PROPERTY_STRING_LENGTH) != 0);
Property::Array array;
- for(auto i=0u; i<numStrings; ++i)
+ for(auto i = 0u; i < numStrings; ++i)
{
- array.PushBack( encodedString.substr( i*MAX_PROPERTY_STRING_LENGTH, MAX_PROPERTY_STRING_LENGTH));
+ array.PushBack(encodedString.substr(i * MAX_PROPERTY_STRING_LENGTH, MAX_PROPERTY_STRING_LENGTH));
}
value = array;
}
}
}
-
} // namespace Toolkit
} // namespace Dali
#define DALI_TOOLKIT_BASE64_ENCODING_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/object/property.h>
#include <dali/public-api/common/vector-wrapper.h>
+#include <dali/public-api/object/property.h>
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @brief Parses a Property::STRING or Property::ARRAY of STRINGS to
* retrieve a block of uint32_t data.
* @param[out] outputData The output data block
* @return True if a data block was decoded successfully.
*/
-bool DecodeBase64PropertyData( const Property::Value& value, std::vector<uint32_t>& outputData );
+bool DecodeBase64PropertyData(const Property::Value& value, std::vector<uint32_t>& outputData);
/**
* @brief Convert a block of uint32_t data into a Property::STRING or ARRAY of STRINGs
* @param[out] value The value to write data into (to avoid copying).
* @param[in] inputData The input
*/
-void EncodeBase64PropertyData( Property::Value& value, const std::vector<uint32_t>& inputData );
+void EncodeBase64PropertyData(Property::Value& value, const std::vector<uint32_t>& inputData);
} // namespace Toolkit
} // namespace Dali
-
#endif // DALI_TOOLKIT_BASE64_ENCODING_H
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
Builder::Builder()
{
}
return Builder(new Internal::Builder());
}
-Builder::Builder(Internal::Builder *impl)
- : BaseHandle(impl)
+Builder::Builder(Internal::Builder* impl)
+: BaseHandle(impl)
{
}
-void Builder::LoadFromString( const std::string &data, UIFormat rep )
+void Builder::LoadFromString(const std::string& data, UIFormat rep)
{
- GetImpl(*this).LoadFromString( data );
+ GetImpl(*this).LoadFromString(data);
}
-void Builder::AddConstants( const Property::Map& map )
+void Builder::AddConstants(const Property::Map& map)
{
- GetImpl(*this).AddConstants( map );
+ GetImpl(*this).AddConstants(map);
}
-void Builder::AddConstant( const std::string& key, const Property::Value& value )
+void Builder::AddConstant(const std::string& key, const Property::Value& value)
{
- GetImpl(*this).AddConstant( key, value );
+ GetImpl(*this).AddConstant(key, value);
}
const Property::Map& Builder::GetConfigurations() const
return GetImpl(*this).GetConstants();
}
-const Property::Value& Builder::GetConstant( const std::string& key ) const
+const Property::Value& Builder::GetConstant(const std::string& key) const
{
- return GetImpl(*this).GetConstant( key );
+ return GetImpl(*this).GetConstant(key);
}
-Animation Builder::CreateAnimation( const std::string& animationName )
+Animation Builder::CreateAnimation(const std::string& animationName)
{
- return GetImpl(*this).CreateAnimation( animationName );
+ return GetImpl(*this).CreateAnimation(animationName);
}
-Animation Builder::CreateAnimation( const std::string& animationName, const Property::Map& map )
+Animation Builder::CreateAnimation(const std::string& animationName, const Property::Map& map)
{
- return GetImpl(*this).CreateAnimation( animationName, map );
+ return GetImpl(*this).CreateAnimation(animationName, map);
}
-Animation Builder::CreateAnimation( const std::string& animationName, Dali::Actor sourceActor )
+Animation Builder::CreateAnimation(const std::string& animationName, Dali::Actor sourceActor)
{
- return GetImpl(*this).CreateAnimation( animationName, sourceActor );
+ return GetImpl(*this).CreateAnimation(animationName, sourceActor);
}
-Animation Builder::CreateAnimation( const std::string& animationName, const Property::Map& map, Dali::Actor sourceActor )
+Animation Builder::CreateAnimation(const std::string& animationName, const Property::Map& map, Dali::Actor sourceActor)
{
- return GetImpl(*this).CreateAnimation( animationName, map, sourceActor );
+ return GetImpl(*this).CreateAnimation(animationName, map, sourceActor);
}
-BaseHandle Builder::Create( const std::string& templateName )
+BaseHandle Builder::Create(const std::string& templateName)
{
- return GetImpl(*this).Create( templateName );
+ return GetImpl(*this).Create(templateName);
}
-BaseHandle Builder::Create( const std::string& templateName, const Property::Map& map )
+BaseHandle Builder::Create(const std::string& templateName, const Property::Map& map)
{
- return GetImpl(*this).Create( templateName, map );
+ return GetImpl(*this).Create(templateName, map);
}
-BaseHandle Builder::CreateFromJson( const std::string& json )
+BaseHandle Builder::CreateFromJson(const std::string& json)
{
- return GetImpl(*this).CreateFromJson( json );
+ return GetImpl(*this).CreateFromJson(json);
}
-bool Builder::ApplyStyle( const std::string& styleName, Handle& handle )
+bool Builder::ApplyStyle(const std::string& styleName, Handle& handle)
{
- return GetImpl(*this).ApplyStyle( styleName, handle );
+ return GetImpl(*this).ApplyStyle(styleName, handle);
}
-bool Builder::ApplyFromJson( Handle& handle, const std::string& json )
+bool Builder::ApplyFromJson(Handle& handle, const std::string& json)
{
- return GetImpl(*this).ApplyFromJson( handle, json );
+ return GetImpl(*this).ApplyFromJson(handle, json);
}
-void Builder::AddActors( Actor toActor )
+void Builder::AddActors(Actor toActor)
{
- GetImpl(*this).AddActors( toActor );
+ GetImpl(*this).AddActors(toActor);
}
-void Builder::AddActors( const std::string §ionName, Actor toActor )
+void Builder::AddActors(const std::string& sectionName, Actor toActor)
{
- GetImpl(*this).AddActors( sectionName, toActor );
+ GetImpl(*this).AddActors(sectionName, toActor);
}
-void Builder::CreateRenderTask( const std::string &name )
+void Builder::CreateRenderTask(const std::string& name)
{
- GetImpl(*this).CreateRenderTask( name );
+ GetImpl(*this).CreateRenderTask(name);
}
-Path Builder::GetPath( const std::string &name )
+Path Builder::GetPath(const std::string& name)
{
- return GetImpl(*this).GetPath( name );
+ return GetImpl(*this).GetPath(name);
}
-PathConstrainer Builder::GetPathConstrainer( const std::string& pathConstrainerName )
+PathConstrainer Builder::GetPathConstrainer(const std::string& pathConstrainerName)
{
- return GetImpl(*this).GetPathConstrainer( pathConstrainerName );
+ return GetImpl(*this).GetPathConstrainer(pathConstrainerName);
}
-LinearConstrainer Builder::GetLinearConstrainer( const std::string& linearConstrainerName )
+LinearConstrainer Builder::GetLinearConstrainer(const std::string& linearConstrainerName)
{
- return GetImpl(*this).GetLinearConstrainer( linearConstrainerName );
+ return GetImpl(*this).GetLinearConstrainer(linearConstrainerName);
}
Builder::BuilderSignalType& Builder::QuitSignal()
{
- return GetImpl( *this ).QuitSignal();
+ return GetImpl(*this).QuitSignal();
}
} // namespace Toolkit
} // namespace Dali
-
*/
// EXTERNAL INCLUDES
+#include <dali/devel-api/animation/path-constrainer.h>
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/animation/animation.h>
#include <dali/public-api/animation/linear-constrainer.h>
-#include <dali/devel-api/animation/path-constrainer.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/dali-toolkit-common.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class Builder;
*/
class DALI_TOOLKIT_API Builder : public BaseHandle
- {
- public:
- /**
+{
+public:
+ /**
* Create an Builder handle; this can be initialised with Builder::New()
* Calling member functions with an uninitialised handle is not allowed.
*/
*/
enum UIFormat
{
- JSON, ///< String is JSON
+ JSON, ///< String is JSON
};
/**
* @param data A string represenation of an Actor tree
* @param format The string representation format ie JSON
*/
- void LoadFromString( const std::string& data, UIFormat format = JSON );
+ void LoadFromString(const std::string& data, UIFormat format = JSON);
/**
* @brief Adds user defined constants to all future style template or animation expansions
* @pre The Builder has been initialized.
* @param map The user defined constants used in template expansions.
*/
- void AddConstants( const Property::Map& map );
+ void AddConstants(const Property::Map& map);
/**
* @brief Adds or modifies a user defined constant to all future style template or animation expansions
* @param key The constant name to add or update
* @param value The new value for the constant.
*/
- void AddConstant( const std::string& key, const Property::Value& value );
+ void AddConstant(const std::string& key, const Property::Value& value);
/**
* @brief Gets all currently defined configurations.
* @pre The Builder has been initialized.
* @param key The constant name to search for.
*/
- const Property::Value& GetConstant( const std::string& key ) const;
+ const Property::Value& GetConstant(const std::string& key) const;
/**
* Creates an animation from the set of known animations
* @param animationName The animation name to create
* @returns The base handle of the created object
*/
- Animation CreateAnimation( const std::string& animationName );
+ Animation CreateAnimation(const std::string& animationName);
/**
* @brief Creates an animation from the set of known animations with user defined constants
* @param map The user defined constants used in style template expansion.
* @returns The base handle of the created object
*/
- Animation CreateAnimation( const std::string& animationName, const Property::Map& map );
+ Animation CreateAnimation(const std::string& animationName, const Property::Map& map);
/**
* @brief Creates an animation from the set of known animations.
* @param sourceActor The starting point in an actor tree, from which to look for property owners
* @returns The base handle of the created object
*/
- Animation CreateAnimation( const std::string& animationName, Dali::Actor sourceActor );
+ Animation CreateAnimation(const std::string& animationName, Dali::Actor sourceActor);
/**
* @brief Creates an animation from the set of known animations with user defined constants
* @param sourceActor The starting point in an actor tree, from which to look for property owners
* @returns The base handle of the created object
*/
- Animation CreateAnimation( const std::string& animationName, const Property::Map& map, Dali::Actor sourceActor );
+ Animation CreateAnimation(const std::string& animationName, const Property::Map& map, Dali::Actor sourceActor);
/**
* @brief Creates an object (e.g. an actor) from the set of known style templates
* @param templateName The template to apply in creation.
* @returns The base handle of the created object
*/
- BaseHandle Create( const std::string& templateName );
+ BaseHandle Create(const std::string& templateName);
/**
* @brief Creates an object from the style templates with user defined constants
* @param map The user defined constants used in template expansion.
* @returns The base handle of the created object
*/
- BaseHandle Create( const std::string& templateName, const Property::Map& map );
+ BaseHandle Create(const std::string& templateName, const Property::Map& map);
/**
* @brief Creates an object (e.g. an actor) from given json snippet
* @param json The json snippet used to create the object.
* @returns The base handle of the created object if any
*/
- BaseHandle CreateFromJson( const std::string& json );
+ BaseHandle CreateFromJson(const std::string& json);
/**
* Apply a style (a collection of properties) to an actor.
*
* @return Return true if the style was found
*/
- bool ApplyStyle( const std::string& styleName, Handle& handle );
+ bool ApplyStyle(const std::string& styleName, Handle& handle);
/**
* Apply a style (a collection of properties) to an actor from the given json snippet
*
* @return Return true if the json snippet was parsed
*/
- bool ApplyFromJson( Handle& handle, const std::string& json );
-
+ bool ApplyFromJson(Handle& handle, const std::string& json);
/**
* Add the actor tree in the "stage" section to the actor toActor.
* will create and add the actors to the stage root layer.
* @param toActor The actor to add the created actors to
*/
- void AddActors( Actor toActor );
+ void AddActors(Actor toActor);
/**
* Adds actors in the sectionName to the actor toActor.
* @param sectionName The section name to search for the actor tree
* @param toActor The actor to add the created actors to
*/
- void AddActors( const std::string §ionName, Actor toActor );
+ void AddActors(const std::string& sectionName, Actor toActor);
/**
* Create a render task set.
* @pre The Builder has been initialized.
* @param name The library name of the render task set.
*/
- void CreateRenderTask( const std::string &name );
+ void CreateRenderTask(const std::string& name);
/**
* Get or create Path from the Path instance library.
* @param name The name of a Path in the loaded representation
* @return A handle to a Path if found, otherwise empty
*/
- Path GetPath( const std::string &name );
+ Path GetPath(const std::string& name);
/**
* Get or create a PathConstrainer from the set of known PathConstrainers
* @param pathConstrainerName The name of the PathConstrainer
* @returns A handle to a PathConstrainer if found, otherwise empty
*/
- PathConstrainer GetPathConstrainer( const std::string& pathConstrainerName );
+ PathConstrainer GetPathConstrainer(const std::string& pathConstrainerName);
/**
* Get or create a LinearConstrainer from the set of known LinearConstrainers
* @param linearConstrainerName The name of the LinearConstrainer
* @returns A handle to a LinearConstrainer if found, otherwise empty
*/
- LinearConstrainer GetLinearConstrainer( const std::string& linearConstrainerName );
+ LinearConstrainer GetLinearConstrainer(const std::string& linearConstrainerName);
// Signals
/**
* @brief Builder signal type
*/
- typedef Signal< void () > BuilderSignalType;
+ typedef Signal<void()> BuilderSignalType;
/**
* @brief Signal emitted when a quit action is requested by the builder.
BuilderSignalType& QuitSignal();
private:
- explicit DALI_INTERNAL Builder(Internal::Builder *impl);
+ explicit DALI_INTERNAL Builder(Internal::Builder* impl);
}; // class Builder
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// EXTERNAL INCLUDES
#include <memory.h>
+#include <algorithm>
+#include <cstring>
#include <functional>
#include <iostream>
-#include <cstring>
-#include <algorithm>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/builder/json-parser-impl.h>
namespace Dali
{
-
namespace Toolkit
{
-
JsonParser JsonParser::New()
{
Internal::JsonParser* internal = new Internal::JsonParser();
{
}
-JsonParser JsonParser::DownCast( BaseHandle handle )
+JsonParser JsonParser::DownCast(BaseHandle handle)
{
- return JsonParser( dynamic_cast<Internal::JsonParser*>(handle.GetObjectPtr()) );
+ return JsonParser(dynamic_cast<Internal::JsonParser*>(handle.GetObjectPtr()));
}
bool JsonParser::Parse(const std::string& source)
}
JsonParser::JsonParser(Internal::JsonParser* internal)
- : BaseHandle(internal)
+: BaseHandle(internal)
{
}
-} // namespace toolkit
+} // namespace Toolkit
} // namespace Dali
-
#define DALI_JSON_PARSER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <string>
+#include <dali/public-api/object/base-handle.h>
#include <list>
#include <ostream>
-#include <dali/public-api/object/base-handle.h>
+#include <string>
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/builder/tree-node.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class JsonParser;
class DALI_TOOLKIT_API JsonParser : public BaseHandle
{
public:
-
/*
* Create new parser
* @return JsonParser
* @param[in] handle Handle to an object
* @return A handle to a JsonParser or an uninitialized handle
*/
- static JsonParser DownCast( BaseHandle handle );
+ static JsonParser DownCast(BaseHandle handle);
/*
* Parse the source and construct a node tree.
void Write(std::ostream& output, int indent) const;
public: // Not intended for application developers
-
/**
* This constructor is used by Dali New() methods
* @param [in] parser A pointer to a newly allocated Dali resource
} // namespace Dali
-
#endif // DALI_JSON_PARSER_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
+#include <algorithm>
#include <cctype>
#include <cstring>
#include <string>
-#include <algorithm>
// INTERNAL INCLUDES
#include "dali-toolkit/devel-api/builder/tree-node.h"
#include "dali-toolkit/internal/builder/tree-node-manipulator.h"
-
namespace Dali
{
-
-bool CaseInsensitiveCharacterCompare( unsigned char a, unsigned char b )
+bool CaseInsensitiveCharacterCompare(unsigned char a, unsigned char b)
{
// Converts to lower case in the current locale.
- return std::tolower( a ) == std::tolower( b );
+ return std::tolower(a) == std::tolower(b);
}
/**
* return true if the lower cased ASCII strings are equal.
*/
-bool CaseInsensitiveStringCompare( const std::string& a, const std::string& b )
+bool CaseInsensitiveStringCompare(const std::string& a, const std::string& b)
{
bool result = false;
- if( a.length() == b.length() )
+ if(a.length() == b.length())
{
- result = std::equal( a.begin(), a.end(), b.begin(), CaseInsensitiveCharacterCompare );
+ result = std::equal(a.begin(), a.end(), b.begin(), CaseInsensitiveCharacterCompare);
}
return result;
}
namespace Toolkit
{
-
TreeNode::TreeNode()
- : mName(NULL),
- mParent(NULL),
- mNextSibling(NULL),
- mFirstChild(NULL),
- mLastChild(NULL),
- mStringValue(NULL),
- mType(TreeNode::IS_NULL),
- mSubstituion(false)
+: mName(NULL),
+ mParent(NULL),
+ mNextSibling(NULL),
+ mFirstChild(NULL),
+ mLastChild(NULL),
+ mStringValue(NULL),
+ mType(TreeNode::IS_NULL),
+ mSubstituion(false)
{
}
TreeNode::~TreeNode()
{
-
}
const char* TreeNode::GetName() const
size_t TreeNode::Size() const
{
- size_t c = 0;
+ size_t c = 0;
TreeNode* p = mFirstChild;
while(p)
{
const TreeNode* p = mFirstChild;
while(p)
{
- if(p->mName && (std::string(p->mName) == childName) )
+ if(p->mName && (std::string(p->mName) == childName))
{
return p;
}
return NULL;
}
-
const TreeNode* TreeNode::GetChildIgnoreCase(const std::string& childName) const
{
const TreeNode* p = mFirstChild;
if(p->mName)
{
std::string nodeName(p->mName);
- if( CaseInsensitiveStringCompare( nodeName, childName) )
+ if(CaseInsensitiveStringCompare(nodeName, childName))
{
return p;
}
return ConstIterator(mFirstChild);
}
-
TreeNode::ConstIterator TreeNode::CEnd() const
{
return ConstIterator(NULL);
}
-
-TreeNode::ConstIterator::ConstIterator(TreeNode* v) : mNode(v)
+TreeNode::ConstIterator::ConstIterator(TreeNode* v)
+: mNode(v)
{
-
}
-TreeNode::ConstIterator& TreeNode::ConstIterator::operator ++()
+TreeNode::ConstIterator& TreeNode::ConstIterator::operator++()
{
if(mNode)
{
return *this;
}
-TreeNode::ConstIterator TreeNode::ConstIterator::operator ++(int)
+TreeNode::ConstIterator TreeNode::ConstIterator::operator++(int)
{
TreeNode::ConstIterator ret(mNode);
return ret;
}
-TreeNode::KeyNodePair TreeNode::ConstIterator::operator *()
+TreeNode::KeyNodePair TreeNode::ConstIterator::operator*()
{
return KeyNodePair(mNode->mName, *mNode);
}
-bool TreeNode::ConstIterator::operator!=( const TreeNode::ConstIterator& rhs ) const
+bool TreeNode::ConstIterator::operator!=(const TreeNode::ConstIterator& rhs) const
{
return mNode != rhs.mNode;
}
#define DALI_SCRIPT_TREE_NODE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <utility> // pair
+#include <dali-toolkit/public-api/dali-toolkit-common.h>
#include <iterator>
#include <string>
-#include <dali-toolkit/public-api/dali-toolkit-common.h>
+#include <utility> // pair
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
-
class TreeNodeManipulator;
-} // namespace Internal
-
+} // namespace DALI_INTERNAL
/*
* TreeNode describes a tree of nodes.
class DALI_TOOLKIT_API ConstIterator
{
public:
- typedef KeyNodePair value_type;
- typedef KeyNodePair *pointer;
- typedef const KeyNodePair *const_pointer;
- typedef KeyNodePair &reference;
- typedef const KeyNodePair &const_reference;
- typedef size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef KeyNodePair value_type;
+ typedef KeyNodePair* pointer;
+ typedef const KeyNodePair* const_pointer;
+ typedef KeyNodePair& reference;
+ typedef const KeyNodePair& const_reference;
+ typedef size_t size_type;
+ typedef std::ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
/*
/*
* pre increment
*/
- ConstIterator& operator ++();
+ ConstIterator& operator++();
/*
* post increment
*/
- ConstIterator operator ++(int);
+ ConstIterator operator++(int);
/*
* != test
*/
- bool operator!=( const ConstIterator& rhs ) const;
+ bool operator!=(const ConstIterator& rhs) const;
/*
* pointer semantics
*/
KeyNodePair operator*();
+
private:
TreeNode* mNode;
};
DALI_INTERNAL TreeNode();
// non copyable or assignable
- DALI_INTERNAL TreeNode(TreeNode &);
+ DALI_INTERNAL TreeNode(TreeNode&);
DALI_INTERNAL TreeNode& operator=(const TreeNode&);
- const char* mName; ///< The nodes name (if any)
+ const char* mName; ///< The nodes name (if any)
- TreeNode* mParent; ///< The nodes parent
- TreeNode* mNextSibling; ///< The nodes next sibling
- TreeNode* mFirstChild; ///< The nodes first child
- TreeNode* mLastChild; ///< The nodes last child
+ TreeNode* mParent; ///< The nodes parent
+ TreeNode* mNextSibling; ///< The nodes next sibling
+ TreeNode* mFirstChild; ///< The nodes first child
+ TreeNode* mLastChild; ///< The nodes last child
union
{
- const char* mStringValue; ///< The node string value
- int mIntValue; ///< The node integer value
- float mFloatValue; ///< The node float value
+ const char* mStringValue; ///< The node string value
+ int mIntValue; ///< The node integer value
+ float mFloatValue; ///< The node float value
};
- NodeType mType; ///< The nodes type
- bool mSubstituion; ///< String substitution flag
-
+ NodeType mType; ///< The nodes type
+ bool mSubstituion; ///< String substitution flag
};
} // namespace Toolkit
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
Alignment::Alignment()
{
}
-Alignment Alignment::New( Type horizontal, Type vertical )
+Alignment Alignment::New(Type horizontal, Type vertical)
{
- return Internal::Alignment::New( horizontal, vertical );
+ return Internal::Alignment::New(horizontal, vertical);
}
Alignment::Alignment(const Alignment& alignment)
-: Control( alignment )
+: Control(alignment)
{
}
{
}
-Alignment Alignment::DownCast( BaseHandle handle )
+Alignment Alignment::DownCast(BaseHandle handle)
{
return Control::DownCast<Alignment, Internal::Alignment>(handle);
}
-void Alignment::SetAlignmentType( Type type )
+void Alignment::SetAlignmentType(Type type)
{
- GetImpl( *this ).SetAlignmentType( type );
+ GetImpl(*this).SetAlignmentType(type);
}
Alignment::Type Alignment::GetAlignmentType() const
{
- return GetImpl( *this ).GetAlignmentType();
+ return GetImpl(*this).GetAlignmentType();
}
-void Alignment::SetScaling( Scaling scaling )
+void Alignment::SetScaling(Scaling scaling)
{
- GetImpl( *this ).SetScaling( scaling );
+ GetImpl(*this).SetScaling(scaling);
}
Alignment::Scaling Alignment::GetScaling() const
{
- return GetImpl( *this ).GetScaling();
+ return GetImpl(*this).GetScaling();
}
-void Alignment::SetPadding( const Alignment::Padding& padding )
+void Alignment::SetPadding(const Alignment::Padding& padding)
{
- GetImpl( *this ).SetPadding( padding );
+ GetImpl(*this).SetPadding(padding);
}
const Alignment::Padding& Alignment::GetPadding() const
{
- return GetImpl( *this ).GetPadding();
+ return GetImpl(*this).GetPadding();
}
-Alignment::Alignment( Internal::Alignment& implementation )
-: Control( implementation )
+Alignment::Alignment(Internal::Alignment& implementation)
+: Control(implementation)
{
}
Alignment& Alignment::operator=(const Alignment& alignment)
{
- if( &alignment != this )
+ if(&alignment != this)
{
- Control::operator=( alignment );
+ Control::operator=(alignment);
}
return *this;
}
-Alignment::Alignment( Dali::Internal::CustomActor* internal )
-: Control( internal )
+Alignment::Alignment(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::Alignment>(internal);
}
#define DALI_ALIGNMENT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class Alignment;
*/
enum Type
{
- HORIZONTAL_LEFT = 1, ///< HORIZONTAL left alignment @SINCE_1_9.28
- HORIZONTAL_CENTER = 2, ///< HORIZONTAL center alignment @SINCE_1_9.28
- HORIZONTAL_RIGHT = 4, ///< HORIZONTAL right alignment @SINCE_1_9.28
- VERTICAL_TOP = 8, ///< VERTICAL top alignment @SINCE_1_9.28
+ HORIZONTAL_LEFT = 1, ///< HORIZONTAL left alignment @SINCE_1_9.28
+ HORIZONTAL_CENTER = 2, ///< HORIZONTAL center alignment @SINCE_1_9.28
+ HORIZONTAL_RIGHT = 4, ///< HORIZONTAL right alignment @SINCE_1_9.28
+ VERTICAL_TOP = 8, ///< VERTICAL top alignment @SINCE_1_9.28
VERTICAL_CENTER = 16, ///< VERTICAL center alignment @SINCE_1_9.28
- VERTICAL_BOTTOM = 32 ///< VERTICAL bottom alignment @SINCE_1_9.28
+ VERTICAL_BOTTOM = 32 ///< VERTICAL bottom alignment @SINCE_1_9.28
};
/**
*/
enum Scaling
{
- SCALE_NONE, ///< The original size is kept. @SINCE_1_9.28
- SCALE_TO_FILL, ///< Scale added actors to fill alignment's boundary. Aspect ratio is not maintained. @SINCE_1_9.28
+ SCALE_NONE, ///< The original size is kept. @SINCE_1_9.28
+ SCALE_TO_FILL, ///< Scale added actors to fill alignment's boundary. Aspect ratio is not maintained. @SINCE_1_9.28
SCALE_TO_FIT_KEEP_ASPECT, ///< Scale added actors to fit within the alignment's boundary. Aspect ratio is maintained. @SINCE_1_9.28
SCALE_TO_FILL_KEEP_ASPECT, ///< Scale added actors to fill the alignment's boundary. Aspect ratio is maintained, and the actor may exceed the alignment's boundary. @SINCE_1_9.28
- SHRINK_TO_FIT, ///< If added actors are larger than the alignment's boundary it will be shrunk down to fit. Aspect ratio is not maintained @SINCE_1_9.28
+ SHRINK_TO_FIT, ///< If added actors are larger than the alignment's boundary it will be shrunk down to fit. Aspect ratio is not maintained @SINCE_1_9.28
SHRINK_TO_FIT_KEEP_ASPECT, ///< If added actors are larger than the alignment's boundary it will be shrunk down to fit. Aspect ratio is maintained @SINCE_1_9.28
};
* @SINCE_1_0.0
*/
Padding()
- : left( 0.f ),
- right( 0.f ),
- top( 0.f ),
- bottom( 0.f )
+ : left(0.f),
+ right(0.f),
+ top(0.f),
+ bottom(0.f)
{
}
* @param[in] t Top padding
* @param[in] b Bottom padding
*/
- Padding( float l, float r, float t, float b )
- : left( l ),
- right( r ),
- top( t ),
- bottom( b )
+ Padding(float l, float r, float t, float b)
+ : left(l),
+ right(r),
+ top(t),
+ bottom(b)
{
}
- float left; ///< The left padding
- float right; ///< The right padding
- float top; ///< The top padding
+ float left; ///< The left padding
+ float right; ///< The right padding
+ float top; ///< The top padding
float bottom; ///< The bottom padding
};
* @param[in] vertical Specifies how to align actors vertically. Could be VERTICAL_TOP, VERTICAL_CENTER or VERTICAL_BOTTOM. By default, VERTICAL_CENTER
* @return A handle to the Alignment control
*/
- static Alignment New( Type horizontal = HORIZONTAL_CENTER, Type vertical = VERTICAL_CENTER );
+ static Alignment New(Type horizontal = HORIZONTAL_CENTER, Type vertical = VERTICAL_CENTER);
/**
* @brief Copy constructor. Creates another handle that points to the same real object.
* @param[in] handle Handle to an object
* @return A handle to a Alignment or an uninitialized handle
*/
- static Alignment DownCast( BaseHandle handle );
+ static Alignment DownCast(BaseHandle handle);
/**
* @brief Sets the new alignment. By default, ( HORIZONTAL_CENTER | VERTICAL_CENTER ).
* @param[in] type The new alignment option
* @note There should only be one horizontal and one vertical policy.
*/
- void SetAlignmentType( Type type );
+ void SetAlignmentType(Type type);
/**
* @brief Gets the current alignment combined into a single value.
* @param[in] scaling The scaling property
* @see Scaling.
*/
- void SetScaling( Scaling scaling );
+ void SetScaling(Scaling scaling);
/**
* @brief Retrieves the scaling property.
* @SINCE_1_0.0
* @param[in] padding The left, right, top, bottom padding values
*/
- void SetPadding( const Padding& padding );
+ void SetPadding(const Padding& padding);
/**
* @brief Gets the padding values.
Alignment& operator=(const Alignment& alignment);
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] implementation The Control implementation
*/
- DALI_INTERNAL Alignment( Internal::Alignment& implementation );
+ DALI_INTERNAL Alignment(Internal::Alignment& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor
*/
- explicit DALI_INTERNAL Alignment( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL Alignment(Dali::Internal::CustomActor* internal);
/// @endcond
};
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
BloomView::BloomView()
{
}
}
BloomView::BloomView(const BloomView& handle)
- : Control( handle )
+: Control(handle)
{
}
BloomView& BloomView::operator=(const BloomView& rhs)
{
- if( &rhs != this )
+ if(&rhs != this)
{
Control::operator=(rhs);
}
return Internal::BloomView::New();
}
-BloomView BloomView::New( const unsigned int numSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat,
- const float downsampleWidthScale, const float downsampleHeightScale)
+BloomView BloomView::New(const unsigned int numSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat, const float downsampleWidthScale, const float downsampleHeightScale)
{
- return Internal::BloomView::New( numSamples, blurBellCurveWidth, renderTargetPixelFormat,
- downsampleWidthScale, downsampleHeightScale);
+ return Internal::BloomView::New(numSamples, blurBellCurveWidth, renderTargetPixelFormat, downsampleWidthScale, downsampleHeightScale);
}
-BloomView::BloomView( Internal::BloomView& implementation )
-: Control( implementation )
+BloomView::BloomView(Internal::BloomView& implementation)
+: Control(implementation)
{
}
-BloomView::BloomView( Dali::Internal::CustomActor* internal )
-: Control( internal )
+BloomView::BloomView(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::BloomView>(internal);
}
-BloomView BloomView::DownCast( BaseHandle handle )
+BloomView BloomView::DownCast(BaseHandle handle)
{
return Control::DownCast<BloomView, Internal::BloomView>(handle);
}
#define DALI_TOOLKIT_BLOOM_VIEW_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
-
/**
* BloomView implementation class
*/
class BloomView;
-} // namespace Internal
+} // namespace DALI_INTERNAL
/**
*
class DALI_TOOLKIT_API BloomView : public Control
{
public:
-
/**
* Create an uninitialized BloomView; this can be initialized with BloomView::New()
* Calling member functions with an uninitialized Dali::Object is not allowed.
* @param[in] handle Handle to an object
* @return handle to a BloomView or an uninitialized handle
*/
- static BloomView DownCast( BaseHandle handle );
+ static BloomView DownCast(BaseHandle handle);
/**
* Create an initialized BloomView, using default settings. The default settings are:-\n
*/
static BloomView New();
- /**
+ /**
* Create an initialized BloomView.
* @param numSamples The size of the Gaussian blur kernel (number of samples in horizontal / vertical blur directions) that is used to blur the bloom
* @param blurBellCurveWidth The constant controlling the Gaussian function, must be > 0.0. Controls the width of the bell curve, i.e. the look of the blur and also indirectly
* Useful for downsampling - trades visual quality for processing speed. A value of 1.0f results in no scaling applied.
* @return A handle to a newly allocated Dali resource
*/
- static BloomView New(const unsigned int numSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat,
- const float downsampleWidthScale, const float downsampleHeightScale);
+ static BloomView New(const unsigned int numSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat, const float downsampleWidthScale, const float downsampleHeightScale);
/**
* Start rendering the BloomView. Must be called after you Add() it to the stage.
Dali::Property::Index GetImageSaturationPropertyIndex() const;
public:
-
/**
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The UI Control implementation.
*/
- DALI_INTERNAL BloomView( Internal::BloomView& implementation );
+ DALI_INTERNAL BloomView(Internal::BloomView& implementation);
/**
* Allows the creation of this UI Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- explicit DALI_INTERNAL BloomView( Dali::Internal::CustomActor* internal );
-
+ explicit DALI_INTERNAL BloomView(Dali::Internal::CustomActor* internal);
};
} // namespace Toolkit
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/bubble-effect/bubble-emitter-impl.h>
-
namespace Dali
{
-
namespace Toolkit
{
-
BubbleEmitter::BubbleEmitter()
{
}
{
}
-BubbleEmitter::BubbleEmitter( Internal::BubbleEmitter& implementation )
-: Control( implementation )
+BubbleEmitter::BubbleEmitter(Internal::BubbleEmitter& implementation)
+: Control(implementation)
{
}
BubbleEmitter::BubbleEmitter(Dali::Internal::CustomActor* internal)
-: Control( internal )
+: Control(internal)
{
- VerifyCustomActorPointer<Internal::BubbleEmitter>( internal );
+ VerifyCustomActorPointer<Internal::BubbleEmitter>(internal);
}
-BubbleEmitter BubbleEmitter::New( const Vector2& winSize,
- Dali::Texture shapeTexture,
- unsigned int maximumNumberOfBubble,
- const Vector2& bubbleSizeRange )
+BubbleEmitter BubbleEmitter::New(const Vector2& winSize,
+ Dali::Texture shapeTexture,
+ unsigned int maximumNumberOfBubble,
+ const Vector2& bubbleSizeRange)
{
- return Internal::BubbleEmitter::New( winSize, shapeTexture, maximumNumberOfBubble, bubbleSizeRange );
+ return Internal::BubbleEmitter::New(winSize, shapeTexture, maximumNumberOfBubble, bubbleSizeRange);
}
-BubbleEmitter::BubbleEmitter( const BubbleEmitter& handle )
-: Control( handle )
+BubbleEmitter::BubbleEmitter(const BubbleEmitter& handle)
+: Control(handle)
{
}
-BubbleEmitter& BubbleEmitter::operator=( const BubbleEmitter& rhs )
+BubbleEmitter& BubbleEmitter::operator=(const BubbleEmitter& rhs)
{
- if( &rhs != this )
+ if(&rhs != this)
{
Control::operator=(rhs);
}
return *this;
}
-BubbleEmitter BubbleEmitter::DownCast( BaseHandle handle )
+BubbleEmitter BubbleEmitter::DownCast(BaseHandle handle)
{
- return Control::DownCast<BubbleEmitter, Internal::BubbleEmitter>( handle );
+ return Control::DownCast<BubbleEmitter, Internal::BubbleEmitter>(handle);
}
Actor BubbleEmitter::GetRootActor()
return GetImpl(*this).GetRootActor();
}
-void BubbleEmitter::SetBackground( Dali::Texture bgTexture, const Vector3& hsvDelta )
+void BubbleEmitter::SetBackground(Dali::Texture bgTexture, const Vector3& hsvDelta)
{
- GetImpl(*this).SetBackground( bgTexture, hsvDelta );
+ GetImpl(*this).SetBackground(bgTexture, hsvDelta);
}
-void BubbleEmitter::SetBubbleShape( Dali::Texture shapeTexture )
+void BubbleEmitter::SetBubbleShape(Dali::Texture shapeTexture)
{
- GetImpl(*this).SetBubbleShape( shapeTexture );
+ GetImpl(*this).SetBubbleShape(shapeTexture);
}
-void BubbleEmitter::SetBubbleScale( float scale )
+void BubbleEmitter::SetBubbleScale(float scale)
{
- GetImpl(*this).SetBubbleScale( scale );
+ GetImpl(*this).SetBubbleScale(scale);
}
-void BubbleEmitter::SetBubbleDensity( unsigned int density )
+void BubbleEmitter::SetBubbleDensity(unsigned int density)
{
- GetImpl(*this).SetBubbleDensity( density );
+ GetImpl(*this).SetBubbleDensity(density);
}
-void BubbleEmitter::EmitBubble( Animation& animation, const Vector2& emitPosition, const Vector2& direction, const Vector2& displacement )
+void BubbleEmitter::EmitBubble(Animation& animation, const Vector2& emitPosition, const Vector2& direction, const Vector2& displacement)
{
- GetImpl(*this).EmitBubble( animation, emitPosition, direction, displacement );
+ GetImpl(*this).EmitBubble(animation, emitPosition, direction, displacement);
}
void BubbleEmitter::Restore()
#define DALI_TOOLKIT_BUBBLE_EMMITER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
- /**
+/**
* @brief BubbleEmitter implementation class.
*/
- class BubbleEmitter;
-}
+class BubbleEmitter;
+} // namespace DALI_INTERNAL
/**
* @brief BubbleEmitter is used to display lots of moving bubbles on the stage.
class DALI_TOOLKIT_API BubbleEmitter : public Control
{
public:
-
/**
* @brief Create an empty BubbleEmitter handle.
*/
* @param[in] bubbleSizeRange The size range of the bubbles; x component is the low bound, and y component is the up bound.
* @return The initialized BubbleEmitter object.
*/
- static BubbleEmitter New( const Vector2& winSize,
- Dali::Texture shapeTexture,
- unsigned int maximumNumberOfBubble,
- const Vector2& bubbleSizeRange );
-
+ static BubbleEmitter New(const Vector2& winSize,
+ Dali::Texture shapeTexture,
+ unsigned int maximumNumberOfBubble,
+ const Vector2& bubbleSizeRange);
/**
* @brief Copy constructor.
* Creates another handle that points to the same real object
* @param[in] handle The handle to copy
*/
- BubbleEmitter( const BubbleEmitter& handle );
+ BubbleEmitter(const BubbleEmitter& handle);
/**
* @brief Assignment operator.
* @param[in] rhs The object to point at
* @return A reference to this
*/
- BubbleEmitter& operator=( const BubbleEmitter& rhs );
+ BubbleEmitter& operator=(const BubbleEmitter& rhs);
/**
* @brief Downcast an Object handle to SuperBlurView.
* @param[in] handle Handle to an object
* @return handle to a BubbleEmitter or an uninitialized handle
*/
- static BubbleEmitter DownCast( BaseHandle handle );
+ static BubbleEmitter DownCast(BaseHandle handle);
/**
* @brief Return the root actor of all bubbles, should then be added to stage.
* @param[in] hsvDelta The hsv channel difference used to adjust the background image color.
* If set these vector as Vector3::Zero, original colors are used.
*/
- void SetBackground( Dali::Texture bgTexture, const Vector3& hsvDelta );
+ void SetBackground(Dali::Texture bgTexture, const Vector3& hsvDelta);
/**
* @brief Set bubble shape.
* The bubble mesh is a rectangular patch, but its displayed shape is decided by the alpha channel of the shape texture.
* @param[in] shapeTexture The texture whose alpha channel defines the bubble shape.
*/
- void SetBubbleShape( Dali::Texture shapeTexture );
+ void SetBubbleShape(Dali::Texture shapeTexture);
/**
* @brief Set the scale factor applied to all the bubbles.
*
* @param [in] scale The scale factor applied on bubbles.
*/
- void SetBubbleScale( float scale );
+ void SetBubbleScale(float scale);
/**
* @brief Set the density of the bubble.
* By set the density bigger than one, instead of emit one bubble each time, a 'density' number of bubbles are emitted.
* @param[in] density The density of the bubble.
*/
- void SetBubbleDensity( unsigned int density );
+ void SetBubbleDensity(unsigned int density);
/**
* @brief Add a bubble movement to the animation.
* @param[in] direction The direction used to constrain the bubble to move in an adjacent direction around it.
* @param[in] displacement The displacement used to bound the moving distance of the bubble.
*/
- void EmitBubble( Animation& animation, const Vector2& emitPosition, const Vector2& direction, const Vector2& displacement );
+ void EmitBubble(Animation& animation, const Vector2& emitPosition, const Vector2& direction, const Vector2& displacement);
/**
* @brief Reset all the parameters controlling the bubbles after animation.
void Restore();
public: // Not intended for developer use
-
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
*
#define DALI_TOOLKIT_BUTTON_DEVEL_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelButton
{
- namespace Property
- {
- enum Type
- {
- /**
+namespace Property
+{
+enum Type
+{
+ /**
* @brief name "labelRelativeAlignment", type STRING
* @details Sets the position of the the label in relation to the foreground/icon if both present
*/
- LABEL_RELATIVE_ALIGNMENT = Dali::Toolkit::Button::Property::DISABLED_SELECTED_BACKGROUND_VISUAL + 1,
+ LABEL_RELATIVE_ALIGNMENT = Dali::Toolkit::Button::Property::DISABLED_SELECTED_BACKGROUND_VISUAL + 1,
- /**
+ /**
* @brief name "labelPadding", type Vector4
* @details Sets the padding around the text
*/
- LABEL_PADDING,
+ LABEL_PADDING,
- /**
+ /**
* @brief name "visualPadding", type Vector4
* @details Sets the padding around the foreground visual
*/
- VISUAL_PADDING
- };
- } // namespace Property
+ VISUAL_PADDING
+};
+} // namespace Property
} // namespace DevelButton
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
ToggleButton::ToggleButton()
: Button()
{
}
-ToggleButton::ToggleButton( Internal::ToggleButton& implementation )
-: Button( implementation )
+ToggleButton::ToggleButton(Internal::ToggleButton& implementation)
+: Button(implementation)
{
}
-ToggleButton::ToggleButton( const ToggleButton& toggleButton )
-: Button( toggleButton )
+ToggleButton::ToggleButton(const ToggleButton& toggleButton)
+: Button(toggleButton)
{
}
-ToggleButton& ToggleButton::operator=( const ToggleButton& toggleButton )
+ToggleButton& ToggleButton::operator=(const ToggleButton& toggleButton)
{
- if( &toggleButton != this )
+ if(&toggleButton != this)
{
- Button::operator=( toggleButton );
+ Button::operator=(toggleButton);
}
return *this;
}
-ToggleButton::ToggleButton( Dali::Internal::CustomActor* internal )
-: Button( internal )
+ToggleButton::ToggleButton(Dali::Internal::CustomActor* internal)
+: Button(internal)
{
VerifyCustomActorPointer<Internal::ToggleButton>(internal);
}
return Internal::ToggleButton::New();
}
-ToggleButton ToggleButton::DownCast( BaseHandle handle )
+ToggleButton ToggleButton::DownCast(BaseHandle handle)
{
return Control::DownCast<ToggleButton, Internal::ToggleButton>(handle);
}
#define DALI_TOOLKIT_TOGGLE_BUTTON_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
// Forward declarations
namespace Internal DALI_INTERNAL
// Forward declarations
class ToggleButton;
-}
+} // namespace DALI_INTERNAL
/**
* @addtogroup dali_toolkit_controls_buttons
* @{
*/
enum PropertyRange
{
- PROPERTY_START_INDEX = Button::PROPERTY_END_INDEX + 1, ///< Toggle button start index
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserving 1000 property indices
+ PROPERTY_START_INDEX = Button::PROPERTY_END_INDEX + 1, ///< Toggle button start index
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserving 1000 property indices
};
/**
};
public:
-
/**
* @brief Create an uninitialized ToggleButton; this can be initialized with ToggleButton::New().
*
* @brief Copy constructor.
* @param[in] toggleButton Handle to an object
*/
- ToggleButton( const ToggleButton& toggleButton );
+ ToggleButton(const ToggleButton& toggleButton);
/**
* @brief Assignment operator.
* @param[in] toggleButton Handle to an object
* @return A reference to this
*/
- ToggleButton& operator=( const ToggleButton& toggleButton );
+ ToggleButton& operator=(const ToggleButton& toggleButton);
/**
* @brief Destructor
* @param[in] handle Handle to an object
* @return handle to a ToggleButton or an uninitialized handle
*/
- static ToggleButton DownCast( BaseHandle handle );
+ static ToggleButton DownCast(BaseHandle handle);
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
*
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL ToggleButton( Internal::ToggleButton& implementation );
+ DALI_INTERNAL ToggleButton(Internal::ToggleButton& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- DALI_INTERNAL ToggleButton( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL ToggleButton(Dali::Internal::CustomActor* internal);
/// @endcond
};
namespace Dali
{
-
namespace Toolkit
{
-
namespace DepthIndex
{
-
// The negative value for background effect and background has been
// chosen so that newer controls can have content without setting
// depth index, and go in front of native controls with a background.
enum Ranges
{
- BACKGROUND_EFFECT = -2 * DevelLayer::SIBLING_ORDER_MULTIPLIER/100,
- BACKGROUND = -1 * DevelLayer::SIBLING_ORDER_MULTIPLIER/100,
- CONTENT = 0,
- DECORATION = 1 * DevelLayer::SIBLING_ORDER_MULTIPLIER/100,
- FOREGROUND_EFFECT = 2 * DevelLayer::SIBLING_ORDER_MULTIPLIER/100
+ BACKGROUND_EFFECT = -2 * DevelLayer::SIBLING_ORDER_MULTIPLIER / 100,
+ BACKGROUND = -1 * DevelLayer::SIBLING_ORDER_MULTIPLIER / 100,
+ CONTENT = 0,
+ DECORATION = 1 * DevelLayer::SIBLING_ORDER_MULTIPLIER / 100,
+ FOREGROUND_EFFECT = 2 * DevelLayer::SIBLING_ORDER_MULTIPLIER / 100
};
-static_assert( (unsigned int)DevelLayer::ACTOR_DEPTH_MULTIPLIER > (unsigned int)DevelLayer::SIBLING_ORDER_MULTIPLIER );
-static_assert( BACKGROUND_EFFECT < BACKGROUND );
-static_assert( BACKGROUND < CONTENT );
-static_assert( CONTENT < DECORATION );
-static_assert( DECORATION < FOREGROUND_EFFECT );
+static_assert((unsigned int)DevelLayer::ACTOR_DEPTH_MULTIPLIER > (unsigned int)DevelLayer::SIBLING_ORDER_MULTIPLIER);
+static_assert(BACKGROUND_EFFECT < BACKGROUND);
+static_assert(BACKGROUND < CONTENT);
+static_assert(CONTENT < DECORATION);
+static_assert(DECORATION < FOREGROUND_EFFECT);
} // namespace DepthIndex
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/public-api/animation/animation.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/visual-factory/transition-data.h>
#include <dali-toolkit/internal/controls/control/control-data-impl.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
-#include <dali-toolkit/devel-api/visual-factory/transition-data.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelControl
{
-
-void RegisterVisual( Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual )
+void RegisterVisual(Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual)
{
- Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
- controlDataImpl.RegisterVisual( index, visual );
+ Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(control);
+ controlDataImpl.RegisterVisual(index, visual);
}
-void RegisterVisual( Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual, int depthIndex )
+void RegisterVisual(Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual, int depthIndex)
{
- Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
- controlDataImpl.RegisterVisual( index, visual, depthIndex );
+ Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(control);
+ controlDataImpl.RegisterVisual(index, visual, depthIndex);
}
-void RegisterVisual( Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual, bool enabled )
+void RegisterVisual(Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual, bool enabled)
{
- Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
- controlDataImpl.RegisterVisual( index, visual, enabled );
+ Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(control);
+ controlDataImpl.RegisterVisual(index, visual, enabled);
}
-void RegisterVisual( Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual, bool enabled, int depthIndex )
+void RegisterVisual(Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual, bool enabled, int depthIndex)
{
- Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
- controlDataImpl.RegisterVisual( index, visual, enabled, depthIndex );
+ Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(control);
+ controlDataImpl.RegisterVisual(index, visual, enabled, depthIndex);
}
-void UnregisterVisual( Internal::Control& control, Dali::Property::Index index )
+void UnregisterVisual(Internal::Control& control, Dali::Property::Index index)
{
- Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
- controlDataImpl.UnregisterVisual( index );
+ Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(control);
+ controlDataImpl.UnregisterVisual(index);
}
-Toolkit::Visual::Base GetVisual( const Internal::Control& control, Dali::Property::Index index )
+Toolkit::Visual::Base GetVisual(const Internal::Control& control, Dali::Property::Index index)
{
- const Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
- return controlDataImpl.GetVisual( index );
+ const Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(control);
+ return controlDataImpl.GetVisual(index);
}
-void EnableVisual( Internal::Control& control, Dali::Property::Index index, bool enable )
+void EnableVisual(Internal::Control& control, Dali::Property::Index index, bool enable)
{
- Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
- controlDataImpl.EnableVisual( index, enable );
+ Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(control);
+ controlDataImpl.EnableVisual(index, enable);
}
-bool IsVisualEnabled( const Internal::Control& control, Dali::Property::Index index )
+bool IsVisualEnabled(const Internal::Control& control, Dali::Property::Index index)
{
- const Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
- return controlDataImpl.IsVisualEnabled( index );
+ const Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(control);
+ return controlDataImpl.IsVisualEnabled(index);
}
-Dali::Animation CreateTransition( Internal::Control& control, const Toolkit::TransitionData& handle )
+Dali::Animation CreateTransition(Internal::Control& control, const Toolkit::TransitionData& handle)
{
- Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
- return controlDataImpl.CreateTransition( handle );
+ Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(control);
+ return controlDataImpl.CreateTransition(handle);
}
-
-void AddTransitions( Internal::Control& control,
- Dali::Animation animation,
- const Toolkit::TransitionData& transitionData )
+void AddTransitions(Internal::Control& control,
+ Dali::Animation animation,
+ const Toolkit::TransitionData& transitionData)
{
- Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
- controlDataImpl.AddTransitions( animation, transitionData );
+ Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(control);
+ controlDataImpl.AddTransitions(animation, transitionData);
}
-void DoAction( Control& control, Dali::Property::Index visualIndex, Dali::Property::Index actionId, const Dali::Property::Value attributes )
+void DoAction(Control& control, Dali::Property::Index visualIndex, Dali::Property::Index actionId, const Dali::Property::Value attributes)
{
- Internal::Control& controlInternal = Toolkit::Internal::GetImplementation( control );
- Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( controlInternal );
- controlDataImpl.DoAction( visualIndex, actionId, attributes );
+ Internal::Control& controlInternal = Toolkit::Internal::GetImplementation(control);
+ Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(controlInternal);
+ controlDataImpl.DoAction(visualIndex, actionId, attributes);
}
-void SetInputMethodContext( Internal::Control& control, InputMethodContext& inputMethodContext )
+void SetInputMethodContext(Internal::Control& control, InputMethodContext& inputMethodContext)
{
- Internal::Control::Impl::Get( control ).SetInputMethodContext( inputMethodContext );
+ Internal::Control::Impl::Get(control).SetInputMethodContext(inputMethodContext);
}
-VisualEventSignalType& VisualEventSignal( Control control )
+VisualEventSignalType& VisualEventSignal(Control control)
{
- Internal::Control& internalControl = Toolkit::Internal::GetImplementation( control );
- Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( internalControl );
+ Internal::Control& internalControl = Toolkit::Internal::GetImplementation(control);
+ Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(internalControl);
return controlDataImpl.VisualEventSignal();
}
#define DALI_TOOLKIT_CONTROL_DEVEL_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/devel-api/adaptor-framework/input-method-context.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
+#include <dali-toolkit/public-api/controls/control.h>
namespace Dali
{
-
namespace Toolkit
{
-
class TransitionData;
namespace Visual
namespace DevelControl
{
-
enum State
{
NORMAL,
namespace Property
{
-
enum
{
- STYLE_NAME = Control::Property::STYLE_NAME,
- KEY_INPUT_FOCUS = Control::Property::KEY_INPUT_FOCUS,
- BACKGROUND = Control::Property::BACKGROUND,
- MARGIN = Control::Property::MARGIN,
- PADDING = Control::Property::PADDING,
+ STYLE_NAME = Control::Property::STYLE_NAME,
+ KEY_INPUT_FOCUS = Control::Property::KEY_INPUT_FOCUS,
+ BACKGROUND = Control::Property::BACKGROUND,
+ MARGIN = Control::Property::MARGIN,
+ PADDING = Control::Property::PADDING,
/**
* @brief Displays a tooltip when the control is hovered over.
* @note If the depth-index is not set on the visual, then it is set to be above the currently registered visuals.
* @note If replacing a visual, then the depth-index of the visual being replaced is used for the visual.
*/
-DALI_TOOLKIT_API void RegisterVisual( Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual );
+DALI_TOOLKIT_API void RegisterVisual(Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual);
/**
* @brief Register a visual by Property Index with a depth index.
* @see Visual::Base::GetDepthIndex()
* @see Visual::Base::SetDepthIndex()
*/
-DALI_TOOLKIT_API void RegisterVisual( Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual, int depthIndex );
+DALI_TOOLKIT_API void RegisterVisual(Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual, int depthIndex);
/**
* @brief Register a visual by Property Index with the option of enabling/disabling it.
*
* @see EnableVisual()
*/
-DALI_TOOLKIT_API void RegisterVisual( Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual, bool enabled );
+DALI_TOOLKIT_API void RegisterVisual(Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual, bool enabled);
/**
* @brief Register a visual by Property Index with a depth index with the option of enabling/disabling it.
* @see Visual::Base::GetDepthIndex()
* @see Visual::Base::SetDepthIndex()
*/
-DALI_TOOLKIT_API void RegisterVisual( Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual, bool enabled, int depthIndex );
+DALI_TOOLKIT_API void RegisterVisual(Internal::Control& control, Dali::Property::Index index, Toolkit::Visual::Base& visual, bool enabled, int depthIndex);
/**
* @brief Erase the entry matching the given index from the list of registered visuals
* @param[in] control The control
* @param[in] index The Property index of the visual, used to reference visual
*/
-DALI_TOOLKIT_API void UnregisterVisual( Internal::Control& control, Dali::Property::Index index );
+DALI_TOOLKIT_API void UnregisterVisual(Internal::Control& control, Dali::Property::Index index);
/**
* @brief Retrieve the visual associated with the given property index.
* @return The registered visual if exist, otherwise empty handle.
* @note For managing object life-cycle, do not store the returned visual as a member which increments its reference count.
*/
-DALI_TOOLKIT_API Toolkit::Visual::Base GetVisual( const Internal::Control& control, Dali::Property::Index index );
+DALI_TOOLKIT_API Toolkit::Visual::Base GetVisual(const Internal::Control& control, Dali::Property::Index index);
/**
* @brief Sets the given visual to be displayed or not when parent staged.
* @param[in] index The Property index of the visual
* @param[in] enable flag to set enabled or disabled.
*/
-DALI_TOOLKIT_API void EnableVisual( Internal::Control& control, Dali::Property::Index index, bool enable );
+DALI_TOOLKIT_API void EnableVisual(Internal::Control& control, Dali::Property::Index index, bool enable);
/**
* @brief Queries if the given visual is to be displayed when parent staged.
* @param[in] index The Property index of the visual
* @return bool whether visual is enabled or not
*/
-DALI_TOOLKIT_API bool IsVisualEnabled( const Internal::Control& control, Dali::Property::Index index );
-
+DALI_TOOLKIT_API bool IsVisualEnabled(const Internal::Control& control, Dali::Property::Index index);
/**
* @brief Add a transition effect on the control to the given animation
* @param[in] animation The Animation to add valid transitions to
* @param[in] transitionData The transition data describing the effect to create
*/
-DALI_TOOLKIT_API void AddTransitions( Internal::Control& control,
- Dali::Animation animation,
- const Toolkit::TransitionData& transitionData );
+DALI_TOOLKIT_API void AddTransitions(Internal::Control& control,
+ Dali::Animation animation,
+ const Toolkit::TransitionData& transitionData);
/**
* @brief Create a transition effect on the control.
* @return A handle to an animation defined with the given effect, or an empty
* handle if no properties match.
*/
-DALI_TOOLKIT_API Dali::Animation CreateTransition( Internal::Control& control,
- const Toolkit::TransitionData& transitionData );
+DALI_TOOLKIT_API Dali::Animation CreateTransition(Internal::Control& control,
+ const Toolkit::TransitionData& transitionData);
/**
* @brief Perform an action on a visual registered to this control.
* @param[in] actionId The action to perform. See Visual to find supported actions.
* @param[in] attributes Optional attributes for the action.
*/
-DALI_TOOLKIT_API void DoAction( Control& control, Dali::Property::Index visualIndex, Dali::Property::Index actionId, const Dali::Property::Value attributes );
+DALI_TOOLKIT_API void DoAction(Control& control, Dali::Property::Index visualIndex, Dali::Property::Index actionId, const Dali::Property::Value attributes);
/**
* @brief Set input method context.
* @param[in] control The control.
* @param[in] inputMethodContext The input method context.
*/
-DALI_TOOLKIT_API void SetInputMethodContext( Internal::Control& control, InputMethodContext& inputMethodContext );
+DALI_TOOLKIT_API void SetInputMethodContext(Internal::Control& control, InputMethodContext& inputMethodContext);
/**
* @brief Visual Event signal type
*/
-using VisualEventSignalType = Signal< void ( Control, Dali::Property::Index, Dali::Property::Index ) >;
+using VisualEventSignalType = Signal<void(Control, Dali::Property::Index, Dali::Property::Index)>;
/**
* @brief This signal is emitted when a visual has an event to notify.
* @endcode
* @return The signal to connect to
*/
-DALI_TOOLKIT_API VisualEventSignalType& VisualEventSignal( Control control );
+DALI_TOOLKIT_API VisualEventSignalType& VisualEventSignal(Control control);
} // namespace DevelControl
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali-toolkit/devel-api/controls/control-wrapper-impl.h>
// EXTERNAL INCLUDES
+#include <dali/devel-api/actors/custom-actor-devel.h>
+#include <dali/devel-api/object/handle-devel.h>
#include <dali/public-api/animation/animation.h>
-#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/type-registry-helper.h>
-#include <dali/devel-api/object/handle-devel.h>
-#include <dali/devel-api/actors/custom-actor-devel.h>
+#include <dali/public-api/object/type-registry.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/devel-api/controls/control-devel.h>
#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
-#include <dali-toolkit/public-api/styling/style-manager.h>
#include <dali-toolkit/internal/styling/style-manager-impl.h>
+#include <dali-toolkit/public-api/controls/control-impl.h>
+#include <dali-toolkit/public-api/styling/style-manager.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal
{
-
namespace
{
-
BaseHandle Create()
{
// empty handle as we cannot create control wrapper
}
// Setup type-registry.
-DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ControlWrapper, Toolkit::Control, Create )
+DALI_TYPE_REGISTRATION_BEGIN(Toolkit::ControlWrapper, Toolkit::Control, Create)
DALI_TYPE_REGISTRATION_END()
-}
+} // namespace
/*
* Implementation.
*/
-Dali::Toolkit::ControlWrapper ControlWrapper::New( const std::string& typeName, ControlWrapper* controlWrapper )
+Dali::Toolkit::ControlWrapper ControlWrapper::New(const std::string& typeName, ControlWrapper* controlWrapper)
{
- ControlWrapperPtr wrapper( controlWrapper );
+ ControlWrapperPtr wrapper(controlWrapper);
// Pass ownership to CustomActor via derived handle.
- Dali::Toolkit::ControlWrapper handle( *wrapper );
+ Dali::Toolkit::ControlWrapper handle(*wrapper);
// Second-phase initialisation of the implementation.
// This can only be done after the CustomActor connection has been made.
// Therefore, we have to link each instance with its correct type info if already
// pre-registered.
- TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeName );
+ TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo(typeName);
if(typeInfo)
{
- Dali::DevelHandle::SetTypeInfo( handle, typeInfo );
+ Dali::DevelHandle::SetTypeInfo(handle, typeInfo);
}
return handle;
}
-ControlWrapper::ControlWrapper( CustomControlBehaviour behaviourFlags )
-: Control( static_cast< ControlBehaviour >( behaviourFlags ) )
+ControlWrapper::ControlWrapper(CustomControlBehaviour behaviourFlags)
+: Control(static_cast<ControlBehaviour>(behaviourFlags))
{
}
CustomActorImpl::RelayoutRequest();
}
-float ControlWrapper::GetHeightForWidthBase( float width )
+float ControlWrapper::GetHeightForWidthBase(float width)
{
- return CustomActorImpl::GetHeightForWidthBase( width );
+ return CustomActorImpl::GetHeightForWidthBase(width);
}
-float ControlWrapper::GetWidthForHeightBase( float height )
+float ControlWrapper::GetWidthForHeightBase(float height)
{
- return CustomActorImpl::GetWidthForHeightBase( height );
+ return CustomActorImpl::GetWidthForHeightBase(height);
}
-float ControlWrapper::CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension )
+float ControlWrapper::CalculateChildSizeBase(const Dali::Actor& child, Dimension::Type dimension)
{
- return CustomActorImpl::CalculateChildSizeBase( child, dimension );
+ return CustomActorImpl::CalculateChildSizeBase(child, dimension);
}
-bool ControlWrapper::RelayoutDependentOnChildrenBase( Dimension::Type dimension )
+bool ControlWrapper::RelayoutDependentOnChildrenBase(Dimension::Type dimension)
{
- return CustomActorImpl::RelayoutDependentOnChildrenBase( dimension );
+ return CustomActorImpl::RelayoutDependentOnChildrenBase(dimension);
}
-void ControlWrapper::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual )
+void ControlWrapper::RegisterVisual(Property::Index index, Toolkit::Visual::Base& visual)
{
- DevelControl::RegisterVisual( *this, index, visual );
+ DevelControl::RegisterVisual(*this, index, visual);
}
-void ControlWrapper::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, int depthIndex )
+void ControlWrapper::RegisterVisual(Property::Index index, Toolkit::Visual::Base& visual, int depthIndex)
{
- DevelControl::RegisterVisual( *this, index, visual, depthIndex );
+ DevelControl::RegisterVisual(*this, index, visual, depthIndex);
}
-void ControlWrapper::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, bool enabled )
+void ControlWrapper::RegisterVisual(Property::Index index, Toolkit::Visual::Base& visual, bool enabled)
{
- DevelControl::RegisterVisual( *this, index, visual, enabled );
+ DevelControl::RegisterVisual(*this, index, visual, enabled);
}
-void ControlWrapper::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, bool enabled, int depthIndex )
+void ControlWrapper::RegisterVisual(Property::Index index, Toolkit::Visual::Base& visual, bool enabled, int depthIndex)
{
- DevelControl::RegisterVisual( *this, index, visual, enabled, depthIndex );
+ DevelControl::RegisterVisual(*this, index, visual, enabled, depthIndex);
}
-void ControlWrapper::UnregisterVisual( Property::Index index )
+void ControlWrapper::UnregisterVisual(Property::Index index)
{
- DevelControl::UnregisterVisual( *this, index );
+ DevelControl::UnregisterVisual(*this, index);
}
-Toolkit::Visual::Base ControlWrapper::GetVisual( Property::Index index ) const
+Toolkit::Visual::Base ControlWrapper::GetVisual(Property::Index index) const
{
- return DevelControl::GetVisual( *this, index );
+ return DevelControl::GetVisual(*this, index);
}
-void ControlWrapper::EnableVisual( Property::Index index, bool enable )
+void ControlWrapper::EnableVisual(Property::Index index, bool enable)
{
- DevelControl::EnableVisual( *this, index, enable );
+ DevelControl::EnableVisual(*this, index, enable);
}
-bool ControlWrapper::IsVisualEnabled( Property::Index index ) const
+bool ControlWrapper::IsVisualEnabled(Property::Index index) const
{
- return DevelControl::IsVisualEnabled( *this, index );
+ return DevelControl::IsVisualEnabled(*this, index);
}
-Dali::Animation ControlWrapper::CreateTransition( const Toolkit::TransitionData& handle )
+Dali::Animation ControlWrapper::CreateTransition(const Toolkit::TransitionData& handle)
{
- return DevelControl::CreateTransition( *this, handle );
+ return DevelControl::CreateTransition(*this, handle);
}
void ControlWrapper::ApplyThemeStyle()
Toolkit::StyleManager styleManager = StyleManager::Get();
// if style manager is available
- if( styleManager )
+ if(styleManager)
{
- StyleManager& styleManagerImpl = GetImpl( styleManager );
+ StyleManager& styleManagerImpl = GetImpl(styleManager);
// Apply the current style
- styleManagerImpl.ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
+ styleManagerImpl.ApplyThemeStyle(Toolkit::Control(GetOwner()));
}
}
return DevelCustomActor::GetTypeInfo(Self());
}
-void ControlWrapper::EmitKeyInputFocusSignal( bool focusGained )
+void ControlWrapper::EmitKeyInputFocusSignal(bool focusGained)
{
- Control::EmitKeyInputFocusSignal( focusGained );
+ Control::EmitKeyInputFocusSignal(focusGained);
}
} // namespace Internal
#define DALI_TOOLKIT_INTERNAL_CONTROL_WRAPPER_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/devel-api/controls/control-wrapper.h>
+#include <dali-toolkit/public-api/controls/control-impl.h>
namespace Dali
{
-
namespace Toolkit
{
-
class TransitionData;
namespace Visual
namespace Internal
{
-
class ControlWrapper;
-typedef IntrusivePtr< ControlWrapper > ControlWrapperPtr;
+typedef IntrusivePtr<ControlWrapper> ControlWrapperPtr;
/**
* @copydoc Toolkit::ControlWrapper
class DALI_TOOLKIT_API ControlWrapper : public Control
{
public:
-
// Flags for the constructor
enum CustomControlBehaviour
{
LAST_CONTROL_BEHAVIOUR_FLAG
};
- static const int CONTROL_BEHAVIOUR_FLAG_COUNT = Log< LAST_CONTROL_BEHAVIOUR_FLAG - 1 >::value + 1; ///< Total count of flags
+ static const int CONTROL_BEHAVIOUR_FLAG_COUNT = Log<LAST_CONTROL_BEHAVIOUR_FLAG - 1>::value + 1; ///< Total count of flags
/**
* @brief Control constructor
*
* @param[in] behaviourFlags Behavioural flags from CustomControlBehaviour enum
*/
- ControlWrapper( CustomControlBehaviour behaviourFlags );
+ ControlWrapper(CustomControlBehaviour behaviourFlags);
/**
* Create a new ControlWrapper.
*
* @return A public handle to the newly allocated ControlWrapper.
*/
- static Dali::Toolkit::ControlWrapper New( const std::string& typeName, ControlWrapper* controlWrapper );
+ static Dali::Toolkit::ControlWrapper New(const std::string& typeName, ControlWrapper* controlWrapper);
public: // From CustomActorImpl
-
// Size negotiation helpers
/**
/**
* @copydoc Dali::CustomActorImpl::GetHeightForWidthBase()
*/
- float GetHeightForWidthBase( float width );
+ float GetHeightForWidthBase(float width);
/**
* @copydoc Dali::CustomActorImpl::GetWidthForHeightBase()
*/
- float GetWidthForHeightBase( float height );
+ float GetWidthForHeightBase(float height);
/**
* @copydoc Dali::CustomActorImpl::CalculateChildSizeBase()
*/
- float CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension );
+ float CalculateChildSizeBase(const Dali::Actor& child, Dimension::Type dimension);
/**
* @copydoc Dali::CustomActorImpl::RelayoutDependentOnChildrenBase()
*/
- bool RelayoutDependentOnChildrenBase( Dimension::Type dimension = Dimension::ALL_DIMENSIONS );
+ bool RelayoutDependentOnChildrenBase(Dimension::Type dimension = Dimension::ALL_DIMENSIONS);
public: // From Control
-
/**
* @ref Dali::Toolkit::DevelControl::RegisterVisual()
*/
- void RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual );
+ void RegisterVisual(Property::Index index, Toolkit::Visual::Base& visual);
/**
* @ref Dali::Toolkit::DevelControl::RegisterVisual()
*/
- void RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, int depthIndex );
+ void RegisterVisual(Property::Index index, Toolkit::Visual::Base& visual, int depthIndex);
/**
* @ref Dali::Toolkit::DevelControl::RegisterVisual()
*/
- void RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, bool enabled );
+ void RegisterVisual(Property::Index index, Toolkit::Visual::Base& visual, bool enabled);
/**
* @ref Dali::Toolkit::DevelControl::RegisterVisual()
*/
- void RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, bool enabled, int depthIndex );
+ void RegisterVisual(Property::Index index, Toolkit::Visual::Base& visual, bool enabled, int depthIndex);
/**
* @ref Dali::Toolkit::DevelControl::UnregisterVisual()
*/
- void UnregisterVisual( Property::Index index );
+ void UnregisterVisual(Property::Index index);
/**
* @ref Dali::Toolkit::DevelControl::GetVisual()
*/
- Toolkit::Visual::Base GetVisual( Property::Index index ) const;
+ Toolkit::Visual::Base GetVisual(Property::Index index) const;
/**
* @ref Dali::Toolkit::DevelControl::EnableVisual()
*/
- void EnableVisual( Property::Index index, bool enable );
+ void EnableVisual(Property::Index index, bool enable);
/**
* @ref Dali::Toolkit::DevelControl::IsVisualEnabled()
*/
- bool IsVisualEnabled( Property::Index index ) const;
+ bool IsVisualEnabled(Property::Index index) const;
/**
* @ref Dali::Toolkit::DevelControl::CreateTransition()
*/
- Dali::Animation CreateTransition( const Toolkit::TransitionData& transitionData );
+ Dali::Animation CreateTransition(const Toolkit::TransitionData& transitionData);
/**
* @copydoc Dali::Toolkit::Internal::Control::EmitKeyInputFocusSignal()
*/
- void EmitKeyInputFocusSignal( bool focusGained );
+ void EmitKeyInputFocusSignal(bool focusGained);
/**
* @brief Apply the current style
Dali::TypeInfo GetTypeInfo();
protected:
-
/**
* Protected Destructor
* A reference counted object may only be deleted by calling Unreference()
virtual ~ControlWrapper();
private:
-
/// @cond internal
/// Undefined.
- DALI_INTERNAL ControlWrapper( const ControlWrapper& );
+ DALI_INTERNAL ControlWrapper(const ControlWrapper&);
/// Undefined.
- DALI_INTERNAL ControlWrapper& operator=( const ControlWrapper& rhs );
+ DALI_INTERNAL ControlWrapper& operator=(const ControlWrapper& rhs);
/// @endcond
};
// Helpers for public-api forwarding methods
-inline Toolkit::Internal::ControlWrapper& GetControlWrapperImpl( Toolkit::ControlWrapper& publicObject )
+inline Toolkit::Internal::ControlWrapper& GetControlWrapperImpl(Toolkit::ControlWrapper& publicObject)
{
- DALI_ASSERT_ALWAYS( publicObject );
+ DALI_ASSERT_ALWAYS(publicObject);
Dali::RefObject& handle = publicObject.GetImplementation();
- return static_cast<Toolkit::Internal::ControlWrapper&>( handle );
+ return static_cast<Toolkit::Internal::ControlWrapper&>(handle);
}
-inline const Toolkit::Internal::ControlWrapper& GetControlWrapperImpl( const Toolkit::ControlWrapper& publicObject )
+inline const Toolkit::Internal::ControlWrapper& GetControlWrapperImpl(const Toolkit::ControlWrapper& publicObject)
{
- DALI_ASSERT_ALWAYS( publicObject );
+ DALI_ASSERT_ALWAYS(publicObject);
const Dali::RefObject& handle = publicObject.GetImplementation();
- return static_cast<const Toolkit::Internal::ControlWrapper&>( handle );
+ return static_cast<const Toolkit::Internal::ControlWrapper&>(handle);
}
} // namespace Toolkit
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
///////////////////////////////////////////////////////////////////////////////////////////////////
// ControlWrapper
///////////////////////////////////////////////////////////////////////////////////////////////////
-ControlWrapper ControlWrapper::New( const std::string& typeName, Internal::ControlWrapper& implementation )
+ControlWrapper ControlWrapper::New(const std::string& typeName, Internal::ControlWrapper& implementation)
{
- return Internal::ControlWrapper::New( typeName, &implementation );
+ return Internal::ControlWrapper::New(typeName, &implementation);
}
ControlWrapper::ControlWrapper()
{
}
-ControlWrapper::ControlWrapper( const ControlWrapper& handle )
-: Control( handle )
+ControlWrapper::ControlWrapper(const ControlWrapper& handle)
+: Control(handle)
{
}
-ControlWrapper& ControlWrapper::operator=( const ControlWrapper& handle )
+ControlWrapper& ControlWrapper::operator=(const ControlWrapper& handle)
{
- if( &handle != this )
+ if(&handle != this)
{
- Control::operator=( handle );
+ Control::operator=(handle);
}
return *this;
}
-ControlWrapper::ControlWrapper( Internal::ControlWrapper& implementation )
-: Control( implementation )
+ControlWrapper::ControlWrapper(Internal::ControlWrapper& implementation)
+: Control(implementation)
{
}
-ControlWrapper::ControlWrapper( Dali::Internal::CustomActor* internal )
-: Control( internal )
+ControlWrapper::ControlWrapper(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
- VerifyCustomActorPointer<Internal::ControlWrapper>( internal );
+ VerifyCustomActorPointer<Internal::ControlWrapper>(internal);
}
ControlWrapper::~ControlWrapper()
{
}
-ControlWrapper ControlWrapper::DownCast( BaseHandle handle )
+ControlWrapper ControlWrapper::DownCast(BaseHandle handle)
{
- return Control::DownCast<ControlWrapper, Internal::ControlWrapper>( handle );
+ return Control::DownCast<ControlWrapper, Internal::ControlWrapper>(handle);
}
} // namespace Toolkit
#define DALI_TOOLKIT_CONTROL_WRAPPER_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class ControlWrapper;
*/
class DALI_TOOLKIT_API ControlWrapper : public Control
{
-
public:
-
/**
* @brief Create a new instance of a ControlWrapper.
*
*
* @return A handle to a new ControlWrapper.
*/
- static ControlWrapper New( const std::string& typeName, Internal::ControlWrapper& implementation );
+ static ControlWrapper New(const std::string& typeName, Internal::ControlWrapper& implementation);
/**
* @brief Creates an empty ControlWrapper handle.
* Creates another handle that points to the same real object
* @param[in] handle Handle to the copied object
*/
- ControlWrapper( const ControlWrapper& handle );
+ ControlWrapper(const ControlWrapper& handle);
/**
* @brief Assignment operator.
* @param[in] handle Handle to the object
* @return A reference to this
*/
- ControlWrapper& operator=( const ControlWrapper& handle );
+ ControlWrapper& operator=(const ControlWrapper& handle);
/**
* @brief Downcast an Object handle to ControlWrapper.
* @param[in] handle Handle to an object
* @return handle to a ControlWrapper or an uninitialized handle
*/
- static ControlWrapper DownCast( BaseHandle handle );
+ static ControlWrapper DownCast(BaseHandle handle);
public: // Not intended for application developers
-
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
*
* @param[in] implementation The Control implementation.
*/
- ControlWrapper( Internal::ControlWrapper& implementation );
+ ControlWrapper(Internal::ControlWrapper& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- explicit ControlWrapper( Dali::Internal::CustomActor* internal );
+ explicit ControlWrapper(Dali::Internal::CustomActor* internal);
};
} // namespace Toolkit
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
-EffectsView EffectsView::New( EffectType type )
+EffectsView EffectsView::New(EffectType type)
{
EffectsView effectsView = Internal::EffectsView::New();
- GetImpl(effectsView).SetType( type );
+ GetImpl(effectsView).SetType(type);
return effectsView;
}
{
}
-EffectsView::EffectsView( const EffectsView& handle )
-: Control( handle )
+EffectsView::EffectsView(const EffectsView& handle)
+: Control(handle)
{
}
-EffectsView& EffectsView::operator=( const EffectsView& rhs )
+EffectsView& EffectsView::operator=(const EffectsView& rhs)
{
- if( &rhs != this )
+ if(&rhs != this)
{
Control::operator=(rhs);
}
return *this;
}
-EffectsView EffectsView::DownCast( BaseHandle handle )
+EffectsView EffectsView::DownCast(BaseHandle handle)
{
return Control::DownCast<EffectsView, Internal::EffectsView>(handle);
}
GetImpl(*this).Refresh();
}
-void EffectsView::SetRefreshOnDemand( bool onDemand )
+void EffectsView::SetRefreshOnDemand(bool onDemand)
{
- GetImpl(*this).SetRefreshOnDemand( onDemand );
+ GetImpl(*this).SetRefreshOnDemand(onDemand);
}
-void EffectsView::SetPixelFormat( Pixel::Format pixelFormat )
+void EffectsView::SetPixelFormat(Pixel::Format pixelFormat)
{
- GetImpl(*this).SetPixelFormat( pixelFormat );
+ GetImpl(*this).SetPixelFormat(pixelFormat);
}
-void EffectsView::SetBackgroundColor( const Vector4& color )
+void EffectsView::SetBackgroundColor(const Vector4& color)
{
GetImpl(*this).SetBackgroundColor(color);
}
return GetImpl(*this).GetBackgroundColor();
}
-
-EffectsView::EffectsView( Internal::EffectsView& implementation )
-: Control( implementation )
+EffectsView::EffectsView(Internal::EffectsView& implementation)
+: Control(implementation)
{
}
-EffectsView::EffectsView( Dali::Internal::CustomActor* internal )
-: Control( internal )
+EffectsView::EffectsView(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::EffectsView>(internal);
}
-
} //namespace Toolkit
} //namespace Dali
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
-
class EffectsView;
-} // namespace Internal
+} // namespace DALI_INTERNAL
/**
* EffectsView: Applies an effect to a tree of actors
class DALI_TOOLKIT_API EffectsView : public Control
{
public:
-
enum EffectType
{
DROP_SHADOW,
*/
enum PropertyRange
{
- PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_0.0
+ PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_0.0
- ANIMATABLE_PROPERTY_START_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX, ///< @SINCE_1_1.18
- ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve animatable property indices, @SINCE_1_1.18
+ ANIMATABLE_PROPERTY_START_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX, ///< @SINCE_1_1.18
+ ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve animatable property indices, @SINCE_1_1.18
};
/**
enum
{
// Event side properties
- EFFECT_SIZE = PROPERTY_START_INDEX, ///< name "effectSize", type INTEGER
+ EFFECT_SIZE = PROPERTY_START_INDEX, ///< name "effectSize", type INTEGER
// Animatable properties
EFFECT_OFFSET = ANIMATABLE_PROPERTY_START_INDEX, ///< name "effectOffset", type VECTOR3
};
public:
-
/**
* Create an EffectsView object with default configuration
* @param[in] type The type of effect to be performed by the EffectView.
* A member of the EffectType enumeration.
*/
- static EffectsView New( EffectType type );
+ static EffectsView New(EffectType type);
/**
* Create an uninitialized EffectsView. Only derived versions can be instantiated.
/**
* Copy constructor.
*/
- EffectsView( const EffectsView& handle );
+ EffectsView(const EffectsView& handle);
/**
* Assignment operator.
*/
- EffectsView& operator=( const EffectsView& rhs );
+ EffectsView& operator=(const EffectsView& rhs);
/**
* Downcast an Object handle to EffectsView. If handle points to a EffectsView the
* @param[in] handle Handle to an object
* @return handle to a EffectsView or an uninitialized handle
*/
- static EffectsView DownCast( BaseHandle handle );
+ static EffectsView DownCast(BaseHandle handle);
/**
* @brief Destructor
~EffectsView();
public:
-
/**
* Get the effect type
* @return The type of effect performed by the EffectView. A member of the EffectType enumeration.
* @param[in] onDemand Set true to enable on demand rendering, call Refresh() whenever a render is required.
* Set false to render each frame. (EffectsView refresh mode is set to continuous by default).
*/
- void SetRefreshOnDemand( bool onDemand );
+ void SetRefreshOnDemand(bool onDemand);
- /**
+ /**
* Set the pixel format for the output
* @param[in] pixelFormat The pixel format for the output
*/
- void SetPixelFormat( Pixel::Format pixelFormat );
+ void SetPixelFormat(Pixel::Format pixelFormat);
- /**
+ /**
* Set background color for the view. The background will be filled with this color.
* @param[in] color The background color.
*/
- void SetBackgroundColor( const Vector4& color );
+ void SetBackgroundColor(const Vector4& color);
- /**
+ /**
* Get the background color.
* @return The background color.
*/
- Vector4 GetBackgroundColor() const;
+ Vector4 GetBackgroundColor() const;
public: // Not intended for application developers
-
/**
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL EffectsView( Internal::EffectsView& implementation );
+ DALI_INTERNAL EffectsView(Internal::EffectsView& implementation);
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- explicit DALI_INTERNAL EffectsView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL EffectsView(Dali::Internal::CustomActor* internal);
}; // class EffectsView
namespace Dali
{
-
namespace Toolkit
{
-
GaussianBlurView::GaussianBlurView()
{
}
}
GaussianBlurView::GaussianBlurView(const GaussianBlurView& handle)
- : Control( handle )
+: Control(handle)
{
}
GaussianBlurView& GaussianBlurView::operator=(const GaussianBlurView& rhs)
{
- if( &rhs != this )
+ if(&rhs != this)
{
Control::operator=(rhs);
}
return Internal::GaussianBlurView::New();
}
-GaussianBlurView GaussianBlurView::New( const unsigned int numSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat,
- const float downsampleWidthScale, const float downsampleHeightScale,
- bool blurUserImage)
+GaussianBlurView GaussianBlurView::New(const unsigned int numSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat, const float downsampleWidthScale, const float downsampleHeightScale, bool blurUserImage)
{
- return Internal::GaussianBlurView::New( numSamples, blurBellCurveWidth, renderTargetPixelFormat,
- downsampleWidthScale, downsampleHeightScale,
- blurUserImage);
+ return Internal::GaussianBlurView::New(numSamples, blurBellCurveWidth, renderTargetPixelFormat, downsampleWidthScale, downsampleHeightScale, blurUserImage);
}
-GaussianBlurView::GaussianBlurView( Internal::GaussianBlurView& implementation )
-: Control( implementation )
+GaussianBlurView::GaussianBlurView(Internal::GaussianBlurView& implementation)
+: Control(implementation)
{
}
-GaussianBlurView::GaussianBlurView( Dali::Internal::CustomActor* internal )
-: Control( internal )
+GaussianBlurView::GaussianBlurView(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::GaussianBlurView>(internal);
}
-GaussianBlurView GaussianBlurView::DownCast( BaseHandle handle )
+GaussianBlurView GaussianBlurView::DownCast(BaseHandle handle)
{
return Control::DownCast<GaussianBlurView, Internal::GaussianBlurView>(handle);
}
return GetImpl(*this).GetBlurredRenderTarget();
}
-void GaussianBlurView::SetBackgroundColor( const Vector4& color )
+void GaussianBlurView::SetBackgroundColor(const Vector4& color)
{
GetImpl(*this).SetBackgroundColor(color);
}
// EXTERNAL INCLUDES
#include <dali/public-api/actors/camera-actor.h>
#include <dali/public-api/common/dali-vector.h>
+#include <dali/public-api/render-tasks/render-task.h>
#include <dali/public-api/rendering/frame-buffer.h>
#include <dali/public-api/rendering/texture.h>
-#include <dali/public-api/render-tasks/render-task.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
-
/**
* GaussianBlurView implementation class
*/
*/
class BloomView;
-} // namespace Internal
+} // namespace DALI_INTERNAL
/**
* @addtogroup dali_toolkit_controls_gaussian_blur_view
* @{
* @brief Signal type for notifications
* @SINCE_1_0.0
*/
- typedef Signal< void (GaussianBlurView source) > GaussianBlurViewSignal;
+ typedef Signal<void(GaussianBlurView source)> GaussianBlurViewSignal;
/**
* @brief Create an uninitialized GaussianBlurView; this can be initialized with GaussianBlurView::New().
* @param[in] handle Handle to an object
* @return A handle to a GaussianBlurView or an uninitialized handle
*/
- static GaussianBlurView DownCast( BaseHandle handle );
+ static GaussianBlurView DownCast(BaseHandle handle);
/**
* @brief Create an initialized GaussianBlurView, using default settings. The default settings are:-\n
* SetUserImageAndOutputRenderTarget().
* @return A handle to a newly allocated Dali resource
*/
- static GaussianBlurView New(const unsigned int numSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat,
- const float downsampleWidthScale, const float downsampleHeightScale,
- bool blurUserImage = false);
+ static GaussianBlurView New(const unsigned int numSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat, const float downsampleWidthScale, const float downsampleHeightScale, bool blurUserImage = false);
/**
* @brief Start rendering the GaussianBlurView. Must be called after you Add() it to the stage.
* @SINCE_1_0.0
* @param[in] color The background color.
*/
- void SetBackgroundColor( const Vector4& color );
+ void SetBackgroundColor(const Vector4& color);
/**
* @brief Get the background color.
GaussianBlurViewSignal& FinishedSignal();
public:
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] implementation The UI Control implementation.
*/
- DALI_INTERNAL GaussianBlurView( Internal::GaussianBlurView& implementation );
+ DALI_INTERNAL GaussianBlurView(Internal::GaussianBlurView& implementation);
/**
* @brief Allows the creation of this UI Control from an Internal::CustomActor pointer.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor.
*/
- DALI_INTERNAL GaussianBlurView( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL GaussianBlurView(Dali::Internal::CustomActor* internal);
/// @endcond
-
};
/**
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace
{
-
} // unnamed namespace
namespace Dali
{
-
namespace Toolkit
{
-
///////////////////////////////////////////////////////////////////////////////////////////////////
// Magnifier
///////////////////////////////////////////////////////////////////////////////////////////////////
{
}
-Magnifier::Magnifier( const Magnifier& handle )
-: Control( handle )
+Magnifier::Magnifier(const Magnifier& handle)
+: Control(handle)
{
}
-Magnifier& Magnifier::operator=( const Magnifier& handle )
+Magnifier& Magnifier::operator=(const Magnifier& handle)
{
- if( &handle != this )
+ if(&handle != this)
{
- Control::operator=( handle );
+ Control::operator=(handle);
}
return *this;
}
{
}
-Magnifier::Magnifier( Dali::Internal::CustomActor* internal )
-: Control( internal )
+Magnifier::Magnifier(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::Magnifier>(internal);
}
{
}
-Magnifier Magnifier::DownCast( BaseHandle handle )
+Magnifier Magnifier::DownCast(BaseHandle handle)
{
return Control::DownCast<Magnifier, Internal::Magnifier>(handle);
}
void Magnifier::SetSourceActor(Actor actor)
{
- GetImpl(*this).SetSourceActor( actor );
+ GetImpl(*this).SetSourceActor(actor);
}
} // namespace Toolkit
#define DALI_TOOLKIT_MAGNIFIER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class Magnifier;
class DALI_TOOLKIT_API Magnifier : public Control
{
public:
-
/**
* @brief The start and end property ranges for this control.
*/
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1,
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices
ANIMATABLE_PROPERTY_START_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX,
- ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve animatable property indices
+ ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve animatable property indices
};
/**
enum
{
// Event side properties
- FRAME_VISIBILITY = PROPERTY_START_INDEX, ///< name "frameVisibility", Whether a frame is visible or not, type boolean
- MAGNIFICATION_FACTOR, ///< name "magnificationFactor", Larger value means greater magnification, type float
+ FRAME_VISIBILITY = PROPERTY_START_INDEX, ///< name "frameVisibility", Whether a frame is visible or not, type boolean
+ MAGNIFICATION_FACTOR, ///< name "magnificationFactor", Larger value means greater magnification, type float
// Animatable properties
SOURCE_POSITION = ANIMATABLE_PROPERTY_START_INDEX, ///< name "sourcePosition", The position of the source, type Vector3
};
public:
-
/**
* Creates an empty Magnifier handle
*/
* Copy constructor. Creates another handle that points to the same real object
* @param handle to copy from
*/
- Magnifier( const Magnifier& handle );
+ Magnifier(const Magnifier& handle);
/**
* Assignment operator. Changes this handle to point to another real object
*/
- Magnifier& operator=( const Magnifier& handle );
+ Magnifier& operator=(const Magnifier& handle);
/**
* @brief Destructor
* @param[in] handle Handle to an object
* @return handle to a Magnifier or an uninitialized handle
*/
- static Magnifier DownCast( BaseHandle handle );
+ static Magnifier DownCast(BaseHandle handle);
public:
-
/**
* Set the actors to be rendered in magnifier.
* @param[in] actor This actor and its children will be rendered.
void SetSourceActor(Actor actor);
public: // Not intended for application developers
-
/**
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
NavigationView::NavigationView()
{
}
-NavigationView::NavigationView( const NavigationView& handle )
+NavigationView::NavigationView(const NavigationView& handle)
: Control(handle)
{
}
-NavigationView& NavigationView::operator=( const NavigationView& handle)
+NavigationView& NavigationView::operator=(const NavigationView& handle)
{
- if( &handle != this )
+ if(&handle != this)
{
- Control::operator=( handle );
+ Control::operator=(handle);
}
return *this;
}
return Internal::NavigationView::New();
}
-NavigationView NavigationView::DownCast( BaseHandle handle )
+NavigationView NavigationView::DownCast(BaseHandle handle)
{
return Control::DownCast<NavigationView, Internal::NavigationView>(handle);
}
-NavigationView::NavigationView( Internal::NavigationView& implementation )
-: Control( implementation )
+NavigationView::NavigationView(Internal::NavigationView& implementation)
+: Control(implementation)
{
}
-NavigationView::NavigationView( Dali::Internal::CustomActor* internal )
-: Control( internal)
+NavigationView::NavigationView(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::NavigationView>(internal);
}
-
-void NavigationView::Push( Actor actor )
+void NavigationView::Push(Actor actor)
{
- GetImpl( *this ).Push( actor );
+ GetImpl(*this).Push(actor);
}
Actor NavigationView::Pop()
{
- return GetImpl( *this ).Pop();
+ return GetImpl(*this).Pop();
}
} // namespace Toolkit
#define DALI_TOOLKIT_NAVIGATION_VIEW_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/animation/alpha-function.h>
#include <dali-toolkit/public-api/controls/control.h>
+#include <dali/public-api/animation/alpha-function.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
// Forward declarations
class NavigationView;
-}
+} // namespace DALI_INTERNAL
/**
* @brief NavigationView implements a view that manages the navigation of hierarchical contents.
*/
class DALI_TOOLKIT_API NavigationView : public Control
{
-
public:
-
/**
* @brief Create a NavigationView handle; this can be initialize with NavigationView::New().
*
* @brief Copy Constructor.
* @param[in] handle Handle to copy.
*/
- NavigationView( const NavigationView& handle );
+ NavigationView(const NavigationView& handle);
- /**
+ /**
* @brief Assignment operator.
* @param handle The handle to copy from.
* @return reference to this
*/
- NavigationView& operator=( const NavigationView& handle );
+ NavigationView& operator=(const NavigationView& handle);
/**
* @brief Destructor
* @param[in] handle Handle to an object.
* @return handle to a NavigationView of an uninitialized handle.
*/
- static NavigationView DownCast( BaseHandle handle );
+ static NavigationView DownCast(BaseHandle handle);
/**
* @brief Push a new actor tree to the top of the NavigationView stack and show it.
* @param[in] item An actor tree.
*/
- void Push( Actor item );
+ void Push(Actor item);
/**
* @brief Pop the actor tree that is on the top of the NavigationView stack and make it disappear.
*/
Actor Pop();
-
public: // Not intended for application developers
-
-/// @cond internal
+ /// @cond internal
/**
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL NavigationView( Internal::NavigationView& implementation );
+ DALI_INTERNAL NavigationView(Internal::NavigationView& implementation);
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- explicit DALI_INTERNAL NavigationView( Dali::Internal::CustomActor* internal );
-/// @endcond
+ explicit DALI_INTERNAL NavigationView(Dali::Internal::CustomActor* internal);
+ /// @endcond
}; // class NavigationView
} // namespace Toolkit
#define DALI_TOOLKIT_PAGE_FACTORY_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @brief PageFactory is an abstract interface for providing textures to PageTurnView
* Each page is identified by a unique ID, and has a linear order from 0 to GetNumberOfPages()-1
class DALI_TOOLKIT_API PageFactory
{
public:
-
class Extension; ///< Forward declare future extension interface
/**
* @param[in] pageId The ID of the page to create.
* @return An actor, or an uninitialized pointer if the ID is out of range.
*/
- virtual Texture NewPage( unsigned int pageId ) = 0;
+ virtual Texture NewPage(unsigned int pageId) = 0;
/**
* @brief Retrieve the extension for this factory
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
PageTurnLandscapeView::PageTurnLandscapeView()
: PageTurnView()
{
}
-PageTurnLandscapeView::PageTurnLandscapeView( const PageTurnLandscapeView& pageTurnLandscapeView )
-: PageTurnView( pageTurnLandscapeView )
+PageTurnLandscapeView::PageTurnLandscapeView(const PageTurnLandscapeView& pageTurnLandscapeView)
+: PageTurnView(pageTurnLandscapeView)
{
}
-PageTurnLandscapeView::PageTurnLandscapeView( Internal::PageTurnLandscapeView& implementation )
-: PageTurnView( implementation )
+PageTurnLandscapeView::PageTurnLandscapeView(Internal::PageTurnLandscapeView& implementation)
+: PageTurnView(implementation)
{
}
-PageTurnLandscapeView::PageTurnLandscapeView( Dali::Internal::CustomActor* internal )
-: PageTurnView( internal )
+PageTurnLandscapeView::PageTurnLandscapeView(Dali::Internal::CustomActor* internal)
+: PageTurnView(internal)
{
- VerifyCustomActorPointer<Internal::PageTurnLandscapeView>( internal );
+ VerifyCustomActorPointer<Internal::PageTurnLandscapeView>(internal);
}
-PageTurnLandscapeView& PageTurnLandscapeView::operator=( const PageTurnLandscapeView& pageTurnLandscapeView )
+PageTurnLandscapeView& PageTurnLandscapeView::operator=(const PageTurnLandscapeView& pageTurnLandscapeView)
{
- if( &pageTurnLandscapeView != this)
+ if(&pageTurnLandscapeView != this)
{
- PageTurnView::operator=( pageTurnLandscapeView );
+ PageTurnView::operator=(pageTurnLandscapeView);
}
return *this;
}
{
}
-PageTurnLandscapeView PageTurnLandscapeView::New( PageFactory& pageFactory, const Vector2& viewPageSize )
+PageTurnLandscapeView PageTurnLandscapeView::New(PageFactory& pageFactory, const Vector2& viewPageSize)
{
return Internal::PageTurnLandscapeView::New(pageFactory, viewPageSize);
}
-PageTurnLandscapeView PageTurnLandscapeView::DownCast( BaseHandle handle )
+PageTurnLandscapeView PageTurnLandscapeView::DownCast(BaseHandle handle)
{
- return Control::DownCast<PageTurnLandscapeView, Internal::PageTurnLandscapeView>( handle );
+ return Control::DownCast<PageTurnLandscapeView, Internal::PageTurnLandscapeView>(handle);
}
} // namespace Toolkit
#define DALI_TOOLKIT_PAGE_TURN_LANDSCAPE_VIEW_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
// Forward declarations
class PageTurnLandscapeView;
-}
+} // namespace DALI_INTERNAL
/**
* @brief PageTurnLandscapeView provides a page turn view in landscape mode
* @brief Copy constructor.
* @SINCE_1_0.0
*/
- PageTurnLandscapeView( const PageTurnLandscapeView& pageTurnLandscapeView );
+ PageTurnLandscapeView(const PageTurnLandscapeView& pageTurnLandscapeView);
/**
* @brief Assignment operator.
* @SINCE_1_0.0
*/
- PageTurnLandscapeView& operator=( const PageTurnLandscapeView& pageTurnLandscapeView );
+ PageTurnLandscapeView& operator=(const PageTurnLandscapeView& pageTurnLandscapeView);
/**
* @brief Destructor
* @param[in] viewPageSize The size of the page
* @return A handle to the PageTurnLandscapeView control.
*/
- static PageTurnLandscapeView New( PageFactory& pageFactory, const Vector2& viewPageSize );
+ static PageTurnLandscapeView New(PageFactory& pageFactory, const Vector2& viewPageSize);
/**
* @brief Downcast an Object handle to PageTurnPortraitView. If handle points to a PageTurnLandscapeView the
* @param[in] handle Handle to an object
* @return handle to a PageTurnLandscapeView or an uninitialized handle
*/
- static PageTurnLandscapeView DownCast( BaseHandle handle );
+ static PageTurnLandscapeView DownCast(BaseHandle handle);
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL PageTurnLandscapeView( Internal::PageTurnLandscapeView& implementation );
+ DALI_INTERNAL PageTurnLandscapeView(Internal::PageTurnLandscapeView& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor.
*/
- explicit DALI_INTERNAL PageTurnLandscapeView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL PageTurnLandscapeView(Dali::Internal::CustomActor* internal);
/// @endcond
};
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
PageTurnPortraitView::PageTurnPortraitView()
: PageTurnView()
{
}
-PageTurnPortraitView::PageTurnPortraitView( const PageTurnPortraitView& pageTurnPortraitView )
-: PageTurnView( pageTurnPortraitView )
+PageTurnPortraitView::PageTurnPortraitView(const PageTurnPortraitView& pageTurnPortraitView)
+: PageTurnView(pageTurnPortraitView)
{
}
-PageTurnPortraitView::PageTurnPortraitView( Internal::PageTurnPortraitView& implementation )
-: PageTurnView( implementation )
+PageTurnPortraitView::PageTurnPortraitView(Internal::PageTurnPortraitView& implementation)
+: PageTurnView(implementation)
{
}
-PageTurnPortraitView::PageTurnPortraitView( Dali::Internal::CustomActor* internal )
-: PageTurnView( internal )
+PageTurnPortraitView::PageTurnPortraitView(Dali::Internal::CustomActor* internal)
+: PageTurnView(internal)
{
- VerifyCustomActorPointer<Internal::PageTurnPortraitView>( internal );
+ VerifyCustomActorPointer<Internal::PageTurnPortraitView>(internal);
}
-PageTurnPortraitView& PageTurnPortraitView::operator=( const PageTurnPortraitView& pageTurnPortraitView )
+PageTurnPortraitView& PageTurnPortraitView::operator=(const PageTurnPortraitView& pageTurnPortraitView)
{
- if( &pageTurnPortraitView != this)
+ if(&pageTurnPortraitView != this)
{
- PageTurnView::operator=( pageTurnPortraitView );
+ PageTurnView::operator=(pageTurnPortraitView);
}
return *this;
}
{
}
-PageTurnPortraitView PageTurnPortraitView::New( PageFactory& pageFactory, const Vector2& viewPageSize)
+PageTurnPortraitView PageTurnPortraitView::New(PageFactory& pageFactory, const Vector2& viewPageSize)
{
return Internal::PageTurnPortraitView::New(pageFactory, viewPageSize);
}
-PageTurnPortraitView PageTurnPortraitView::DownCast( BaseHandle handle )
+PageTurnPortraitView PageTurnPortraitView::DownCast(BaseHandle handle)
{
- return Control::DownCast<PageTurnPortraitView, Internal::PageTurnPortraitView>( handle );
+ return Control::DownCast<PageTurnPortraitView, Internal::PageTurnPortraitView>(handle);
}
} // namespace Toolkit
#define DALI_TOOLKIT_PAGE_TURN_PORTRAIT_VIEW_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
// Forward declarations
class PageTurnPortraitView;
-}
+} // namespace DALI_INTERNAL
/**
* @brief PageTurnPortraitView provides a page turn view in portrait mode
* @brief Copy constructor.
* @SINCE_1_1.4
*/
- PageTurnPortraitView( const PageTurnPortraitView& pageTurnPortraitView );
+ PageTurnPortraitView(const PageTurnPortraitView& pageTurnPortraitView);
/**
* @brief Assignment operator.
* @SINCE_1_1.4
*/
- PageTurnPortraitView& operator=( const PageTurnPortraitView& pageTurnPortraitView );
+ PageTurnPortraitView& operator=(const PageTurnPortraitView& pageTurnPortraitView);
/**
* @brief Destructor
* @param[in] viewPageSize The size of the page
* @return A handle to the PageTurnPortraitView control.
*/
- static PageTurnPortraitView New( PageFactory& pageFactory, const Vector2& viewPageSize );
+ static PageTurnPortraitView New(PageFactory& pageFactory, const Vector2& viewPageSize);
/**
* @brief Downcast an Object handle to PageTurnPortraitView. If handle points to a PageTurnPortraitView the
* @param[in] handle Handle to an object
* @return handle to a PageTurnPortraitView or an uninitialized handle
*/
- static PageTurnPortraitView DownCast( BaseHandle handle );
+ static PageTurnPortraitView DownCast(BaseHandle handle);
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_1.4
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL PageTurnPortraitView( Internal::PageTurnPortraitView& implementation );
+ DALI_INTERNAL PageTurnPortraitView(Internal::PageTurnPortraitView& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @SINCE_1_1.4
* @param[in] internal A pointer to the internal CustomActor.
*/
- explicit DALI_INTERNAL PageTurnPortraitView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL PageTurnPortraitView(Dali::Internal::CustomActor* internal);
/// @endcond
};
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
PageTurnView::PageTurnView()
{
}
-PageTurnView::PageTurnView( const PageTurnView& handle )
-: Control( handle )
+PageTurnView::PageTurnView(const PageTurnView& handle)
+: Control(handle)
{
}
-PageTurnView& PageTurnView::operator=( const PageTurnView& handle )
+PageTurnView& PageTurnView::operator=(const PageTurnView& handle)
{
- if( &handle != this )
+ if(&handle != this)
{
- Control::operator=( handle );
+ Control::operator=(handle);
}
return *this;
}
{
}
-PageTurnView PageTurnView::DownCast( BaseHandle handle )
+PageTurnView PageTurnView::DownCast(BaseHandle handle)
{
return Control::DownCast<PageTurnView, Internal::PageTurnView>(handle);
}
-PageTurnView::PageTurnView( Internal::PageTurnView& implementation )
-: Control( implementation )
+PageTurnView::PageTurnView(Internal::PageTurnView& implementation)
+: Control(implementation)
{
}
-PageTurnView::PageTurnView( Dali::Internal::CustomActor* internal )
-: Control( internal )
+PageTurnView::PageTurnView(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::PageTurnView>(internal);
}
PageTurnView::PageTurnSignal& PageTurnView::PageTurnStartedSignal()
{
- return Toolkit::GetImplementation( *this ).PageTurnStartedSignal();
+ return Toolkit::GetImplementation(*this).PageTurnStartedSignal();
}
PageTurnView::PageTurnSignal& PageTurnView::PageTurnFinishedSignal()
{
- return Toolkit::GetImplementation( *this ).PageTurnFinishedSignal();
+ return Toolkit::GetImplementation(*this).PageTurnFinishedSignal();
}
PageTurnView::PagePanSignal& PageTurnView::PagePanStartedSignal()
{
- return Toolkit::GetImplementation( *this ).PagePanStartedSignal();
+ return Toolkit::GetImplementation(*this).PagePanStartedSignal();
}
PageTurnView::PagePanSignal& PageTurnView::PagePanFinishedSignal()
{
- return Toolkit::GetImplementation( *this ).PagePanFinishedSignal();
+ return Toolkit::GetImplementation(*this).PagePanFinishedSignal();
}
} // namespace Toolkit
#define DALI_TOOLKIT_PAGE_TURN_VIEW_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
// Forward declarations
class PageFactory;
class DALI_TOOLKIT_API PageTurnView : public Control
{
public:
-
/**
* @brief The start and end property ranges for this control.
* @SINCE_1_1.4
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_1.4
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices @SINCE_1_1.4
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices @SINCE_1_1.4
};
struct Property
* The two values are the major&minor radius (in pixels) to form an ellipse shape.
* The top-left quarter of this ellipse is used to calculate spine normal for simulating shadow.
*/
- SPINE_SHADOW, ///< name "spineShadow", type Vector2 @SINCE_1_1.4
+ SPINE_SHADOW, ///< name "spineShadow", type Vector2 @SINCE_1_1.4
};
};
* @SINCE_1_1.4
* @param[in] handle Handle to copy from
*/
- PageTurnView( const PageTurnView& handle );
+ PageTurnView(const PageTurnView& handle);
/**
* @brief Assignment operator. Changes this handle to point to another real object
* @SINCE_1_1.4
*/
- PageTurnView& operator=( const PageTurnView& handle );
+ PageTurnView& operator=(const PageTurnView& handle);
/**
* @brief Destructor
* @param[in] handle Handle to an object
* @return handle to a PageTurnView or an uninitialized handle
*/
- static PageTurnView DownCast( BaseHandle handle );
+ static PageTurnView DownCast(BaseHandle handle);
public: //Signal
-
// Page Turned signal, with page index and boolean turning direction (true = forward, false = backward)
- typedef Signal< void ( PageTurnView, unsigned int, bool ) > PageTurnSignal;
- typedef Signal< void ( PageTurnView ) > PagePanSignal;
+ typedef Signal<void(PageTurnView, unsigned int, bool)> PageTurnSignal;
+ typedef Signal<void(PageTurnView)> PagePanSignal;
/**
* @brief Signal emitted when a page has started to turn over.
PagePanSignal& PagePanFinishedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
-
ConfirmationPopup::ConfirmationPopup()
: Popup()
{
}
-ConfirmationPopup::ConfirmationPopup( Internal::ConfirmationPopup& implementation )
-: Popup( implementation )
+ConfirmationPopup::ConfirmationPopup(Internal::ConfirmationPopup& implementation)
+: Popup(implementation)
{
}
-ConfirmationPopup::ConfirmationPopup( const ConfirmationPopup& confirmationPopup )
-: Popup( confirmationPopup )
+ConfirmationPopup::ConfirmationPopup(const ConfirmationPopup& confirmationPopup)
+: Popup(confirmationPopup)
{
}
-ConfirmationPopup& ConfirmationPopup::operator=( const ConfirmationPopup& confirmationPopup )
+ConfirmationPopup& ConfirmationPopup::operator=(const ConfirmationPopup& confirmationPopup)
{
- if( &confirmationPopup != this )
+ if(&confirmationPopup != this)
{
- Popup::operator=( confirmationPopup );
+ Popup::operator=(confirmationPopup);
}
return *this;
}
-ConfirmationPopup::ConfirmationPopup( Dali::Internal::CustomActor* internal )
-: Popup( internal )
+ConfirmationPopup::ConfirmationPopup(Dali::Internal::CustomActor* internal)
+: Popup(internal)
{
- VerifyCustomActorPointer<Internal::ConfirmationPopup>( internal );
+ VerifyCustomActorPointer<Internal::ConfirmationPopup>(internal);
}
ConfirmationPopup::~ConfirmationPopup()
return Internal::ConfirmationPopup::New();
}
-ConfirmationPopup ConfirmationPopup::DownCast( BaseHandle handle )
+ConfirmationPopup ConfirmationPopup::DownCast(BaseHandle handle)
{
- return Control::DownCast<ConfirmationPopup, Internal::ConfirmationPopup>( handle );
+ return Control::DownCast<ConfirmationPopup, Internal::ConfirmationPopup>(handle);
}
-
} // namespace Toolkit
} // namespace Dali
#define DALI_TOOLKIT_CONFIRMATION_POPUP_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
// Forward declarations
namespace Internal DALI_INTERNAL
{
class DALI_TOOLKIT_API ConfirmationPopup : public Popup
{
public:
-
/**
* @brief The start and end property ranges for this control.
*/
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1 + DEFAULT_PROPERTY_MAX_COUNT_PER_DERIVATION + 1,
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
};
/**
*/
enum ControlIndex
{
- CONTROL_OK = 0, ///< Index of control 1
- CONTROL_CANCEL, ///< Index of control 2
+ CONTROL_OK = 0, ///< Index of control 1
+ CONTROL_CANCEL, ///< Index of control 2
};
/**
/**
* @brief Copy constructor.
*/
- ConfirmationPopup( const ConfirmationPopup& confirmationPopup );
+ ConfirmationPopup(const ConfirmationPopup& confirmationPopup);
/**
* @brief Assignment operator.
*/
- ConfirmationPopup& operator=( const ConfirmationPopup& confirmationPopup );
+ ConfirmationPopup& operator=(const ConfirmationPopup& confirmationPopup);
/**
* @brief Destructor.
* @param[in] handle Handle to an object
* @return handle to a ConfirmationPopup or an uninitialized handle
*/
- static ConfirmationPopup DownCast( BaseHandle handle );
+ static ConfirmationPopup DownCast(BaseHandle handle);
public: // Not intended for application developers
-
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
*
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL ConfirmationPopup( Internal::ConfirmationPopup& implementation );
+ DALI_INTERNAL ConfirmationPopup(Internal::ConfirmationPopup& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- DALI_INTERNAL ConfirmationPopup( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL ConfirmationPopup(Dali::Internal::CustomActor* internal);
};
} // namespace Toolkit
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
///////////////////////////////////////////////////////////////////////////////////////////////////
// Popup
///////////////////////////////////////////////////////////////////////////////////////////////////
{
}
-Popup::Popup( const Popup& handle )
-: Control( handle )
+Popup::Popup(const Popup& handle)
+: Control(handle)
{
}
-Popup& Popup::operator=( const Popup& handle )
+Popup& Popup::operator=(const Popup& handle)
{
- if( &handle != this )
+ if(&handle != this)
{
- Control::operator=( handle );
+ Control::operator=(handle);
}
return *this;
}
{
}
-Popup::Popup( Dali::Internal::CustomActor* internal )
-: Control( internal )
+Popup::Popup(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::Popup>(internal);
}
{
}
-Popup Popup::DownCast( BaseHandle handle )
+Popup Popup::DownCast(BaseHandle handle)
{
return Control::DownCast<Popup, Internal::Popup>(handle);
}
// Properties:
-void Popup::SetTitle( Actor titleActor )
+void Popup::SetTitle(Actor titleActor)
{
- GetImpl( *this ).SetTitle( titleActor );
+ GetImpl(*this).SetTitle(titleActor);
}
Actor Popup::GetTitle() const
{
- return GetImpl( *this ).GetTitle();
+ return GetImpl(*this).GetTitle();
}
-void Popup::SetContent( Actor content )
+void Popup::SetContent(Actor content)
{
- GetImpl( *this ).SetContent( content );
+ GetImpl(*this).SetContent(content);
}
Actor Popup::GetContent() const
{
- return GetImpl( *this ).GetContent();
+ return GetImpl(*this).GetContent();
}
-void Popup::SetFooter( Actor footer )
+void Popup::SetFooter(Actor footer)
{
- GetImpl( *this ).SetFooter( footer );
+ GetImpl(*this).SetFooter(footer);
}
Actor Popup::GetFooter() const
{
- return GetImpl( *this ).GetFooter();
+ return GetImpl(*this).GetFooter();
}
-void Popup::SetDisplayState( Toolkit::Popup::DisplayState displayState )
+void Popup::SetDisplayState(Toolkit::Popup::DisplayState displayState)
{
- GetImpl( *this ).SetDisplayState( displayState );
+ GetImpl(*this).SetDisplayState(displayState);
}
Toolkit::Popup::DisplayState Popup::GetDisplayState() const
{
- return GetImpl( *this ).GetDisplayState();
+ return GetImpl(*this).GetDisplayState();
}
// Signals:
Popup::TouchedOutsideSignalType& Popup::OutsideTouchedSignal()
{
- return GetImpl( *this ).OutsideTouchedSignal();
+ return GetImpl(*this).OutsideTouchedSignal();
}
Popup::DisplayStateChangeSignalType& Popup::ShowingSignal()
{
- return GetImpl( *this ).ShowingSignal();
+ return GetImpl(*this).ShowingSignal();
}
Popup::DisplayStateChangeSignalType& Popup::ShownSignal()
{
- return GetImpl( *this ).ShownSignal();
+ return GetImpl(*this).ShownSignal();
}
Popup::DisplayStateChangeSignalType& Popup::HidingSignal()
{
- return GetImpl( *this ).HidingSignal();
+ return GetImpl(*this).HidingSignal();
}
Popup::DisplayStateChangeSignalType& Popup::HiddenSignal()
{
- return GetImpl( *this ).HiddenSignal();
+ return GetImpl(*this).HiddenSignal();
}
} // namespace Toolkit
#define DALI_TOOLKIT_POPUP_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class Popup;
*/
class DALI_TOOLKIT_API Popup : public Control
{
-
public:
-
/**
* @brief The start and end property ranges for this control.
*/
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1,
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
};
/**
*/
enum DisplayState
{
- SHOWING, ///< The popup is transitioning in
- SHOWN, ///< The popup is fully shown
- HIDING, ///< The popup is transitioning out
- HIDDEN ///< The popup is fully hidden
+ SHOWING, ///< The popup is transitioning in
+ SHOWN, ///< The popup is fully shown
+ HIDING, ///< The popup is transitioning out
+ HIDDEN ///< The popup is fully hidden
};
/**
*/
enum AnimationMode
{
- NONE, ///< No animation.
- ZOOM, ///< Popup zooms in and out animating the scale property.
- FADE, ///< Popup fades in and out.
- CUSTOM ///< Use the EntryAnimation and ExitAnimation animation properties.
+ NONE, ///< No animation.
+ ZOOM, ///< Popup zooms in and out animating the scale property.
+ FADE, ///< Popup fades in and out.
+ CUSTOM ///< Use the EntryAnimation and ExitAnimation animation properties.
};
/**
};
public:
-
/**
* @brief Creates an empty Popup handle.
*/
* Creates another handle that points to the same real object
* @param[in] handle Handle to the copied object
*/
- Popup( const Popup& handle );
+ Popup(const Popup& handle);
/**
* @brief Assignment operator.
* @param[in] handle Handle to the object
* @return A reference to this
*/
- Popup& operator=( const Popup& handle );
+ Popup& operator=(const Popup& handle);
/**
* @brief Downcast an Object handle to Popup.
* @param[in] handle Handle to an object
* @return handle to a Popup or an uninitialized handle
*/
- static Popup DownCast( BaseHandle handle );
+ static Popup DownCast(BaseHandle handle);
public:
-
/**
* @brief Sets a title for this Popup.
*
* @param[in] titleActor Any actor can be specified when using this method.
*/
- void SetTitle( Actor titleActor );
+ void SetTitle(Actor titleActor);
/**
* @brief Gets the title actor for this Popup.
*
* @param[in] content The actor to use.
*/
- void SetContent( Actor content );
+ void SetContent(Actor content);
/**
* @brief Gets the actor currently used for the content.
*
* @param[in] footer The footer actor to be added to this Popup
*/
- void SetFooter( Actor footer );
+ void SetFooter(Actor footer);
/**
* @brief Gets the footer actor.
*
* @param[in] displayState The desired display state to change to.
*/
- void SetDisplayState( Toolkit::Popup::DisplayState displayState );
+ void SetDisplayState(Toolkit::Popup::DisplayState displayState);
/**
* @brief Gets the current state of the popup.
Toolkit::Popup::DisplayState GetDisplayState() const;
public:
-
- typedef Signal< void () > TouchedOutsideSignalType; ///< Touched outside signal type.
- typedef Signal< void () > DisplayStateChangeSignalType; ///< Used for signals emitted when the displayed state changes.
+ typedef Signal<void()> TouchedOutsideSignalType; ///< Touched outside signal type.
+ typedef Signal<void()> DisplayStateChangeSignalType; ///< Used for signals emitted when the displayed state changes.
/**
* @brief Signal emitted when user has touched outside of the Dialog.
DisplayStateChangeSignalType& HiddenSignal();
public: // Not intended for application developers
-
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
*
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL Popup( Internal::Popup& implementation );
+ DALI_INTERNAL Popup(Internal::Popup& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- explicit DALI_INTERNAL Popup( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL Popup(Dali::Internal::CustomActor* internal);
};
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelProgressBar
{
-
-Toolkit::ProgressBar New( Style progressBarStyle )
+Toolkit::ProgressBar New(Style progressBarStyle)
{
- return Internal::ProgressBar::New( progressBarStyle );
+ return Internal::ProgressBar::New(progressBarStyle);
}
} // namespace DevelProgressBar
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelProgressBar
{
-
/**
* @brief Enumeration for the style of progress bar.
*/
* @param[in] progressBarStyle A style value that determines the visual properties for ProgressBar.
* @return A handle to the ProgressBar control.
*/
-DALI_TOOLKIT_API Toolkit::ProgressBar New( Style progressBarStyle );
+DALI_TOOLKIT_API Toolkit::ProgressBar New(Style progressBarStyle);
} // namespace DevelProgressBar
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
Scene3dView::Scene3dView()
{
}
{
}
-Scene3dView::Scene3dView( const Scene3dView& handle )
- : Control( handle )
+Scene3dView::Scene3dView(const Scene3dView& handle)
+: Control(handle)
{
}
-Scene3dView& Scene3dView::operator=( const Scene3dView& handle )
+Scene3dView& Scene3dView::operator=(const Scene3dView& handle)
{
- BaseHandle::operator=( handle );
+ BaseHandle::operator=(handle);
return *this;
}
-Scene3dView Scene3dView::New( const std::string& filePath )
+Scene3dView Scene3dView::New(const std::string& filePath)
{
- return Internal::Scene3dView::New( filePath );
+ return Internal::Scene3dView::New(filePath);
}
-Scene3dView Scene3dView::New( const std::string& filePath, const std::string& diffuseTexturePath, const std::string& specularTexturePath, Vector4 scaleFactor )
+Scene3dView Scene3dView::New(const std::string& filePath, const std::string& diffuseTexturePath, const std::string& specularTexturePath, Vector4 scaleFactor)
{
- return Internal::Scene3dView::New( filePath, diffuseTexturePath, specularTexturePath, scaleFactor );
+ return Internal::Scene3dView::New(filePath, diffuseTexturePath, specularTexturePath, scaleFactor);
}
-Scene3dView::Scene3dView( Internal::Scene3dView& implementation )
- : Control( implementation )
+Scene3dView::Scene3dView(Internal::Scene3dView& implementation)
+: Control(implementation)
{
}
-Scene3dView::Scene3dView( Dali::Internal::CustomActor* internal )
- : Control( internal )
+Scene3dView::Scene3dView(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
- VerifyCustomActorPointer<Internal::Scene3dView>( internal );
+ VerifyCustomActorPointer<Internal::Scene3dView>(internal);
}
-Scene3dView Scene3dView::DownCast( BaseHandle handle )
+Scene3dView Scene3dView::DownCast(BaseHandle handle)
{
- return Control::DownCast<Scene3dView, Internal::Scene3dView>( handle );
+ return Control::DownCast<Scene3dView, Internal::Scene3dView>(handle);
}
uint32_t Scene3dView::GetAnimationCount()
{
- return GetImpl( *this ).GetAnimationCount();
+ return GetImpl(*this).GetAnimationCount();
}
-bool Scene3dView::PlayAnimation( uint32_t index )
+bool Scene3dView::PlayAnimation(uint32_t index)
{
- return GetImpl( *this ).PlayAnimation( index );
+ return GetImpl(*this).PlayAnimation(index);
}
bool Scene3dView::PlayAnimations()
{
- return GetImpl( *this ).PlayAnimations();
+ return GetImpl(*this).PlayAnimations();
}
-bool Scene3dView::SetLight( LightType type, Vector3 lightVector, Vector3 lightColor )
+bool Scene3dView::SetLight(LightType type, Vector3 lightVector, Vector3 lightColor)
{
- return GetImpl( *this ).SetLight( type, lightVector, lightColor );
+ return GetImpl(*this).SetLight(type, lightVector, lightColor);
}
CameraActor Scene3dView::GetDefaultCamera()
{
- return GetImpl( *this ).GetDefaultCamera();
+ return GetImpl(*this).GetDefaultCamera();
}
uint32_t Scene3dView::GetCameraCount()
{
- return GetImpl( *this ).GetCameraCount();
+ return GetImpl(*this).GetCameraCount();
}
-CameraActor Scene3dView::GetCamera( uint32_t cameraIndex )
+CameraActor Scene3dView::GetCamera(uint32_t cameraIndex)
{
- return GetImpl( *this ).GetCamera( cameraIndex );
+ return GetImpl(*this).GetCamera(cameraIndex);
}
-}//namespace Toolkit
-
-}//namespace Dali
+} //namespace Toolkit
+} //namespace Dali
#define DALI_TOOLKIT_SCENE3D_VIEW_H\r
\r
/*\r
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.\r
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.\r
*\r
* Licensed under the Apache License, Version 2.0 (the "License");\r
* you may not use this file except in compliance with the License.\r
\r
namespace Dali\r
{\r
-\r
namespace Toolkit\r
{\r
-\r
namespace Internal DALI_INTERNAL\r
{\r
-\r
/**\r
* Scene3dView implementation class\r
*/\r
class Scene3dView;\r
\r
-}\r
+} // namespace DALI_INTERNAL\r
\r
/**\r
*\r
class DALI_TOOLKIT_API Scene3dView : public Control\r
{\r
public:\r
-\r
enum LightType\r
{\r
// Scene doesn't use both of point and directional light\r
/**\r
* @brief Copy constructor. Creates another handle that points to the same real object\r
*/\r
- Scene3dView( const Scene3dView& handle );\r
+ Scene3dView(const Scene3dView& handle);\r
\r
/**\r
* @brief Assignment operator. Changes this handle to point to another real object\r
*/\r
- Scene3dView& operator=( const Scene3dView& handle );\r
+ Scene3dView& operator=(const Scene3dView& handle);\r
\r
/**\r
* @brief Destructor\r
* @param[in] handle Handle to an object\r
* @return handle to a Scene3dView or an uninitialized handle\r
*/\r
- static Scene3dView DownCast( BaseHandle handle );\r
+ static Scene3dView DownCast(BaseHandle handle);\r
\r
/**\r
* @brief Create an initialized Scene3dView.\r
* @param[in] filePath File path of scene format file (e.g., glTF).\r
* @return A handle to a newly allocated Dali resource\r
*/\r
- static Scene3dView New( const std::string& filePath );\r
+ static Scene3dView New(const std::string& filePath);\r
\r
/**\r
* @brief Create an initialized Scene3dView.\r
* @param[in] scaleFactor Scaling factor for the Image Based Lighting.\r
* @return A handle to a newly allocated Dali resource\r
*/\r
- static Scene3dView New( const std::string& filePath, const std::string& diffuseTexturePath, const std::string& specularTexturePath, Vector4 scaleFactor );\r
+ static Scene3dView New(const std::string& filePath, const std::string& diffuseTexturePath, const std::string& specularTexturePath, Vector4 scaleFactor);\r
\r
/**\r
* @brief Get animation count.\r
* @param[in] index Animation index\r
* @return true if animation is played.\r
*/\r
- bool PlayAnimation( uint32_t index );\r
+ bool PlayAnimation(uint32_t index);\r
\r
/**\r
* @brief Play all animations.\r
* @param[in] lightColor Vector3 value that denotes the light color of point light or directional light. Since this is the light color, we don't need to use alpha value.\r
* @return true if point light or directional light is set.\r
*/\r
- bool SetLight( LightType type, Vector3 lightVector, Vector3 lightColor );\r
+ bool SetLight(LightType type, Vector3 lightVector, Vector3 lightColor);\r
\r
/**\r
* @brief Get default CameraActor. Dali::Camera::Type = Dali::Camera::LOOK_AT_TARGET , near clipping plane = 0.1, and camera position = Vector3( 0.0, 0.0, 0.0 ).\r
* @param[in] cameraIndex Index of CameraActor list.\r
* @return CameraActor.\r
*/\r
- CameraActor GetCamera( uint32_t cameraIndex );\r
+ CameraActor GetCamera(uint32_t cameraIndex);\r
\r
// Not intended for developer use\r
public:\r
-\r
/**\r
* @brief Creates a handle using the Toolkit::Internal implementation.\r
* @param[in] implementation The UI Control implementation.\r
*/\r
- DALI_INTERNAL Scene3dView( Toolkit::Internal::Scene3dView& implementation );\r
+ DALI_INTERNAL Scene3dView(Toolkit::Internal::Scene3dView& implementation);\r
\r
- explicit DALI_INTERNAL Scene3dView( Dali::Internal::CustomActor* internal );\r
+ explicit DALI_INTERNAL Scene3dView(Dali::Internal::CustomActor* internal);\r
};\r
\r
} // namespace Toolkit\r
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
ScrollBar::ScrollBar()
{
}
ScrollBar::ScrollBar(Internal::ScrollBar& implementation)
-: Control( implementation )
+: Control(implementation)
{
}
-ScrollBar::ScrollBar( Dali::Internal::CustomActor* internal )
-: Control( internal )
+ScrollBar::ScrollBar(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::ScrollBar>(internal);
}
-ScrollBar::ScrollBar( const ScrollBar& handle )
-: Control( handle )
+ScrollBar::ScrollBar(const ScrollBar& handle)
+: Control(handle)
{
}
-ScrollBar& ScrollBar::operator=( const ScrollBar& scrollBar )
+ScrollBar& ScrollBar::operator=(const ScrollBar& scrollBar)
{
- if( &scrollBar != this )
+ if(&scrollBar != this)
{
- Control::operator=( scrollBar );
+ Control::operator=(scrollBar);
}
return *this;
}
return Internal::ScrollBar::New(direction);
}
-ScrollBar ScrollBar::DownCast( BaseHandle handle )
+ScrollBar ScrollBar::DownCast(BaseHandle handle)
{
return Control::DownCast<ScrollBar, Internal::ScrollBar>(handle);
}
{
}
-void ScrollBar::SetScrollPropertySource( Handle handle, Dali::Property::Index propertyScrollPosition, Dali::Property::Index propertyMinScrollPosition, Dali::Property::Index propertyMaxScrollPosition, Dali::Property::Index propertyScrollContentSize )
+void ScrollBar::SetScrollPropertySource(Handle handle, Dali::Property::Index propertyScrollPosition, Dali::Property::Index propertyMinScrollPosition, Dali::Property::Index propertyMaxScrollPosition, Dali::Property::Index propertyScrollContentSize)
{
GetImpl(*this).SetScrollPropertySource(handle, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
}
-void ScrollBar::SetScrollIndicator( Actor indicator )
+void ScrollBar::SetScrollIndicator(Actor indicator)
{
GetImpl(*this).SetScrollIndicator(indicator);
}
return GetImpl(*this).GetScrollIndicator();
}
-void ScrollBar::SetScrollPositionIntervals( const Dali::Vector<float>& positions )
+void ScrollBar::SetScrollPositionIntervals(const Dali::Vector<float>& positions)
{
GetImpl(*this).SetScrollPositionIntervals(positions);
}
return GetImpl(*this).GetScrollPositionIntervals();
}
-void ScrollBar::SetScrollDirection( ScrollBar::Direction direction )
+void ScrollBar::SetScrollDirection(ScrollBar::Direction direction)
{
GetImpl(*this).SetScrollDirection(direction);
}
return GetImpl(*this).GetScrollDirection();
}
-void ScrollBar::SetIndicatorHeightPolicy( ScrollBar::IndicatorHeightPolicy policy )
+void ScrollBar::SetIndicatorHeightPolicy(ScrollBar::IndicatorHeightPolicy policy)
{
GetImpl(*this).SetIndicatorHeightPolicy(policy);
}
return GetImpl(*this).GetIndicatorHeightPolicy();
}
-void ScrollBar::SetIndicatorFixedHeight( float height )
+void ScrollBar::SetIndicatorFixedHeight(float height)
{
GetImpl(*this).SetIndicatorFixedHeight(height);
}
return GetImpl(*this).GetIndicatorFixedHeight();
}
-void ScrollBar::SetIndicatorShowDuration( float durationSeconds )
+void ScrollBar::SetIndicatorShowDuration(float durationSeconds)
{
GetImpl(*this).SetIndicatorShowDuration(durationSeconds);
}
return GetImpl(*this).GetIndicatorShowDuration();
}
-void ScrollBar::SetIndicatorHideDuration( float durationSeconds )
+void ScrollBar::SetIndicatorHideDuration(float durationSeconds)
{
GetImpl(*this).SetIndicatorHideDuration(durationSeconds);
}
#define DALI_TOOLKIT_SCROLL_BAR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
// Forward declarations
class ScrollBar;
-}
+} // namespace DALI_INTERNAL
/**
* @addtogroup dali_toolkit_controls_scroll_bar
* @{
class DALI_TOOLKIT_API ScrollBar : public Control
{
public:
-
// Properties
/**
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices @SINCE_1_0.0
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices @SINCE_1_0.0
};
/**
// Signals
- typedef Signal< void () > PanFinishedSignalType;
- typedef Signal< void ( float ) > ScrollPositionIntervalReachedSignalType;
+ typedef Signal<void()> PanFinishedSignalType;
+ typedef Signal<void(float)> ScrollPositionIntervalReachedSignalType;
public:
-
/**
* @brief Direction.
* @SINCE_1_0.0
*/
enum Direction
{
- VERTICAL = 0, ///< Scroll in the vertical direction @SINCE_1_9.28
- HORIZONTAL ///< Scroll in the horizontal direction @SINCE_1_9.28
+ VERTICAL = 0, ///< Scroll in the vertical direction @SINCE_1_9.28
+ HORIZONTAL ///< Scroll in the horizontal direction @SINCE_1_9.28
};
/**
*/
enum IndicatorHeightPolicy
{
- VARIABLE = 0, ///< VARIABLE height changed dynamically according to the length of scroll content @SINCE_1_9.28
- FIXED ///< FIXED height regardless of the length of scroll content @SINCE_1_9.28
+ VARIABLE = 0, ///< VARIABLE height changed dynamically according to the length of scroll content @SINCE_1_9.28
+ FIXED ///< FIXED height regardless of the length of scroll content @SINCE_1_9.28
};
/**
* @SINCE_1_0.0
* @param[in] scrollBar Handle to an object
*/
- ScrollBar( const ScrollBar& scrollBar );
+ ScrollBar(const ScrollBar& scrollBar);
/**
* @brief Assignment operator.
* @param[in] scrollBar Handle to an object
* @return A reference to this
*/
- ScrollBar& operator=( const ScrollBar& scrollBar );
+ ScrollBar& operator=(const ScrollBar& scrollBar);
/**
* @brief Destructor.
* @param[in] handle Handle to an object
* @return Handle to a ScrollBar or an uninitialized handle
*/
- static ScrollBar DownCast( BaseHandle handle );
+ static ScrollBar DownCast(BaseHandle handle);
/**
* @brief Sets the source of the scroll position properties.
* @param[in] propertyScrollContentSize The index of the scroll content size property (The size of the scrollable content in actor coordinates, type float)
* @pre The handle to the object owing the scroll properties has been initialised and the property index must be valid.
*/
- void SetScrollPropertySource( Handle handle, Dali::Property::Index propertyScrollPosition, Dali::Property::Index propertyMinScrollPosition, Dali::Property::Index propertyMaxScrollPosition, Dali::Property::Index propertyScrollContentSize );
+ void SetScrollPropertySource(Handle handle, Dali::Property::Index propertyScrollPosition, Dali::Property::Index propertyMinScrollPosition, Dali::Property::Index propertyMaxScrollPosition, Dali::Property::Index propertyScrollContentSize);
/**
* @brief Sets the indicator of scroll bar.
* @param[in] indicator The indicator that moves to indicate the current scroll position
* @pre The scroll bar actor has been initialized.
*/
- void SetScrollIndicator( Actor indicator );
+ void SetScrollIndicator(Actor indicator);
/**
* @brief Gets the indicator of scroll bar.
* @param[in] positions List of values to receive notifications for when the current scroll position crosses them
* @pre The scroll bar actor has been initialized.
*/
- void SetScrollPositionIntervals( const Dali::Vector<float>& positions );
+ void SetScrollPositionIntervals(const Dali::Vector<float>& positions);
/**
* @brief Gets the list of values to receive notifications when the current scroll position of the scrollable
* @param[in] direction The direction of scroll bar (either vertically or horizontally)
* @pre The scroll bar actor has been initialized.
*/
- void SetScrollDirection( Direction direction );
+ void SetScrollDirection(Direction direction);
/**
* @brief Gets the direction of scroll bar.
* @param[in] policy The height policy of scroll indicator
* @pre The scroll bar actor has been initialized.
*/
- void SetIndicatorHeightPolicy( IndicatorHeightPolicy policy );
+ void SetIndicatorHeightPolicy(IndicatorHeightPolicy policy);
/**
* @brief Gets the height policy of scroll indicator.
* @pre The scroll bar actor has been initialized.
*
*/
- void SetIndicatorFixedHeight( float height );
+ void SetIndicatorFixedHeight(float height);
/**
* @brief Gets the fix height of scroll indicator.
* @pre The scroll bar actor has been initialised; durationSeconds must be zero or greater; zero means the indicator will be shown instantly.
*
*/
- void SetIndicatorShowDuration( float durationSeconds );
+ void SetIndicatorShowDuration(float durationSeconds);
/**
* @brief Gets the duration in seconds for the scroll indicator to become fully visible.
* @pre The scroll bar actor has been initialised; durationSeconds must be zero or greater; zero means the indicator will be hidden instantly.
*
*/
- void SetIndicatorHideDuration( float durationSeconds );
+ void SetIndicatorHideDuration(float durationSeconds);
/**
* @brief Gets the duration in seconds for the scroll indicator to become fully invisible.
void HideIndicator();
public: // Signals
-
/**
* @brief Signal emitted when panning is finished on the scroll indicator.
*
ScrollBar::ScrollPositionIntervalReachedSignalType& ScrollPositionIntervalReachedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] implementation The Control implementation
*/
- DALI_INTERNAL ScrollBar( Internal::ScrollBar& implementation );
+ DALI_INTERNAL ScrollBar(Internal::ScrollBar& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor
*/
- explicit DALI_INTERNAL ScrollBar( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL ScrollBar(Dali::Internal::CustomActor* internal);
/// @endcond
};
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace
{
-
-const float GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_WIDTH_SCALE = 1.0f;
+const float GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_WIDTH_SCALE = 1.0f;
const float GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_HEIGHT_SCALE = 1.0f;
} // namespace
namespace Dali
{
-
namespace Toolkit
{
-
ShadowView::ShadowView()
{
}
}
ShadowView::ShadowView(const ShadowView& handle)
- : Control( handle )
+: Control(handle)
{
}
ShadowView& ShadowView::operator=(const ShadowView& rhs)
{
- if( &rhs != this )
+ if(&rhs != this)
{
Control::operator=(rhs);
}
return Internal::ShadowView::New(downsampleWidthScale, downsampleHeightScale);
}
-ShadowView::ShadowView( Internal::ShadowView& implementation )
-: Control( implementation )
+ShadowView::ShadowView(Internal::ShadowView& implementation)
+: Control(implementation)
{
}
-ShadowView::ShadowView( Dali::Internal::CustomActor* internal )
-: Control( internal )
+ShadowView::ShadowView(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::ShadowView>(internal);
}
-ShadowView ShadowView::DownCast( BaseHandle handle )
+ShadowView ShadowView::DownCast(BaseHandle handle)
{
return Control::DownCast<ShadowView, Internal::ShadowView>(handle);
}
#define DALI_TOOLKIT_SHADOW_VIEW_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
-
/**
* ShadowView implementation class
*/
class ShadowView;
-} // namespace Internal
+} // namespace DALI_INTERNAL
/**
*
class DALI_TOOLKIT_API ShadowView : public Control
{
public:
-
/**
* Create an uninitialized ShadowView; this can be initialized with ShadowView::New()
* Calling member functions with an uninitialized Dali::Object is not allowed.
* @param[in] handle Handle to an object
* @return handle to a ShadowView or an uninitialized handle
*/
- static ShadowView DownCast( BaseHandle handle );
+ static ShadowView DownCast(BaseHandle handle);
/**
* Create an initialized ShadowView. Add children and call SetShadowPlane to make shadows visible\n
*/
Dali::Property::Index GetShadowColorPropertyIndex() const;
-
public:
-
/**
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The UI Control implementation.
*/
- DALI_INTERNAL ShadowView( Internal::ShadowView& implementation );
+ DALI_INTERNAL ShadowView(Internal::ShadowView& implementation);
/**
* Allows the creation of this UI Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- explicit DALI_INTERNAL ShadowView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL ShadowView(Dali::Internal::CustomActor* internal);
};
} // namespace Toolkit
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
SuperBlurView::SuperBlurView()
{
}
-SuperBlurView SuperBlurView::New( unsigned int blurLevels )
+SuperBlurView SuperBlurView::New(unsigned int blurLevels)
{
- return Internal::SuperBlurView::New( blurLevels );
+ return Internal::SuperBlurView::New(blurLevels);
}
-SuperBlurView::SuperBlurView( const SuperBlurView& handle )
-: Control( handle )
+SuperBlurView::SuperBlurView(const SuperBlurView& handle)
+: Control(handle)
{
}
-SuperBlurView& SuperBlurView::operator=( const SuperBlurView& rhs )
+SuperBlurView& SuperBlurView::operator=(const SuperBlurView& rhs)
{
- if( &rhs != this )
+ if(&rhs != this)
{
Control::operator=(rhs);
}
{
}
-SuperBlurView SuperBlurView::DownCast( BaseHandle handle )
+SuperBlurView SuperBlurView::DownCast(BaseHandle handle)
{
- return Control::DownCast<SuperBlurView, Internal::SuperBlurView>( handle );
+ return Control::DownCast<SuperBlurView, Internal::SuperBlurView>(handle);
}
SuperBlurView::SuperBlurView(Internal::SuperBlurView& implementation)
-: Control( implementation )
+: Control(implementation)
{
}
SuperBlurView::SuperBlurView(Dali::Internal::CustomActor* internal)
-: Control( internal )
+: Control(internal)
{
- VerifyCustomActorPointer<Internal::SuperBlurView>( internal );
+ VerifyCustomActorPointer<Internal::SuperBlurView>(internal);
}
-void SuperBlurView::SetTexture( Texture texture )
+void SuperBlurView::SetTexture(Texture texture)
{
- GetImpl(*this).SetTexture( texture );
+ GetImpl(*this).SetTexture(texture);
}
Property::Index SuperBlurView::GetBlurStrengthPropertyIndex() const
return GetImpl(*this).GetBlurStrengthPropertyIndex();
}
-void SuperBlurView::SetBlurStrength( float blurStrength )
+void SuperBlurView::SetBlurStrength(float blurStrength)
{
- GetImpl(*this).SetBlurStrength( blurStrength );
+ GetImpl(*this).SetBlurStrength(blurStrength);
}
float SuperBlurView::GetCurrentBlurStrength() const
return GetImpl(*this).BlurFinishedSignal();
}
-Texture SuperBlurView::GetBlurredTexture( unsigned int level )
+Texture SuperBlurView::GetBlurredTexture(unsigned int level)
{
- return GetImpl(*this).GetBlurredTexture( level );
+ return GetImpl(*this).GetBlurredTexture(level);
}
} // namespace Toolkit
#define DALI_TOOLKIT_SUPER_BLUR_VIEW_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class SuperBlurView;
class DALI_TOOLKIT_API SuperBlurView : public Control
{
public:
-
/**
* @brief The start and end property ranges for this control.
*/
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1,
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
};
/**
/**
* @brief Signal type for notifications.
*/
- typedef Signal< void (SuperBlurView source) > SuperBlurViewSignal;
+ typedef Signal<void(SuperBlurView source)> SuperBlurViewSignal;
/**
* @brief Creates an empty SuperBlurView handle.
* @param[in] blurLevels The final blur strength level. It decides how many filtering passes are used to create the group of blurred textures.
* @return A handle to a newly allocated Dali resource
*/
- static SuperBlurView New( unsigned int blurLevels );
+ static SuperBlurView New(unsigned int blurLevels);
/**
* @brief Copy constructor.
* Creates another handle that points to the same real object.
* @param[in] handle the handle to copy from
*/
- SuperBlurView( const SuperBlurView& handle );
+ SuperBlurView(const SuperBlurView& handle);
/**
* @brief Assignment operator.
* @param[in] rhs the handle to copy from
* @return a reference to this
*/
- SuperBlurView& operator=( const SuperBlurView& rhs );
+ SuperBlurView& operator=(const SuperBlurView& rhs);
/**
* @brief Destructor
* @param[in] handle Handle to an object
* @return handle to a SuperBlurView or an uninitialized handle
*/
- static SuperBlurView DownCast( BaseHandle handle );
+ static SuperBlurView DownCast(BaseHandle handle);
/**
* @brief Sets a custom texture to be blurred.
*
* @param[in] texture The texture that the user wishes to blur
*/
- void SetTexture( Texture texture );
+ void SetTexture(Texture texture);
/**
* @brief Get the index of the property that can be used to fade the blur in / out.
*
* @param[in] blurStrength The blur strength used to display the texture.
*/
- void SetBlurStrength( float blurStrength );
+ void SetBlurStrength(float blurStrength);
/**
* @brief Get the current blur strength.
* @param[in] level Indicate which blurred texture to get, must be a value between 1 and blurLevels
* @return The level-th blurred texture
*/
- Texture GetBlurredTexture( unsigned int level );
+ Texture GetBlurredTexture(unsigned int level);
public: // Not intended for application developers
-
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
*
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
TableView::TableView()
{
}
-TableView::TableView( const TableView& handle )
-: Control( handle )
+TableView::TableView(const TableView& handle)
+: Control(handle)
{
}
-TableView& TableView::operator=( const TableView& handle )
+TableView& TableView::operator=(const TableView& handle)
{
- if( &handle != this )
+ if(&handle != this)
{
- Control::operator=( handle );
+ Control::operator=(handle);
}
return *this;
}
-TableView TableView::New( unsigned int initialRows, unsigned int initialColumns )
+TableView TableView::New(unsigned int initialRows, unsigned int initialColumns)
{
- return Internal::TableView::New( initialRows, initialColumns );
+ return Internal::TableView::New(initialRows, initialColumns);
}
TableView::~TableView()
{
}
-TableView TableView::DownCast( BaseHandle handle )
+TableView TableView::DownCast(BaseHandle handle)
{
return Control::DownCast<TableView, Internal::TableView>(handle);
}
-bool TableView::AddChild( Actor child, CellPosition position )
+bool TableView::AddChild(Actor child, CellPosition position)
{
- return GetImpl(*this).AddChild( child, position );
+ return GetImpl(*this).AddChild(child, position);
}
-Actor TableView::GetChildAt( CellPosition position )
+Actor TableView::GetChildAt(CellPosition position)
{
- return GetImpl(*this).GetChildAt( position );
+ return GetImpl(*this).GetChildAt(position);
}
-Actor TableView::RemoveChildAt( CellPosition position )
+Actor TableView::RemoveChildAt(CellPosition position)
{
- return GetImpl(*this).RemoveChildAt( position );
+ return GetImpl(*this).RemoveChildAt(position);
}
-bool TableView::FindChildPosition( Actor child, CellPosition& position )
+bool TableView::FindChildPosition(Actor child, CellPosition& position)
{
- return GetImpl(*this).FindChildPosition( child, position );
+ return GetImpl(*this).FindChildPosition(child, position);
}
-void TableView::InsertRow( unsigned int rowIndex )
+void TableView::InsertRow(unsigned int rowIndex)
{
- GetImpl(*this).InsertRow( rowIndex );
+ GetImpl(*this).InsertRow(rowIndex);
}
-void TableView::DeleteRow( unsigned int rowIndex )
+void TableView::DeleteRow(unsigned int rowIndex)
{
- GetImpl(*this).DeleteRow( rowIndex );
+ GetImpl(*this).DeleteRow(rowIndex);
}
-void TableView::DeleteRow( unsigned int rowIndex, vector<Actor>& removed )
+void TableView::DeleteRow(unsigned int rowIndex, vector<Actor>& removed)
{
- GetImpl(*this).DeleteRow( rowIndex, removed );
+ GetImpl(*this).DeleteRow(rowIndex, removed);
}
-void TableView::InsertColumn( unsigned int columnIndex )
+void TableView::InsertColumn(unsigned int columnIndex)
{
- GetImpl(*this).InsertColumn( columnIndex );
+ GetImpl(*this).InsertColumn(columnIndex);
}
-void TableView::DeleteColumn( unsigned int columnIndex )
+void TableView::DeleteColumn(unsigned int columnIndex)
{
- GetImpl(*this).DeleteColumn( columnIndex );
+ GetImpl(*this).DeleteColumn(columnIndex);
}
-void TableView::DeleteColumn( unsigned int columnIndex, vector<Actor>& removed )
+void TableView::DeleteColumn(unsigned int columnIndex, vector<Actor>& removed)
{
- GetImpl(*this).DeleteColumn( columnIndex, removed );
+ GetImpl(*this).DeleteColumn(columnIndex, removed);
}
-void TableView::Resize( unsigned int rows, unsigned int columns )
+void TableView::Resize(unsigned int rows, unsigned int columns)
{
- GetImpl(*this).Resize( rows, columns );
+ GetImpl(*this).Resize(rows, columns);
}
-void TableView::Resize( unsigned int rows, unsigned int columns, vector<Actor>& removed )
+void TableView::Resize(unsigned int rows, unsigned int columns, vector<Actor>& removed)
{
- GetImpl(*this).Resize( rows, columns, removed );
+ GetImpl(*this).Resize(rows, columns, removed);
}
-void TableView::SetCellPadding( Size padding )
+void TableView::SetCellPadding(Size padding)
{
- GetImpl(*this).SetCellPadding( padding );
+ GetImpl(*this).SetCellPadding(padding);
}
Size TableView::GetCellPadding()
return GetImpl(*this).GetCellPadding();
}
-void TableView::SetFitHeight( unsigned int rowIndex )
+void TableView::SetFitHeight(unsigned int rowIndex)
{
- GetImpl(*this).SetFitHeight( rowIndex );
+ GetImpl(*this).SetFitHeight(rowIndex);
}
-bool TableView::IsFitHeight( unsigned int rowIndex ) const
+bool TableView::IsFitHeight(unsigned int rowIndex) const
{
- return GetImpl(*this).IsFitHeight( rowIndex );
+ return GetImpl(*this).IsFitHeight(rowIndex);
}
-void TableView::SetFitWidth( unsigned int columnIndex )
+void TableView::SetFitWidth(unsigned int columnIndex)
{
- GetImpl(*this).SetFitWidth( columnIndex );
+ GetImpl(*this).SetFitWidth(columnIndex);
}
-bool TableView::IsFitWidth( unsigned int columnIndex ) const
+bool TableView::IsFitWidth(unsigned int columnIndex) const
{
- return GetImpl(*this).IsFitWidth( columnIndex );
+ return GetImpl(*this).IsFitWidth(columnIndex);
}
-void TableView::SetFixedHeight( unsigned int rowIndex, float height )
+void TableView::SetFixedHeight(unsigned int rowIndex, float height)
{
- GetImpl(*this).SetFixedHeight( rowIndex, height );
+ GetImpl(*this).SetFixedHeight(rowIndex, height);
}
-float TableView::GetFixedHeight( unsigned int rowIndex ) const
+float TableView::GetFixedHeight(unsigned int rowIndex) const
{
- return GetImpl(*this).GetFixedHeight( rowIndex );
+ return GetImpl(*this).GetFixedHeight(rowIndex);
}
-void TableView::SetRelativeHeight( unsigned int rowIndex, float heightPercentage )
+void TableView::SetRelativeHeight(unsigned int rowIndex, float heightPercentage)
{
- GetImpl(*this).SetRelativeHeight( rowIndex, heightPercentage );
+ GetImpl(*this).SetRelativeHeight(rowIndex, heightPercentage);
}
-float TableView::GetRelativeHeight( unsigned int rowIndex ) const
+float TableView::GetRelativeHeight(unsigned int rowIndex) const
{
- return GetImpl(*this).GetRelativeHeight( rowIndex );
+ return GetImpl(*this).GetRelativeHeight(rowIndex);
}
-void TableView::SetFixedWidth( unsigned int columnIndex, float width )
+void TableView::SetFixedWidth(unsigned int columnIndex, float width)
{
- GetImpl(*this).SetFixedWidth( columnIndex, width );
+ GetImpl(*this).SetFixedWidth(columnIndex, width);
}
-float TableView::GetFixedWidth( unsigned int columnIndex ) const
+float TableView::GetFixedWidth(unsigned int columnIndex) const
{
- return GetImpl(*this).GetFixedWidth( columnIndex );
+ return GetImpl(*this).GetFixedWidth(columnIndex);
}
-void TableView::SetRelativeWidth( unsigned int columnIndex, float widthPercentage )
+void TableView::SetRelativeWidth(unsigned int columnIndex, float widthPercentage)
{
- GetImpl(*this).SetRelativeWidth( columnIndex, widthPercentage );
+ GetImpl(*this).SetRelativeWidth(columnIndex, widthPercentage);
}
-float TableView::GetRelativeWidth( unsigned int columnIndex ) const
+float TableView::GetRelativeWidth(unsigned int columnIndex) const
{
- return GetImpl(*this).GetRelativeWidth( columnIndex );
+ return GetImpl(*this).GetRelativeWidth(columnIndex);
}
unsigned int TableView::GetRows()
return GetImpl(*this).GetColumns();
}
-void TableView::SetCellAlignment( CellPosition position, HorizontalAlignment::Type horizontal, VerticalAlignment::Type vertical )
+void TableView::SetCellAlignment(CellPosition position, HorizontalAlignment::Type horizontal, VerticalAlignment::Type vertical)
{
- GetImpl(*this).SetCellAlignment( position, horizontal, vertical );
+ GetImpl(*this).SetCellAlignment(position, horizontal, vertical);
}
TableView::TableView(Internal::TableView& implementation)
{
}
-TableView::TableView( Dali::Internal::CustomActor* internal )
-: Control( internal )
+TableView::TableView(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::TableView>(internal);
}
#define DALI_TOOLKIT_TABLE_VIEW_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/actors/actor-enumerations.h>
+#include <dali/public-api/common/vector-wrapper.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class TableView;
class DALI_TOOLKIT_API TableView : public Control
{
public:
-
/**
* @brief Enumeration for the start and end property ranges for this control.
* @SINCE_1_0.0
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_0.0
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_0.0
- CHILD_PROPERTY_START_INDEX = CHILD_PROPERTY_REGISTRATION_START_INDEX, ///< @SINCE_1_1.36
- CHILD_PROPERTY_END_INDEX = CHILD_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve child property indices @SINCE_1_1.36
+ CHILD_PROPERTY_START_INDEX = CHILD_PROPERTY_REGISTRATION_START_INDEX, ///< @SINCE_1_1.36
+ CHILD_PROPERTY_END_INDEX = CHILD_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve child property indices @SINCE_1_1.36
};
/**
*/
enum
{
- CELL_INDEX = CHILD_PROPERTY_START_INDEX, ///< name "cellIndex", The top-left cell this child occupies, if not set, the first available cell is used, type VECTOR2 @SINCE_1_1.36
- ROW_SPAN, ///< name "rowSpan", The number of rows this child occupies, if not set, default value is 1, type FLOAT @SINCE_1_1.36
- COLUMN_SPAN, ///< name "columnSpan", The number of columns this child occupies, if not set, default value is 1, type FLOAT @SINCE_1_1.36
- CELL_HORIZONTAL_ALIGNMENT, ///< name "cellHorizontalAlignment", The horizontal alignment of this child inside the cells, if not set, default value is 'left', type STRING @SINCE_1_1.36
- CELL_VERTICAL_ALIGNMENT ///< name "cellVerticalAlignment", The vertical alignment of this child inside the cells, if not set, default value is 'top', type STRING @SINCE_1_1.36
+ CELL_INDEX = CHILD_PROPERTY_START_INDEX, ///< name "cellIndex", The top-left cell this child occupies, if not set, the first available cell is used, type VECTOR2 @SINCE_1_1.36
+ ROW_SPAN, ///< name "rowSpan", The number of rows this child occupies, if not set, default value is 1, type FLOAT @SINCE_1_1.36
+ COLUMN_SPAN, ///< name "columnSpan", The number of columns this child occupies, if not set, default value is 1, type FLOAT @SINCE_1_1.36
+ CELL_HORIZONTAL_ALIGNMENT, ///< name "cellHorizontalAlignment", The horizontal alignment of this child inside the cells, if not set, default value is 'left', type STRING @SINCE_1_1.36
+ CELL_VERTICAL_ALIGNMENT ///< name "cellVerticalAlignment", The vertical alignment of this child inside the cells, if not set, default value is 'top', type STRING @SINCE_1_1.36
};
};
*/
enum LayoutPolicy
{
- FIXED, ///< Fixed with the given value. @SINCE_1_0.0
- RELATIVE, ///< Calculated as percentage of the remainder after subtracting Padding and Fixed height/width @SINCE_1_0.0
- FILL, ///< Default policy, get the remainder of the 100% (after subtracting Fixed, Fit and Relative height/ width) divided evenly between 'fill' rows/columns @SINCE_1_0.0
- FIT ///< Fit around its children. @SINCE_1_0.0
+ FIXED, ///< Fixed with the given value. @SINCE_1_0.0
+ RELATIVE, ///< Calculated as percentage of the remainder after subtracting Padding and Fixed height/width @SINCE_1_0.0
+ FILL, ///< Default policy, get the remainder of the 100% (after subtracting Fixed, Fit and Relative height/ width) divided evenly between 'fill' rows/columns @SINCE_1_0.0
+ FIT ///< Fit around its children. @SINCE_1_0.0
};
/**
* @param[in] rowSpan The row span initialized
* @param[in] columnSpan The column span initialized
*/
- CellPosition( unsigned int rowIndex = 0, unsigned int columnIndex = 0,
- unsigned int rowSpan = 1, unsigned int columnSpan = 1 )
- : rowIndex( rowIndex ), columnIndex( columnIndex ),
- rowSpan( rowSpan ), columnSpan( columnSpan )
- { }
+ CellPosition(unsigned int rowIndex = 0, unsigned int columnIndex = 0, unsigned int rowSpan = 1, unsigned int columnSpan = 1)
+ : rowIndex(rowIndex),
+ columnIndex(columnIndex),
+ rowSpan(rowSpan),
+ columnSpan(columnSpan)
+ {
+ }
unsigned int rowIndex;
unsigned int columnIndex;
* @SINCE_1_0.0
* @param[in] handle Handle to copy from
*/
- TableView( const TableView& handle );
+ TableView(const TableView& handle);
/**
* @brief Assignment operator. Changes this handle to point to another real object.
* @param[in] handle Handle to an object
* @return A reference to this
*/
- TableView& operator=( const TableView& handle );
+ TableView& operator=(const TableView& handle);
/**
* @brief Destructor.
* @param[in] initialColumns for the table
* @return A handle to the TableView control
*/
- static TableView New( unsigned int initialRows, unsigned int initialColumns );
+ static TableView New(unsigned int initialRows, unsigned int initialColumns);
/**
* @brief Downcasts a handle to TableView handle.
* @param[in] handle Handle to an object
* @return Handle to a TableView or an uninitialized handle
*/
- static TableView DownCast( BaseHandle handle );
+ static TableView DownCast(BaseHandle handle);
/**
* @brief Adds a child to the table.
* @return @c true if the addition succeeded, @c false if the cell is already occupied
* @pre The child actor has been initialized.
*/
- bool AddChild( Actor child, CellPosition position );
+ bool AddChild(Actor child, CellPosition position);
/**
* @brief Returns a child from the given layout position.
* @note If there is no child in this position this method returns an uninitialized.
* Actor handle
*/
- Actor GetChildAt( CellPosition position );
+ Actor GetChildAt(CellPosition position);
/**
* @brief Removes a child from the given layout position.
* @return Child that was removed or an uninitialized handle
* @note If there is no child in this position, this method does nothing.
*/
- Actor RemoveChildAt( CellPosition position );
+ Actor RemoveChildAt(CellPosition position);
/**
* @brief Finds the child's layout position.
* @param[out] position The position for the child
* @return true if the child was included in this TableView
*/
- bool FindChildPosition( Actor child, CellPosition& position );
+ bool FindChildPosition(Actor child, CellPosition& position);
/**
* @brief Inserts a new row to given index.
* @SINCE_1_0.0
* @param[in] rowIndex The rowIndex of the new row
*/
- void InsertRow( unsigned int rowIndex );
+ void InsertRow(unsigned int rowIndex);
/**
* @brief Deletes a row from the given index.
* @SINCE_1_0.0
* @param[in] rowIndex The rowIndex of the row to delete
*/
- void DeleteRow( unsigned int rowIndex );
+ void DeleteRow(unsigned int rowIndex);
/**
* @brief Deletes a row from the given index.
* @param[in] rowIndex The rowIndex of the row to delete
* @param[out] removed The removed elements
*/
- void DeleteRow( unsigned int rowIndex, std::vector<Actor>& removed );
+ void DeleteRow(unsigned int rowIndex, std::vector<Actor>& removed);
/**
* @brief Inserts a new column to the given index.
* @SINCE_1_0.0
* @param[in] columnIndex The columnIndex of the new column
*/
- void InsertColumn( unsigned int columnIndex );
+ void InsertColumn(unsigned int columnIndex);
/**
* @brief Deletes a column from the given index.
* @SINCE_1_0.0
* @param[in] columnIndex The columnIndex of the column to delete
*/
- void DeleteColumn( unsigned int columnIndex );
+ void DeleteColumn(unsigned int columnIndex);
/**
* @brief Deletes a column from the given index.
* @param[in] columnIndex The columnIndex of the column to delete
* @param[out] removed The removed elements
*/
- void DeleteColumn( unsigned int columnIndex, std::vector<Actor>& removed );
+ void DeleteColumn(unsigned int columnIndex, std::vector<Actor>& removed);
/**
* @brief Resizes the TableView.
* use the variant that returns the removed Actors and reinsert them into the table.
* If an actor spans to a removed row or column, it gets removed from the table.
*/
- void Resize( unsigned int rows, unsigned int columns );
+ void Resize(unsigned int rows, unsigned int columns);
/**
* @brief Resizes the TableView.
* @note If the new size is smaller than old, superfluous actors get removed.
* If an actor spans to a removed row or column it gets removed from the table.
*/
- void Resize( unsigned int rows, unsigned int columns, std::vector<Actor>& removed );
+ void Resize(unsigned int rows, unsigned int columns, std::vector<Actor>& removed);
/**
* @brief Sets horizontal and vertical padding between cells.
* @SINCE_1_0.0
* @param[in] padding Width and height
*/
- void SetCellPadding( Size padding );
+ void SetCellPadding(Size padding);
/**
* @brief Gets the current padding as width and height.
* @SINCE_1_0.0
* @param[in] rowIndex The row to set
*/
- void SetFitHeight( unsigned int rowIndex );
+ void SetFitHeight(unsigned int rowIndex);
/**
* @brief Checks if the row is a fit row.
* @param[in] rowIndex The row to check
* @return Return true if the row is fit
*/
- bool IsFitHeight( unsigned int rowIndex ) const;
+ bool IsFitHeight(unsigned int rowIndex) const;
/**
* @brief Specifies this column as fitting its width to its children.
* @SINCE_1_0.0
* @param[in] columnIndex The column to set
*/
- void SetFitWidth( unsigned int columnIndex );
+ void SetFitWidth(unsigned int columnIndex);
/**
* @brief Checks if the column is a fit column.
* @param[in] columnIndex The column to check
* @return Return true if the column is fit
*/
- bool IsFitWidth( unsigned int columnIndex ) const;
+ bool IsFitWidth(unsigned int columnIndex) const;
/**
* @brief Sets a row to have fixed height.
* @param height The height in world coordinate units
* @pre The row rowIndex must exist.
*/
- void SetFixedHeight( unsigned int rowIndex, float height );
+ void SetFixedHeight(unsigned int rowIndex, float height);
/**
* @brief Gets a row's fixed height.
* @pre The row rowIndex must exist.
* @note The returned value is valid if it has been set before.
*/
- float GetFixedHeight( unsigned int rowIndex ) const;
+ float GetFixedHeight(unsigned int rowIndex) const;
/**
* @brief Sets a row to have relative height. Relative height means percentage of
* @param heightPercentage between 0.0f and 1.0f
* @pre The row rowIndex must exist.
*/
- void SetRelativeHeight( unsigned int rowIndex, float heightPercentage );
+ void SetRelativeHeight(unsigned int rowIndex, float heightPercentage);
/**
* @brief Gets a row's relative height.
* @pre The row rowIndex must exist.
* @note The returned value is valid if it has been set before.
*/
- float GetRelativeHeight( unsigned int rowIndex ) const;
+ float GetRelativeHeight(unsigned int rowIndex) const;
/**
* @brief Sets a column to have fixed width.
* @param width The width in world coordinate units
* @pre The column columnIndex must exist.
*/
- void SetFixedWidth( unsigned int columnIndex, float width );
+ void SetFixedWidth(unsigned int columnIndex, float width);
/**
* @brief Gets a column's fixed width.
* @pre The column columnIndex must exist.
* @note The returned value is valid if it has been set before.
*/
- float GetFixedWidth( unsigned int columnIndex ) const;
+ float GetFixedWidth(unsigned int columnIndex) const;
/**
* @brief Sets a column to have relative width. Relative width means percentage of
* @param widthPercentage The widthPercentage between 0.0f and 1.0f
* @pre The column columnIndex must exist.
*/
- void SetRelativeWidth( unsigned int columnIndex, float widthPercentage );
+ void SetRelativeWidth(unsigned int columnIndex, float widthPercentage);
/**
* @brief Gets a column's relative width.
* @pre The column columnIndex must exist.
* @note The returned value is valid if it has been set before.
*/
- float GetRelativeWidth( unsigned int columnIndex ) const;
+ float GetRelativeWidth(unsigned int columnIndex) const;
/**
* @brief Gets the amount of rows in the table.
* @param[in] horizontal The horizontal alignment
* @param[in] vertical The vertical alignment
*/
- void SetCellAlignment( CellPosition position, HorizontalAlignment::Type horizontal, VerticalAlignment::Type vertical );
+ void SetCellAlignment(CellPosition position, HorizontalAlignment::Type horizontal, VerticalAlignment::Type vertical);
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor
*/
- explicit DALI_INTERNAL TableView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL TableView(Dali::Internal::CustomActor* internal);
/// @endcond
};
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelTextEditor
{
-
-InputMethodContext GetInputMethodContext( TextEditor textEditor )
+InputMethodContext GetInputMethodContext(TextEditor textEditor)
{
- return GetImpl( textEditor ).GetInputMethodContext();
+ return GetImpl(textEditor).GetInputMethodContext();
}
-MaxLengthReachedSignalType& MaxLengthReachedSignal( TextEditor textEditor )
+MaxLengthReachedSignalType& MaxLengthReachedSignal(TextEditor textEditor)
{
- return GetImpl( textEditor ).MaxLengthReachedSignal();
+ return GetImpl(textEditor).MaxLengthReachedSignal();
}
} // namespace DevelTextEditor
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelTextEditor
{
-
namespace Property
{
- enum Type
- {
- TEXT = Dali::Toolkit::TextEditor::Property::TEXT,
- TEXT_COLOR = Dali::Toolkit::TextEditor::Property::TEXT_COLOR,
- FONT_FAMILY = Dali::Toolkit::TextEditor::Property::FONT_FAMILY,
- FONT_STYLE = Dali::Toolkit::TextEditor::Property::FONT_STYLE,
- POINT_SIZE = Dali::Toolkit::TextEditor::Property::POINT_SIZE,
- HORIZONTAL_ALIGNMENT = Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT,
- SCROLL_THRESHOLD = Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD,
- SCROLL_SPEED = Dali::Toolkit::TextEditor::Property::SCROLL_SPEED,
- PRIMARY_CURSOR_COLOR = Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR,
- SECONDARY_CURSOR_COLOR = Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR,
- ENABLE_CURSOR_BLINK = Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK,
- CURSOR_BLINK_INTERVAL = Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL,
- CURSOR_BLINK_DURATION = Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION,
- CURSOR_WIDTH = Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH,
- GRAB_HANDLE_IMAGE = Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE,
- GRAB_HANDLE_PRESSED_IMAGE = Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE,
- SELECTION_HANDLE_IMAGE_LEFT = Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT,
- SELECTION_HANDLE_IMAGE_RIGHT = Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT,
- SELECTION_HANDLE_PRESSED_IMAGE_LEFT = Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT,
- SELECTION_HANDLE_PRESSED_IMAGE_RIGHT = Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT,
- SELECTION_HANDLE_MARKER_IMAGE_LEFT = Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT,
- SELECTION_HANDLE_MARKER_IMAGE_RIGHT = Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT,
- SELECTION_HIGHLIGHT_COLOR = Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR,
- DECORATION_BOUNDING_BOX = Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX,
- ENABLE_MARKUP = Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP,
- INPUT_COLOR = Dali::Toolkit::TextEditor::Property::INPUT_COLOR,
- INPUT_FONT_FAMILY = Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY,
- INPUT_FONT_STYLE = Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE,
- INPUT_POINT_SIZE = Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE,
- LINE_SPACING = Dali::Toolkit::TextEditor::Property::LINE_SPACING,
- INPUT_LINE_SPACING = Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING,
- UNDERLINE = Dali::Toolkit::TextEditor::Property::UNDERLINE,
- INPUT_UNDERLINE = Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE,
- SHADOW = Dali::Toolkit::TextEditor::Property::SHADOW,
- INPUT_SHADOW = Dali::Toolkit::TextEditor::Property::INPUT_SHADOW,
- EMBOSS = Dali::Toolkit::TextEditor::Property::EMBOSS,
- INPUT_EMBOSS = Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS,
- OUTLINE = Dali::Toolkit::TextEditor::Property::OUTLINE,
- INPUT_OUTLINE = Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE,
- SMOOTH_SCROLL = Dali::Toolkit::TextEditor::Property::SMOOTH_SCROLL,
- SMOOTH_SCROLL_DURATION = Dali::Toolkit::TextEditor::Property::SMOOTH_SCROLL_DURATION,
- ENABLE_SCROLL_BAR = Dali::Toolkit::TextEditor::Property::ENABLE_SCROLL_BAR,
- SCROLL_BAR_SHOW_DURATION = Dali::Toolkit::TextEditor::Property::SCROLL_BAR_SHOW_DURATION,
- SCROLL_BAR_FADE_DURATION = Dali::Toolkit::TextEditor::Property::SCROLL_BAR_FADE_DURATION,
- PIXEL_SIZE = Dali::Toolkit::TextEditor::Property::PIXEL_SIZE,
- LINE_COUNT = Dali::Toolkit::TextEditor::Property::LINE_COUNT,
- ENABLE_SELECTION = Dali::Toolkit::TextEditor::Property::ENABLE_SELECTION,
- PLACEHOLDER = Dali::Toolkit::TextEditor::Property::PLACEHOLDER,
- LINE_WRAP_MODE = Dali::Toolkit::TextEditor::Property::LINE_WRAP_MODE,
-
- /**
+enum Type
+{
+ TEXT = Dali::Toolkit::TextEditor::Property::TEXT,
+ TEXT_COLOR = Dali::Toolkit::TextEditor::Property::TEXT_COLOR,
+ FONT_FAMILY = Dali::Toolkit::TextEditor::Property::FONT_FAMILY,
+ FONT_STYLE = Dali::Toolkit::TextEditor::Property::FONT_STYLE,
+ POINT_SIZE = Dali::Toolkit::TextEditor::Property::POINT_SIZE,
+ HORIZONTAL_ALIGNMENT = Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT,
+ SCROLL_THRESHOLD = Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD,
+ SCROLL_SPEED = Dali::Toolkit::TextEditor::Property::SCROLL_SPEED,
+ PRIMARY_CURSOR_COLOR = Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR,
+ SECONDARY_CURSOR_COLOR = Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR,
+ ENABLE_CURSOR_BLINK = Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK,
+ CURSOR_BLINK_INTERVAL = Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL,
+ CURSOR_BLINK_DURATION = Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION,
+ CURSOR_WIDTH = Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH,
+ GRAB_HANDLE_IMAGE = Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE,
+ GRAB_HANDLE_PRESSED_IMAGE = Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE,
+ SELECTION_HANDLE_IMAGE_LEFT = Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT,
+ SELECTION_HANDLE_IMAGE_RIGHT = Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT,
+ SELECTION_HANDLE_PRESSED_IMAGE_LEFT = Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT,
+ SELECTION_HANDLE_PRESSED_IMAGE_RIGHT = Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT,
+ SELECTION_HANDLE_MARKER_IMAGE_LEFT = Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT,
+ SELECTION_HANDLE_MARKER_IMAGE_RIGHT = Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT,
+ SELECTION_HIGHLIGHT_COLOR = Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR,
+ DECORATION_BOUNDING_BOX = Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX,
+ ENABLE_MARKUP = Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP,
+ INPUT_COLOR = Dali::Toolkit::TextEditor::Property::INPUT_COLOR,
+ INPUT_FONT_FAMILY = Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY,
+ INPUT_FONT_STYLE = Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE,
+ INPUT_POINT_SIZE = Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE,
+ LINE_SPACING = Dali::Toolkit::TextEditor::Property::LINE_SPACING,
+ INPUT_LINE_SPACING = Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING,
+ UNDERLINE = Dali::Toolkit::TextEditor::Property::UNDERLINE,
+ INPUT_UNDERLINE = Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE,
+ SHADOW = Dali::Toolkit::TextEditor::Property::SHADOW,
+ INPUT_SHADOW = Dali::Toolkit::TextEditor::Property::INPUT_SHADOW,
+ EMBOSS = Dali::Toolkit::TextEditor::Property::EMBOSS,
+ INPUT_EMBOSS = Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS,
+ OUTLINE = Dali::Toolkit::TextEditor::Property::OUTLINE,
+ INPUT_OUTLINE = Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE,
+ SMOOTH_SCROLL = Dali::Toolkit::TextEditor::Property::SMOOTH_SCROLL,
+ SMOOTH_SCROLL_DURATION = Dali::Toolkit::TextEditor::Property::SMOOTH_SCROLL_DURATION,
+ ENABLE_SCROLL_BAR = Dali::Toolkit::TextEditor::Property::ENABLE_SCROLL_BAR,
+ SCROLL_BAR_SHOW_DURATION = Dali::Toolkit::TextEditor::Property::SCROLL_BAR_SHOW_DURATION,
+ SCROLL_BAR_FADE_DURATION = Dali::Toolkit::TextEditor::Property::SCROLL_BAR_FADE_DURATION,
+ PIXEL_SIZE = Dali::Toolkit::TextEditor::Property::PIXEL_SIZE,
+ LINE_COUNT = Dali::Toolkit::TextEditor::Property::LINE_COUNT,
+ ENABLE_SELECTION = Dali::Toolkit::TextEditor::Property::ENABLE_SELECTION,
+ PLACEHOLDER = Dali::Toolkit::TextEditor::Property::PLACEHOLDER,
+ LINE_WRAP_MODE = Dali::Toolkit::TextEditor::Property::LINE_WRAP_MODE,
+
+ /**
* @brief The text to display when the TextEditor is empty and inactive.
* @details Name "placeholderText", type Property::STRING.
*/
- PLACEHOLDER_TEXT,
+ PLACEHOLDER_TEXT,
- /**
+ /**
* @brief The placeholder-text color.
* @details Name "placeholderTextColor", type Property::VECTOR4.
*/
- PLACEHOLDER_TEXT_COLOR,
+ PLACEHOLDER_TEXT_COLOR,
- /**
+ /**
* @brief Enables Text selection using Shift key.
* @details Name "enableShiftSelection", type Property::BOOLEAN.
*/
- ENABLE_SHIFT_SELECTION,
+ ENABLE_SHIFT_SELECTION,
- /**
+ /**
* @brief Enables the grab handles for text selection.
* @details Name "enableGrabHandle", type Property::BOOLEAN.
* @note The default value is true, which means the grab handles are enabled by default.
*/
- ENABLE_GRAB_HANDLE,
+ ENABLE_GRAB_HANDLE,
- /**
+ /**
* @brief Modifies the default text alignment to match the direction of the system language.
* @details Name "matchSystemLanguageDirection", type (Property::BOOLEAN), Read/Write
* @note The default value is false
*/
- MATCH_SYSTEM_LANGUAGE_DIRECTION,
+ MATCH_SYSTEM_LANGUAGE_DIRECTION,
- /**
+ /**
* @brief The type or rendering e.g. bitmap-based.
* @details Name "renderingBackend", type Property::INTEGER.
*/
- RENDERING_BACKEND,
+ RENDERING_BACKEND,
- /**
+ /**
* @brief The maximum number of characters that can be inserted.
* @details Name "maxLength", type Property::INTEGER.
*/
- MAX_LENGTH,
- };
+ MAX_LENGTH,
+};
} // namespace Property
* @param[in] textEditor The instance of TextEditor.
* @return InputMethodContext instance.
*/
-DALI_TOOLKIT_API InputMethodContext GetInputMethodContext( TextEditor textEditor );
+DALI_TOOLKIT_API InputMethodContext GetInputMethodContext(TextEditor textEditor);
/**
* @brief Max Characters Exceed signal type.
*/
-using MaxLengthReachedSignalType = Signal< void ( TextEditor ) >;
+using MaxLengthReachedSignalType = Signal<void(TextEditor)>;
/**
* @brief This signal is emitted when inserted text exceeds the maximum character limit.
* @param[in] textEditor The instance of TextEditor.
* @return The signal to connect to
*/
-DALI_TOOLKIT_API MaxLengthReachedSignalType& MaxLengthReachedSignal( TextEditor textEditor );
+DALI_TOOLKIT_API MaxLengthReachedSignalType& MaxLengthReachedSignal(TextEditor textEditor);
} // namespace DevelTextEditor
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelTextField
{
-
-InputMethodContext GetInputMethodContext( TextField textField )
+InputMethodContext GetInputMethodContext(TextField textField)
{
- return GetImpl( textField ).GetInputMethodContext();
+ return GetImpl(textField).GetInputMethodContext();
}
-void SelectWholeText( TextField textField )
+void SelectWholeText(TextField textField)
{
- GetImpl( textField ).SelectWholeText();
+ GetImpl(textField).SelectWholeText();
}
-void SelectNone( TextField textField )
+void SelectNone(TextField textField)
{
- GetImpl( textField ).SelectNone();
+ GetImpl(textField).SelectNone();
}
-} // namespace DevelText
+} // namespace DevelTextField
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelTextField
{
-
namespace Property
{
- enum
- {
- TEXT = Dali::Toolkit::TextField::Property::TEXT,
- PLACEHOLDER_TEXT = Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT,
- PLACEHOLDER_TEXT_FOCUSED = Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED,
- FONT_FAMILY = Dali::Toolkit::TextField::Property::FONT_FAMILY,
- FONT_STYLE = Dali::Toolkit::TextField::Property::FONT_STYLE,
- POINT_SIZE = Dali::Toolkit::TextField::Property::POINT_SIZE,
- MAX_LENGTH = Dali::Toolkit::TextField::Property::MAX_LENGTH,
- EXCEED_POLICY = Dali::Toolkit::TextField::Property::EXCEED_POLICY,
- HORIZONTAL_ALIGNMENT = Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT,
- VERTICAL_ALIGNMENT = Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT,
- TEXT_COLOR = Dali::Toolkit::TextField::Property::TEXT_COLOR,
- PLACEHOLDER_TEXT_COLOR = Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR,
- PRIMARY_CURSOR_COLOR = Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR,
- SECONDARY_CURSOR_COLOR = Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR,
- ENABLE_CURSOR_BLINK = Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK,
- CURSOR_BLINK_INTERVAL = Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL,
- CURSOR_BLINK_DURATION = Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION,
- CURSOR_WIDTH = Dali::Toolkit::TextField::Property::CURSOR_WIDTH,
- GRAB_HANDLE_IMAGE = Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE,
- GRAB_HANDLE_PRESSED_IMAGE = Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE,
- SCROLL_THRESHOLD = Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD,
- SCROLL_SPEED = Dali::Toolkit::TextField::Property::SCROLL_SPEED,
- SELECTION_HANDLE_IMAGE_LEFT = Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT,
- SELECTION_HANDLE_IMAGE_RIGHT = Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT,
- SELECTION_HANDLE_PRESSED_IMAGE_LEFT = Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT,
- SELECTION_HANDLE_PRESSED_IMAGE_RIGHT = Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT,
- SELECTION_HANDLE_MARKER_IMAGE_LEFT = Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT,
- SELECTION_HANDLE_MARKER_IMAGE_RIGHT = Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT,
- SELECTION_HIGHLIGHT_COLOR = Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR,
- DECORATION_BOUNDING_BOX = Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX,
- INPUT_METHOD_SETTINGS = Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS,
- INPUT_COLOR = Dali::Toolkit::TextField::Property::INPUT_COLOR,
- ENABLE_MARKUP = Dali::Toolkit::TextField::Property::ENABLE_MARKUP,
- INPUT_FONT_FAMILY = Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY,
- INPUT_FONT_STYLE = Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE,
- INPUT_POINT_SIZE = Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE,
- UNDERLINE = Dali::Toolkit::TextField::Property::UNDERLINE,
- INPUT_UNDERLINE = Dali::Toolkit::TextField::Property::INPUT_UNDERLINE,
- SHADOW = Dali::Toolkit::TextField::Property::SHADOW,
- INPUT_SHADOW = Dali::Toolkit::TextField::Property::INPUT_SHADOW,
- EMBOSS = Dali::Toolkit::TextField::Property::EMBOSS,
- INPUT_EMBOSS = Dali::Toolkit::TextField::Property::INPUT_EMBOSS,
- OUTLINE = Dali::Toolkit::TextField::Property::OUTLINE,
- INPUT_OUTLINE = Dali::Toolkit::TextField::Property::INPUT_OUTLINE,
- HIDDEN_INPUT_SETTINGS = Dali::Toolkit::TextField::Property::HIDDEN_INPUT_SETTINGS,
- PIXEL_SIZE = Dali::Toolkit::TextField::Property::PIXEL_SIZE,
- ENABLE_SELECTION = Dali::Toolkit::TextField::Property::ENABLE_SELECTION,
- PLACEHOLDER = Dali::Toolkit::TextField::Property::PLACEHOLDER,
- ELLIPSIS = Dali::Toolkit::TextField::Property::ELLIPSIS,
-
- /**
+enum
+{
+ TEXT = Dali::Toolkit::TextField::Property::TEXT,
+ PLACEHOLDER_TEXT = Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT,
+ PLACEHOLDER_TEXT_FOCUSED = Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED,
+ FONT_FAMILY = Dali::Toolkit::TextField::Property::FONT_FAMILY,
+ FONT_STYLE = Dali::Toolkit::TextField::Property::FONT_STYLE,
+ POINT_SIZE = Dali::Toolkit::TextField::Property::POINT_SIZE,
+ MAX_LENGTH = Dali::Toolkit::TextField::Property::MAX_LENGTH,
+ EXCEED_POLICY = Dali::Toolkit::TextField::Property::EXCEED_POLICY,
+ HORIZONTAL_ALIGNMENT = Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT,
+ VERTICAL_ALIGNMENT = Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT,
+ TEXT_COLOR = Dali::Toolkit::TextField::Property::TEXT_COLOR,
+ PLACEHOLDER_TEXT_COLOR = Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR,
+ PRIMARY_CURSOR_COLOR = Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR,
+ SECONDARY_CURSOR_COLOR = Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR,
+ ENABLE_CURSOR_BLINK = Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK,
+ CURSOR_BLINK_INTERVAL = Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL,
+ CURSOR_BLINK_DURATION = Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION,
+ CURSOR_WIDTH = Dali::Toolkit::TextField::Property::CURSOR_WIDTH,
+ GRAB_HANDLE_IMAGE = Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE,
+ GRAB_HANDLE_PRESSED_IMAGE = Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE,
+ SCROLL_THRESHOLD = Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD,
+ SCROLL_SPEED = Dali::Toolkit::TextField::Property::SCROLL_SPEED,
+ SELECTION_HANDLE_IMAGE_LEFT = Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT,
+ SELECTION_HANDLE_IMAGE_RIGHT = Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT,
+ SELECTION_HANDLE_PRESSED_IMAGE_LEFT = Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT,
+ SELECTION_HANDLE_PRESSED_IMAGE_RIGHT = Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT,
+ SELECTION_HANDLE_MARKER_IMAGE_LEFT = Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT,
+ SELECTION_HANDLE_MARKER_IMAGE_RIGHT = Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT,
+ SELECTION_HIGHLIGHT_COLOR = Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR,
+ DECORATION_BOUNDING_BOX = Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX,
+ INPUT_METHOD_SETTINGS = Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS,
+ INPUT_COLOR = Dali::Toolkit::TextField::Property::INPUT_COLOR,
+ ENABLE_MARKUP = Dali::Toolkit::TextField::Property::ENABLE_MARKUP,
+ INPUT_FONT_FAMILY = Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY,
+ INPUT_FONT_STYLE = Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE,
+ INPUT_POINT_SIZE = Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE,
+ UNDERLINE = Dali::Toolkit::TextField::Property::UNDERLINE,
+ INPUT_UNDERLINE = Dali::Toolkit::TextField::Property::INPUT_UNDERLINE,
+ SHADOW = Dali::Toolkit::TextField::Property::SHADOW,
+ INPUT_SHADOW = Dali::Toolkit::TextField::Property::INPUT_SHADOW,
+ EMBOSS = Dali::Toolkit::TextField::Property::EMBOSS,
+ INPUT_EMBOSS = Dali::Toolkit::TextField::Property::INPUT_EMBOSS,
+ OUTLINE = Dali::Toolkit::TextField::Property::OUTLINE,
+ INPUT_OUTLINE = Dali::Toolkit::TextField::Property::INPUT_OUTLINE,
+ HIDDEN_INPUT_SETTINGS = Dali::Toolkit::TextField::Property::HIDDEN_INPUT_SETTINGS,
+ PIXEL_SIZE = Dali::Toolkit::TextField::Property::PIXEL_SIZE,
+ ENABLE_SELECTION = Dali::Toolkit::TextField::Property::ENABLE_SELECTION,
+ PLACEHOLDER = Dali::Toolkit::TextField::Property::PLACEHOLDER,
+ ELLIPSIS = Dali::Toolkit::TextField::Property::ELLIPSIS,
+
+ /**
* @brief Enables Text selection using Shift key.
* @details Name "enableShiftSelection", type Property::BOOLEAN.
*/
- ENABLE_SHIFT_SELECTION = ELLIPSIS + 1,
+ ENABLE_SHIFT_SELECTION = ELLIPSIS + 1,
- /**
+ /**
* @brief Enables the grab handles for text selection.
* @details Name "enableGrabHandle", type Property::BOOLEAN.
* @note The default value is true, which means the grab handles are enabled by default.
*/
- ENABLE_GRAB_HANDLE = ELLIPSIS + 2,
+ ENABLE_GRAB_HANDLE = ELLIPSIS + 2,
- /**
+ /**
* @brief Modifies the default text alignment to match the direction of the system language.
* @details Name "matchSystemLanguageDirection", type (Property::BOOLEAN), Read/Write
* @note The default value is false
*/
- MATCH_SYSTEM_LANGUAGE_DIRECTION = ELLIPSIS + 3,
+ MATCH_SYSTEM_LANGUAGE_DIRECTION = ELLIPSIS + 3,
- /**
+ /**
* @brief Enables the grab handle popup for text selection.
* @details Name "enableGrabHandlePopup", type Property::BOOLEAN.
* @note The default value is true, which means the grab handle popup is enabled by default.
*/
- ENABLE_GRAB_HANDLE_POPUP = ELLIPSIS + 4,
+ ENABLE_GRAB_HANDLE_POPUP = ELLIPSIS + 4,
- /**
+ /**
* @brief The default text background parameters.
* @details Name "textBackground", type Property::VECTOR4.
* @note Use "textBackground" as property name to avoid conflict with Control's "background" property.
* @note The default value is Color::TRANSPARENT.
*/
- BACKGROUND = ELLIPSIS + 5,
-
+ BACKGROUND = ELLIPSIS + 5,
- /**
+ /**
* @brief The selected text in UTF-8 format.
* @details Name "selectedText", type Property::STRING.
* @note This property is read-only.
*/
- SELECTED_TEXT = ELLIPSIS + 6,
+ SELECTED_TEXT = ELLIPSIS + 6,
- /**
+ /**
* @brief The type or rendering e.g. bitmap-based.
* @details Name "renderingBackend", type Property::INTEGER.
*/
- RENDERING_BACKEND = ELLIPSIS + 7,
+ RENDERING_BACKEND = ELLIPSIS + 7,
- };
+};
} // namespace Property
/**
* @param[in] textField The instance of TextField.
* @return InputMethodContext instance.
*/
-DALI_TOOLKIT_API InputMethodContext GetInputMethodContext( TextField textField );
+DALI_TOOLKIT_API InputMethodContext GetInputMethodContext(TextField textField);
/**
* @brief Select the whole text of TextField.
*
* @param[in] textField The instance of TextField.
*/
-DALI_TOOLKIT_API void SelectWholeText( TextField textField );
+DALI_TOOLKIT_API void SelectWholeText(TextField textField);
/**
* @brief Unselect the whole text of TextField.
*
* @param[in] textField The instance of TextField.
*/
-DALI_TOOLKIT_API void SelectNone( TextField textField );
+DALI_TOOLKIT_API void SelectNone(TextField textField);
-} // namespace DevelText
+} // namespace DevelTextField
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelTextLabel
{
-
namespace Property
{
- enum Type
- {
- TEXT = Dali::Toolkit::TextLabel::Property::TEXT,
- FONT_FAMILY = Dali::Toolkit::TextLabel::Property::FONT_FAMILY,
- FONT_STYLE = Dali::Toolkit::TextLabel::Property::FONT_STYLE,
- POINT_SIZE = Dali::Toolkit::TextLabel::Property::POINT_SIZE,
- MULTI_LINE = Dali::Toolkit::TextLabel::Property::MULTI_LINE,
- HORIZONTAL_ALIGNMENT = Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT,
- VERTICAL_ALIGNMENT = Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT,
- ENABLE_MARKUP = Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP,
- ENABLE_AUTO_SCROLL = Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL,
- AUTO_SCROLL_SPEED = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED,
- AUTO_SCROLL_LOOP_COUNT = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT,
- AUTO_SCROLL_GAP = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP,
- LINE_SPACING = Dali::Toolkit::TextLabel::Property::LINE_SPACING,
- UNDERLINE = Dali::Toolkit::TextLabel::Property::UNDERLINE,
- SHADOW = Dali::Toolkit::TextLabel::Property::SHADOW,
- EMBOSS = Dali::Toolkit::TextLabel::Property::EMBOSS,
- OUTLINE = Dali::Toolkit::TextLabel::Property::OUTLINE,
- PIXEL_SIZE = Dali::Toolkit::TextLabel::Property::PIXEL_SIZE,
- ELLIPSIS = Dali::Toolkit::TextLabel::Property::ELLIPSIS,
- AUTO_SCROLL_LOOP_DELAY = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_DELAY,
- AUTO_SCROLL_STOP_MODE = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_STOP_MODE,
- LINE_COUNT = Dali::Toolkit::TextLabel::Property::LINE_COUNT,
- LINE_WRAP_MODE = Dali::Toolkit::TextLabel::Property::LINE_WRAP_MODE,
-
- /**
+enum Type
+{
+ TEXT = Dali::Toolkit::TextLabel::Property::TEXT,
+ FONT_FAMILY = Dali::Toolkit::TextLabel::Property::FONT_FAMILY,
+ FONT_STYLE = Dali::Toolkit::TextLabel::Property::FONT_STYLE,
+ POINT_SIZE = Dali::Toolkit::TextLabel::Property::POINT_SIZE,
+ MULTI_LINE = Dali::Toolkit::TextLabel::Property::MULTI_LINE,
+ HORIZONTAL_ALIGNMENT = Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT,
+ VERTICAL_ALIGNMENT = Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT,
+ ENABLE_MARKUP = Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP,
+ ENABLE_AUTO_SCROLL = Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL,
+ AUTO_SCROLL_SPEED = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED,
+ AUTO_SCROLL_LOOP_COUNT = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT,
+ AUTO_SCROLL_GAP = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP,
+ LINE_SPACING = Dali::Toolkit::TextLabel::Property::LINE_SPACING,
+ UNDERLINE = Dali::Toolkit::TextLabel::Property::UNDERLINE,
+ SHADOW = Dali::Toolkit::TextLabel::Property::SHADOW,
+ EMBOSS = Dali::Toolkit::TextLabel::Property::EMBOSS,
+ OUTLINE = Dali::Toolkit::TextLabel::Property::OUTLINE,
+ PIXEL_SIZE = Dali::Toolkit::TextLabel::Property::PIXEL_SIZE,
+ ELLIPSIS = Dali::Toolkit::TextLabel::Property::ELLIPSIS,
+ AUTO_SCROLL_LOOP_DELAY = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_DELAY,
+ AUTO_SCROLL_STOP_MODE = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_STOP_MODE,
+ LINE_COUNT = Dali::Toolkit::TextLabel::Property::LINE_COUNT,
+ LINE_WRAP_MODE = Dali::Toolkit::TextLabel::Property::LINE_WRAP_MODE,
+
+ /**
* @brief The direction of the layout.
* @details Name "textDirection", type [Type](@ref Dali::Toolkit::DevelText::TextDirection::Type) (Property::INTEGER), Read/Write
* @note The text direction can be changed only by replacing the text itself.
* @see TextDirection::Type for supported values.
*/
- TEXT_DIRECTION,
+ TEXT_DIRECTION,
- /**
+ /**
* @brief Alignment of text within area of single line
* @details Name "verticalLineAlignment", type [Type](@ref Dali::Toolkit::DevelText::VerticalLineAlignment::Type) (Property::INTEGER), Read/Write
* @note The default value is TOP
* @see VerticalLineAlignment::Type for supported values
*/
- VERTICAL_LINE_ALIGNMENT,
+ VERTICAL_LINE_ALIGNMENT,
- /**
+ /**
* @brief The default text background parameters.
* @details Name "textBackground", type Property::MAP.
* @note Use "textBackground" as property name to avoid conflict with Control's "background" property
* | enable | BOOLEAN | No | True to enable the background or false to disable (the default value is false) |
* | color | VECTOR4 | No | The color of the background (the default value is Color::CYAN) |
*/
- BACKGROUND,
+ BACKGROUND,
- /**
+ /**
* @brief Ignore spaces after text.
* @details Name "ignoreSpacesAfterText", type (Property::BOLEAN), Read/Write
* @note The default value is true
*/
- IGNORE_SPACES_AFTER_TEXT,
+ IGNORE_SPACES_AFTER_TEXT,
- /**
+ /**
* @brief Modifies the default text alignment to match the direction of the system language.
* @details Name "matchSystemLanguageDirection", type (Property::BOLEAN), Read/Write
* @note The default value is false
* | ﻡﺮﺤﺑﺍ. | ﻡﺮﺤﺑﺍ. |
*
*/
- MATCH_SYSTEM_LANGUAGE_DIRECTION,
+ MATCH_SYSTEM_LANGUAGE_DIRECTION,
- /**
+ /**
* @brief The text fit parameters.
* @details Name "textFit", type Property::MAP.
* @note The default value is false
* | stepSize | FLOAT | No | Step Size for font increase (the default value is 1.f) |
* | fontSizeType | STRING | No | The size type of font, You can choose between "pointSize" or "pixelSize". (the default value is "pointSize") |
*/
- TEXT_FIT,
+ TEXT_FIT,
- /**
+ /**
* @brief Sets the height of the line in points.
* @details Name "lineSize", type Property::FLOAT.
* @note If the font size is larger than the line size, it works with the font size.
*/
- MIN_LINE_SIZE,
+ MIN_LINE_SIZE,
- /**
+ /**
* @brief The type of rendering e.g. bitmap-based.
* @details Name "renderingBackend", type Property::INT.
*/
- RENDERING_BACKEND,
- };
+ RENDERING_BACKEND,
+};
} // namespace Property
#define DALI_TOOLKIT_TEXT_SELECTION_POPUP_CALLBACK_INTERFACE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @brief Interface used to receive the TextSelectionPopup's button callbacks.
*/
* @brief Virtual destructor.
*/
virtual ~TextSelectionPopupCallbackInterface()
- {}
+ {
+ }
/**
* @brief Called when a button is touched.
*
* @param[in] button The button identifier.
*/
- virtual void TextPopupButtonTouched( TextSelectionPopup::Buttons button ) = 0;
+ virtual void TextPopupButtonTouched(TextSelectionPopup::Buttons button) = 0;
};
} // namespace Toolkit
} // namespace Dali
-
#endif // DALI_TOOLKIT_TEXT_SELECTION_POPUP_CALLBACK_INTERFACE_H
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
-TextSelectionPopup TextSelectionPopup::New( TextSelectionPopupCallbackInterface* callbackInterface )
+TextSelectionPopup TextSelectionPopup::New(TextSelectionPopupCallbackInterface* callbackInterface)
{
- return Internal::TextSelectionPopup::New( callbackInterface );
+ return Internal::TextSelectionPopup::New(callbackInterface);
}
TextSelectionPopup::TextSelectionPopup()
{
}
-TextSelectionPopup::TextSelectionPopup( const TextSelectionPopup& handle )
-: Control( handle )
+TextSelectionPopup::TextSelectionPopup(const TextSelectionPopup& handle)
+: Control(handle)
{
}
-TextSelectionPopup& TextSelectionPopup::operator=( const TextSelectionPopup& handle )
+TextSelectionPopup& TextSelectionPopup::operator=(const TextSelectionPopup& handle)
{
- if( &handle != this )
+ if(&handle != this)
{
- Control::operator=( handle );
+ Control::operator=(handle);
}
return *this;
}
{
}
-TextSelectionPopup TextSelectionPopup::DownCast( BaseHandle handle )
+TextSelectionPopup TextSelectionPopup::DownCast(BaseHandle handle)
{
return Control::DownCast<TextSelectionPopup, Internal::TextSelectionPopup>(handle);
}
-void TextSelectionPopup::EnableButtons( Toolkit::TextSelectionPopup::Buttons buttonsToEnable )
+void TextSelectionPopup::EnableButtons(Toolkit::TextSelectionPopup::Buttons buttonsToEnable)
{
- GetImpl(*this).EnableButtons( buttonsToEnable );
+ GetImpl(*this).EnableButtons(buttonsToEnable);
}
-void TextSelectionPopup::RaiseAbove( Layer target )
+void TextSelectionPopup::RaiseAbove(Layer target)
{
- GetImpl(*this).RaiseAbove( target );
+ GetImpl(*this).RaiseAbove(target);
}
void TextSelectionPopup::ShowPopup()
GetImpl(*this).HidePopup();
}
-TextSelectionPopup::TextSelectionPopup( Internal::TextSelectionPopup& implementation )
+TextSelectionPopup::TextSelectionPopup(Internal::TextSelectionPopup& implementation)
: Control(implementation)
{
}
-TextSelectionPopup::TextSelectionPopup( Dali::Internal::CustomActor* internal )
-: Control( internal )
+TextSelectionPopup::TextSelectionPopup(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
- VerifyCustomActorPointer<Internal::TextSelectionPopup>( internal );
+ VerifyCustomActorPointer<Internal::TextSelectionPopup>(internal);
}
-
} // namespace Toolkit
} // namespace Dali
#define DALI_TOOLKIT_TEXT_SELECTION_POPUP_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
class TextSelectionPopupCallbackInterface;
namespace Internal DALI_INTERNAL
class DALI_TOOLKIT_API TextSelectionPopup : public Control
{
public:
-
enum Buttons
{
- CUT = 1u << 0,
- COPY = 1u << 1,
- PASTE = 1u << 2,
- SELECT = 1u << 3,
+ CUT = 1u << 0,
+ COPY = 1u << 1,
+ PASTE = 1u << 2,
+ SELECT = 1u << 3,
SELECT_ALL = 1u << 4,
- CLIPBOARD = 1u << 5,
- NONE = 1u << 6,
+ CLIPBOARD = 1u << 5,
+ NONE = 1u << 6,
};
/**
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1,
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
};
/**
* @brief The maximum size the Popup can be.
* @details Name "popupMaxSize", type Vector2.
*/
- POPUP_MAX_SIZE = PROPERTY_START_INDEX,
+ POPUP_MAX_SIZE = PROPERTY_START_INDEX,
/**
* @brief The minimum size the Popup can be.
* @param[in] callbackInterface The text popup callback interface which receives the button click callbacks.
* @return A handle to the TextSelectionPopup control.
*/
- static TextSelectionPopup New( TextSelectionPopupCallbackInterface* callbackInterface );
+ static TextSelectionPopup New(TextSelectionPopupCallbackInterface* callbackInterface);
/**
* @brief Creates an empty handle.
*
* @param[in] handle The handle to copy from.
*/
- TextSelectionPopup( const TextSelectionPopup& handle );
+ TextSelectionPopup(const TextSelectionPopup& handle);
/**
* @brief Assignment operator.
* @param[in] handle The handle to copy from.
* @return A reference to this.
*/
- TextSelectionPopup& operator=( const TextSelectionPopup& handle );
+ TextSelectionPopup& operator=(const TextSelectionPopup& handle);
/**
* @brief Destructor
* @param[in] handle Handle to an object
* @return handle to a TextSelectionPopup or an empty handle
*/
- static TextSelectionPopup DownCast( BaseHandle handle );
+ static TextSelectionPopup DownCast(BaseHandle handle);
/**
* @brief Specify which buttons to show in Popup
* @param[in] buttonsToEnable Buttons to enable
*/
- void EnableButtons( Toolkit::TextSelectionPopup::Buttons buttonsToEnable );
+ void EnableButtons(Toolkit::TextSelectionPopup::Buttons buttonsToEnable);
/**
* @brief Raises the toolbar's layer above the given @e target layer.
*
* @param[in] target The layer to get above of.
*/
- void RaiseAbove( Layer target );
+ void RaiseAbove(Layer target);
/**
* @brief Show the Popup if not being shown
void HidePopup();
public: // Not intended for application developers
-
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
*
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL TextSelectionPopup( Internal::TextSelectionPopup& implementation );
+ DALI_INTERNAL TextSelectionPopup(Internal::TextSelectionPopup& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- explicit DALI_INTERNAL TextSelectionPopup( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL TextSelectionPopup(Dali::Internal::CustomActor* internal);
}; // Class TextSelectionPopup
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
TextSelectionToolbar TextSelectionToolbar::New()
{
return Internal::TextSelectionToolbar::New();
{
}
-TextSelectionToolbar::TextSelectionToolbar( const TextSelectionToolbar& handle )
-: Control( handle )
+TextSelectionToolbar::TextSelectionToolbar(const TextSelectionToolbar& handle)
+: Control(handle)
{
}
-TextSelectionToolbar& TextSelectionToolbar::operator=( const TextSelectionToolbar& handle )
+TextSelectionToolbar& TextSelectionToolbar::operator=(const TextSelectionToolbar& handle)
{
- if( &handle != this )
+ if(&handle != this)
{
- Control::operator=( handle );
+ Control::operator=(handle);
}
return *this;
}
{
}
-void TextSelectionToolbar::AddOption( Actor& option )
+void TextSelectionToolbar::AddOption(Actor& option)
{
GetImpl(*this).AddOption(option);
}
-void TextSelectionToolbar::AddDivider( Actor& divider )
+void TextSelectionToolbar::AddDivider(Actor& divider)
{
- GetImpl(*this).AddDivider( divider );
+ GetImpl(*this).AddDivider(divider);
}
-void TextSelectionToolbar::ResizeDividers( Size& size )
+void TextSelectionToolbar::ResizeDividers(Size& size)
{
- GetImpl(*this).ResizeDividers( size );
+ GetImpl(*this).ResizeDividers(size);
}
-void TextSelectionToolbar::RaiseAbove( Layer target )
+void TextSelectionToolbar::RaiseAbove(Layer target)
{
- GetImpl(*this).RaiseAbove( target );
+ GetImpl(*this).RaiseAbove(target);
}
-void TextSelectionToolbar::ScrollTo( const Vector2& position )
+void TextSelectionToolbar::ScrollTo(const Vector2& position)
{
- GetImpl(*this).ScrollTo( position );
+ GetImpl(*this).ScrollTo(position);
}
-TextSelectionToolbar TextSelectionToolbar::DownCast( BaseHandle handle )
+TextSelectionToolbar TextSelectionToolbar::DownCast(BaseHandle handle)
{
return Control::DownCast<TextSelectionToolbar, Internal::TextSelectionToolbar>(handle);
}
-TextSelectionToolbar::TextSelectionToolbar( Internal::TextSelectionToolbar& implementation )
+TextSelectionToolbar::TextSelectionToolbar(Internal::TextSelectionToolbar& implementation)
: Control(implementation)
{
}
-TextSelectionToolbar::TextSelectionToolbar( Dali::Internal::CustomActor* internal )
-: Control( internal )
+TextSelectionToolbar::TextSelectionToolbar(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
- VerifyCustomActorPointer<Internal::TextSelectionToolbar>( internal );
+ VerifyCustomActorPointer<Internal::TextSelectionToolbar>(internal);
}
-
} // namespace Toolkit
} // namespace Dali
#define DALI_TOOLKIT_TEXT_SELECTION_TOOLBAR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class TextSelectionToolbar;
class DALI_TOOLKIT_API TextSelectionToolbar : public Control
{
public:
-
/**
* @brief The start and end property ranges for this control.
*/
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1,
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
};
/**
{
enum
{
- MAX_SIZE = PROPERTY_START_INDEX, ///< name "maxSize", The maximum size the Popup can be, type VECTOR2
- ENABLE_OVERSHOOT, ///< name "enableOvershoot", Whether the overshoot image is enabled, type BOOLEAN
- ENABLE_SCROLL_BAR, ///< name "enableScrollBar", Whether the scroll-bar is enabled, type BOOLEAN
- SCROLL_BAR_PADDING, ///< name "scrollBarPadding", The padding used to position the scroll bar, type VECTOR2
- SCROLL_VIEW, ///< name "scrollView", Properties to set on scroll view type Property::Map
+ MAX_SIZE = PROPERTY_START_INDEX, ///< name "maxSize", The maximum size the Popup can be, type VECTOR2
+ ENABLE_OVERSHOOT, ///< name "enableOvershoot", Whether the overshoot image is enabled, type BOOLEAN
+ ENABLE_SCROLL_BAR, ///< name "enableScrollBar", Whether the scroll-bar is enabled, type BOOLEAN
+ SCROLL_BAR_PADDING, ///< name "scrollBarPadding", The padding used to position the scroll bar, type VECTOR2
+ SCROLL_VIEW, ///< name "scrollView", Properties to set on scroll view type Property::Map
};
};
*
* @param[in] handle The handle to copy from.
*/
- TextSelectionToolbar( const TextSelectionToolbar& handle );
+ TextSelectionToolbar(const TextSelectionToolbar& handle);
/**
* @brief Assignment operator.
* @param[in] handle The handle to copy from.
* @return A reference to this.
*/
- TextSelectionToolbar& operator=( const TextSelectionToolbar& handle );
+ TextSelectionToolbar& operator=(const TextSelectionToolbar& handle);
/**
* @brief Destructor
*/
~TextSelectionToolbar();
-
/**
* @brief Add a option to the the Tool bar
* @param[in] option Option actor to add
*/
- void AddOption( Actor& option );
+ void AddOption(Actor& option);
/**
* @brief Add a divider to the the Tool bar
* @param[in] divider Actor to be used as divider
*/
- void AddDivider( Actor& divider );
+ void AddDivider(Actor& divider);
/**
* @brief ResizeDividers
* @param[in] size New size of dividers, provide 0 for height to automatically set height
*/
- void ResizeDividers( Size& size );
+ void ResizeDividers(Size& size);
/**
* @brief Raises the layer above the given @e target layer.
*
* @param[in] target The layer to get above of.
*/
- void RaiseAbove( Layer target );
+ void RaiseAbove(Layer target);
/**
* @copydoc Toolkit::ScrollView::ScrollTo(const Vector2&)
*/
- void ScrollTo( const Vector2& position );
+ void ScrollTo(const Vector2& position);
/**
* @brief Downcast a handle to TextSelectionToolbar.
* @param[in] handle Handle to an object
* @return handle to a TextSelectionToolbar or an empty handle
*/
- static TextSelectionToolbar DownCast( BaseHandle handle );
+ static TextSelectionToolbar DownCast(BaseHandle handle);
public: // Not intended for application developers
-
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
*
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL TextSelectionToolbar( Internal::TextSelectionToolbar& implementation );
+ DALI_INTERNAL TextSelectionToolbar(Internal::TextSelectionToolbar& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- explicit DALI_INTERNAL TextSelectionToolbar( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL TextSelectionToolbar(Dali::Internal::CustomActor* internal);
}; // Class TextSelectionToolbar
#define DALI_TOOLKIT_TEXT_STYLE_PROPERTIES_DEVEL_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_controls
* @{
namespace DevelText
{
-
namespace Shadow
{
-
/**
* @brief Used by Text controls to show different styles of text.
*
*/
namespace Property
{
-
enum
{
/**
namespace Underline
{
-
namespace Property
{
-
enum
{
/**
namespace Outline
{
-
namespace Property
{
-
enum
{
/**
namespace Background
{
-
namespace Property
{
-
enum
{
/**
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// INTERNAL INCLUDES
-#include <dali/integration-api/debug.h>
#include <dali-toolkit/internal/controls/tool-bar/tool-bar-impl.h>
+#include <dali/integration-api/debug.h>
namespace Dali
{
-
namespace Toolkit
{
-
-const Toolkit::Alignment::Padding ToolBar::DEFAULT_PADDING( 0.f, 0.f, 0.f, 0.f );
+const Toolkit::Alignment::Padding ToolBar::DEFAULT_PADDING(0.f, 0.f, 0.f, 0.f);
ToolBar::ToolBar()
{
}
-ToolBar::ToolBar( const ToolBar& handle )
-: Control( handle )
+ToolBar::ToolBar(const ToolBar& handle)
+: Control(handle)
{
}
-ToolBar& ToolBar::operator=( const ToolBar& handle )
+ToolBar& ToolBar::operator=(const ToolBar& handle)
{
- if( &handle != this )
+ if(&handle != this)
{
- Control::operator=( handle );
+ Control::operator=(handle);
}
return *this;
}
return Internal::ToolBar::New();
}
-ToolBar ToolBar::DownCast( BaseHandle handle )
+ToolBar ToolBar::DownCast(BaseHandle handle)
{
return Control::DownCast<ToolBar, Internal::ToolBar>(handle);
}
-void ToolBar::AddControl( Actor control, float relativeSize, Toolkit::Alignment::Type alignment, const Toolkit::Alignment::Padding& padding )
+void ToolBar::AddControl(Actor control, float relativeSize, Toolkit::Alignment::Type alignment, const Toolkit::Alignment::Padding& padding)
{
- GetImpl( *this ).AddControl( control, relativeSize, alignment, padding );
+ GetImpl(*this).AddControl(control, relativeSize, alignment, padding);
}
-void ToolBar::RemoveControl( Actor control )
+void ToolBar::RemoveControl(Actor control)
{
- GetImpl( *this ).RemoveControl( control );
+ GetImpl(*this).RemoveControl(control);
}
-ToolBar::ToolBar( Internal::ToolBar& implementation )
-: Control( implementation )
+ToolBar::ToolBar(Internal::ToolBar& implementation)
+: Control(implementation)
{
}
-ToolBar::ToolBar( Dali::Internal::CustomActor* internal )
-: Control( internal )
+ToolBar::ToolBar(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::ToolBar>(internal);
}
#define DALI_TOOLKIT_TOOL_BAR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
// Forward declarations
class ToolBar;
-}
+} // namespace DALI_INTERNAL
/**
* Provides a tool bar where other controls (Dali::Actor) could be placed.
* Copy constructor. Creates another handle that points to the same real object
* @param handle to copy from
*/
- ToolBar( const ToolBar& handle );
+ ToolBar(const ToolBar& handle);
/**
* Assignment operator. Changes this handle to point to another real object
*/
- ToolBar& operator=( const ToolBar& handle );
+ ToolBar& operator=(const ToolBar& handle);
/**
* @brief Destructor
* @param[in] handle Handle to an object
* @return handle to a ToolBar or an uninitialized handle
*/
- static ToolBar DownCast( BaseHandle handle );
+ static ToolBar DownCast(BaseHandle handle);
/**
* Adds an additional control to the tool bar.
* @param alignment Where to insert controls. Possible values are Toolkit::Alignment::Left, Toolkit::Alignment::Center or Toolkit::Alignment::Right.
* @param padding Padding values used for the added control (left, right, top, bottom). By default, no padding is added.
*/
- void AddControl( Actor control, float relativeSize, Toolkit::Alignment::Type alignment, const Toolkit::Alignment::Padding& padding = DEFAULT_PADDING );
+ void AddControl(Actor control, float relativeSize, Toolkit::Alignment::Type alignment, const Toolkit::Alignment::Padding& padding = DEFAULT_PADDING);
/**
* Removes a control from the tool bar.
* @pre control must have been added before to this tool bar.
* @param control The control to be removed.
*/
- void RemoveControl( Actor control );
+ void RemoveControl(Actor control);
public: // Not intended for application developers
-
/**
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL ToolBar( Internal::ToolBar& implementation );
+ DALI_INTERNAL ToolBar(Internal::ToolBar& implementation);
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- explicit DALI_INTERNAL ToolBar( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL ToolBar(Dali::Internal::CustomActor* internal);
};
} // namespace Toolkit
#define DALI_TOOLKIT_TOOLTIP_PROPERTIES_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Tooltip
{
-
/**
* @brief The properties used for a Tooltip.
*/
namespace Property
{
-
enum
{
/**
namespace Background
{
-
namespace Property
{
-
enum
{
/**
*/
namespace Tail
{
-
/**
* @brief The properties of the tail used by the tooltip.
*/
namespace Property
{
-
enum
{
/**
namespace Position
{
-
/**
* @brief The position of the tooltip in relation to the control.
*/
enum Type
{
- ABOVE, ///< The tooltip will appear above the control.
- BELOW, ///< The tooltip will appear below the control.
+ ABOVE, ///< The tooltip will appear above the control.
+ BELOW, ///< The tooltip will appear below the control.
HOVER_POINT ///< The tooltip will appear near the hover point.
};
\r
namespace Dali\r
{\r
-\r
namespace Toolkit\r
{\r
-\r
namespace DevelVideoView\r
{\r
-\r
-Any GetMediaPlayer( VideoView videoView )\r
+Any GetMediaPlayer(VideoView videoView)\r
{\r
- return Dali::Toolkit::GetImpl( videoView ).GetMediaPlayer();\r
+ return Dali::Toolkit::GetImpl(videoView).GetMediaPlayer();\r
}\r
\r
-VideoView New( VideoSyncMode syncMode )\r
+VideoView New(VideoSyncMode syncMode)\r
{\r
- VideoView videoView = Internal::VideoView::New( syncMode );\r
+ VideoView videoView = Internal::VideoView::New(syncMode);\r
return videoView;\r
}\r
\r
-void PlayAnimation( VideoView videoView, Animation animation )\r
+void PlayAnimation(VideoView videoView, Animation animation)\r
{\r
- Dali::Toolkit::GetImpl( videoView ).PlayAnimation( animation );\r
+ Dali::Toolkit::GetImpl(videoView).PlayAnimation(animation);\r
}\r
\r
} // namespace DevelVideoView\r
#include <dali/devel-api/adaptor-framework/video-sync-mode.h>\r
\r
// INTERNAL INCLUDES\r
-#include <dali/public-api/animation/animation.h>\r
#include <dali-toolkit/public-api/controls/video-view/video-view.h>\r
+#include <dali/public-api/animation/animation.h>\r
#include <dali/public-api/object/any.h>\r
\r
namespace Dali\r
{\r
-\r
namespace Toolkit\r
{\r
-\r
namespace DevelVideoView\r
{\r
-\r
/**\r
* @brief Returns the internal media player.\r
* @param[in] videoView The current VideoView\r
* @return The internal media player of current VideoView\r
*/\r
-DALI_TOOLKIT_API Any GetMediaPlayer( VideoView videoView );\r
+DALI_TOOLKIT_API Any GetMediaPlayer(VideoView videoView);\r
\r
/**\r
* @brief Creates an initialized VideoView with synchronization mode.\r
* @param[in] syncMode The synchronization mode between the UI (transparent hole) and VideoPlayer\r
* @return A handle to a newly allocated Dali VideoView\r
*/\r
-DALI_TOOLKIT_API VideoView New( VideoSyncMode syncMode );\r
+DALI_TOOLKIT_API VideoView New(VideoSyncMode syncMode);\r
\r
/**\r
* @brief Play the resize or move animation with synchronization between UI(transparent hole) and video player\r
* @param[in] videoView The current VideoView\r
* @param[in] animation The animation for video view's resize or move.\r
*/\r
-DALI_TOOLKIT_API void PlayAnimation( VideoView videoView, Animation animation );\r
+DALI_TOOLKIT_API void PlayAnimation(VideoView videoView, Animation animation);\r
\r
} // namespace DevelVideoView\r
\r
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
WebView::WebView()
{
}
-WebView::WebView( const WebView& WebView )
-: Control( WebView )
+WebView::WebView(const WebView& WebView)
+: Control(WebView)
{
}
-WebView& WebView::operator=( const WebView& view )
+WebView& WebView::operator=(const WebView& view)
{
- if( &view != this )
+ if(&view != this)
{
- Control::operator=( view );
+ Control::operator=(view);
}
return *this;
return Internal::WebView::New();
}
-WebView WebView::New( const std::string& locale, const std::string& timezoneId )
+WebView WebView::New(const std::string& locale, const std::string& timezoneId)
{
- return Internal::WebView::New( locale, timezoneId );
+ return Internal::WebView::New(locale, timezoneId);
}
-WebView WebView::DownCast( BaseHandle handle )
+WebView WebView::DownCast(BaseHandle handle)
{
- return Control::DownCast< WebView, Internal::WebView >( handle );
+ return Control::DownCast<WebView, Internal::WebView>(handle);
}
-void WebView::LoadUrl( const std::string& url )
+void WebView::LoadUrl(const std::string& url)
{
- Dali::Toolkit::GetImpl( *this ).LoadUrl( url );
+ Dali::Toolkit::GetImpl(*this).LoadUrl(url);
}
-void WebView::LoadHTMLString( const std::string& htmlString )
+void WebView::LoadHTMLString(const std::string& htmlString)
{
- Dali::Toolkit::GetImpl( *this ).LoadHTMLString( htmlString );
+ Dali::Toolkit::GetImpl(*this).LoadHTMLString(htmlString);
}
void WebView::Reload()
{
- Dali::Toolkit::GetImpl( *this ).Reload();
+ Dali::Toolkit::GetImpl(*this).Reload();
}
void WebView::StopLoading()
{
- Dali::Toolkit::GetImpl( *this ).StopLoading();
+ Dali::Toolkit::GetImpl(*this).StopLoading();
}
void WebView::Suspend()
{
- Dali::Toolkit::GetImpl( *this ).Suspend();
+ Dali::Toolkit::GetImpl(*this).Suspend();
}
void WebView::Resume()
{
- Dali::Toolkit::GetImpl( *this ).Resume();
+ Dali::Toolkit::GetImpl(*this).Resume();
}
bool WebView::CanGoForward()
{
- return Dali::Toolkit::GetImpl( *this ).CanGoForward();
+ return Dali::Toolkit::GetImpl(*this).CanGoForward();
}
void WebView::GoForward()
{
- Dali::Toolkit::GetImpl( *this ).GoForward();
+ Dali::Toolkit::GetImpl(*this).GoForward();
}
bool WebView::CanGoBack()
{
- return Dali::Toolkit::GetImpl( *this ).CanGoBack();
+ return Dali::Toolkit::GetImpl(*this).CanGoBack();
}
void WebView::GoBack()
{
- Dali::Toolkit::GetImpl( *this ).GoBack();
+ Dali::Toolkit::GetImpl(*this).GoBack();
}
-void WebView::EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler )
+void WebView::EvaluateJavaScript(const std::string& script, std::function<void(const std::string&)> resultHandler)
{
- Dali::Toolkit::GetImpl( *this ).EvaluateJavaScript( script, resultHandler );
+ Dali::Toolkit::GetImpl(*this).EvaluateJavaScript(script, resultHandler);
}
-void WebView::EvaluateJavaScript( const std::string& script )
+void WebView::EvaluateJavaScript(const std::string& script)
{
- Dali::Toolkit::GetImpl( *this ).EvaluateJavaScript( script, nullptr );
+ Dali::Toolkit::GetImpl(*this).EvaluateJavaScript(script, nullptr);
}
-void WebView::AddJavaScriptMessageHandler( const std::string& exposedObjectName, std::function< void( const std::string& ) > handler )
+void WebView::AddJavaScriptMessageHandler(const std::string& exposedObjectName, std::function<void(const std::string&)> handler)
{
- Dali::Toolkit::GetImpl( *this ).AddJavaScriptMessageHandler( exposedObjectName, handler );
+ Dali::Toolkit::GetImpl(*this).AddJavaScriptMessageHandler(exposedObjectName, handler);
}
void WebView::ClearHistory()
{
- Dali::Toolkit::GetImpl( *this ).ClearHistory();
+ Dali::Toolkit::GetImpl(*this).ClearHistory();
}
void WebView::ClearCache()
{
- Dali::Toolkit::GetImpl( *this ).ClearCache();
+ Dali::Toolkit::GetImpl(*this).ClearCache();
}
void WebView::ClearCookies()
{
- Dali::Toolkit::GetImpl( *this ).ClearCookies();
+ Dali::Toolkit::GetImpl(*this).ClearCookies();
}
WebView::WebViewPageLoadSignalType& WebView::PageLoadStartedSignal()
{
- return Dali::Toolkit::GetImpl( *this ).PageLoadStartedSignal();
+ return Dali::Toolkit::GetImpl(*this).PageLoadStartedSignal();
}
WebView::WebViewPageLoadSignalType& WebView::PageLoadFinishedSignal()
{
- return Dali::Toolkit::GetImpl( *this ).PageLoadFinishedSignal();
+ return Dali::Toolkit::GetImpl(*this).PageLoadFinishedSignal();
}
WebView::WebViewPageLoadErrorSignalType& WebView::PageLoadErrorSignal()
{
- return Dali::Toolkit::GetImpl( *this ).PageLoadErrorSignal();
+ return Dali::Toolkit::GetImpl(*this).PageLoadErrorSignal();
}
-WebView::WebView( Internal::WebView& implementation )
-: Control( implementation )
+WebView::WebView(Internal::WebView& implementation)
+: Control(implementation)
{
}
-WebView::WebView( Dali::Internal::CustomActor* internal )
-: Control( internal )
+WebView::WebView(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
- VerifyCustomActorPointer< Internal::WebView >( internal );
+ VerifyCustomActorPointer<Internal::WebView>(internal);
}
} // namespace Toolkit
#define DALI_TOOLKIT_WEB_VIEW_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
- class WebView;
-} // namespace Internal
+class WebView;
+} // namespace DALI_INTERNAL
/**
* @addtogroup dali_toolkit_controls_web_view
class DALI_TOOLKIT_API WebView : public Control
{
public:
-
/**
* @brief A structure used to contain the cache model enumeration.
*/
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1,
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000,
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000,
};
/**
/**
* @brief WebView signal type related with page loading.
*/
- typedef Signal< void ( WebView, const std::string& ) > WebViewPageLoadSignalType;
+ typedef Signal<void(WebView, const std::string&)> WebViewPageLoadSignalType;
/**
* @brief WebView signal type related with page loading error.
*/
- typedef Signal< void ( WebView, const std::string&, LoadErrorCode ) > WebViewPageLoadErrorSignalType;
+ typedef Signal<void(WebView, const std::string&, LoadErrorCode)> WebViewPageLoadErrorSignalType;
public:
-
/**
* @brief Creates an initialized WebView.
* @return A handle to a newly allocated Dali WebView
* @param [in] locale The locale of Web
* @param [in] timezoneId The timezoneId of Web
*/
- static WebView New( const std::string& locale, const std::string& timezoneId );
+ static WebView New(const std::string& locale, const std::string& timezoneId);
/**
* @brief Creates an uninitialized WebView.
*
* @param[in] WebView WebView to copy. The copied WebView will point at the same implementation
*/
- WebView( const WebView& WebView );
+ WebView(const WebView& WebView);
/**
* @brief Assignment operator.
* @param[in] WebView The WebView to assign from
* @return The updated WebView
*/
- WebView& operator=( const WebView& WebView );
+ WebView& operator=(const WebView& WebView);
/**
* @brief Downcasts a handle to WebView handle.
* @param[in] handle Handle to an object
* @return Handle to a WebView or an uninitialized handle
*/
- static WebView DownCast( BaseHandle handle );
+ static WebView DownCast(BaseHandle handle);
/**
* @brief Loads a web page based on a given URL.
*
* @param [in] url The URL of the resource to load
*/
- void LoadUrl( const std::string& url );
+ void LoadUrl(const std::string& url);
/**
* @brief Loads a given string as web contents.
*
* @param [in] htmlString The string to use as the contents of the web page
*/
- void LoadHTMLString( const std::string& htmlString );
+ void LoadHTMLString(const std::string& htmlString);
/**
* @brief Reloads the Web.
* @param[in] script The JavaScript code
* @param[in] resultHandler The callback function to be called by the JavaScript runtime. This carries evaluation result.
*/
- void EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler );
+ void EvaluateJavaScript(const std::string& script, std::function<void(const std::string&)> resultHandler);
/**
* @brief Evaluates JavaScript code represented as a string.
*
* @param[in] script The JavaScript code
*/
- void EvaluateJavaScript( const std::string& script );
+ void EvaluateJavaScript(const std::string& script);
/**
* @brief Inject a JavaScript object with a message handler into the WebView.
* @param[in] exposedObjectName The name of exposed object
* @param[in] handler The callback function
*/
- void AddJavaScriptMessageHandler( const std::string& exposedObjectName, std::function< void( const std::string& ) > handler );
+ void AddJavaScriptMessageHandler(const std::string& exposedObjectName, std::function<void(const std::string&)> handler);
/**
* @brief Clears the history of Web.
WebViewPageLoadErrorSignalType& PageLoadErrorSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
*
* @param[in] implementation The WebView implementation
*/
- DALI_INTERNAL WebView( Internal::WebView& implementation );
+ DALI_INTERNAL WebView(Internal::WebView& implementation);
/**
* @brief Allows the creation of this WebView from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor
*/
- explicit DALI_INTERNAL WebView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL WebView(Dali::Internal::CustomActor* internal);
/// @endcond
-
};
/**
#define DALI_TOOLKIT_DEVEL_API_ALIGN_ENUMS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*
*/
-
namespace Dali
{
-
namespace Toolkit
{
-
namespace Direction
{
- enum Type
- {
- LEFT_TO_RIGHT = 0,
- RIGHT_TO_LEFT
- };
+enum Type
+{
+ LEFT_TO_RIGHT = 0,
+ RIGHT_TO_LEFT
+};
}
} // namespace Toolkit
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
DragAndDropDetector::DragAndDropDetector()
{
}
return GetImplementation(*this).EndedSignal();
}
-DragAndDropDetector::DragAndDropDetector( Internal::DragAndDropDetector* detector )
-: BaseHandle( detector )
+DragAndDropDetector::DragAndDropDetector(Internal::DragAndDropDetector* detector)
+: BaseHandle(detector)
{
}
#define DALI_DRAG_AND_DROP_DETECTOR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*
*/
-
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class DragAndDropDetector;
class DALI_TOOLKIT_API DragAndDropDetector : public BaseHandle
{
public:
-
// Typedefs
- using DragAndDropSignal = Signal< void ( Control, DragAndDropDetector ) >; ///< Drag & Drop signal
+ using DragAndDropSignal = Signal<void(Control, DragAndDropDetector)>; ///< Drag & Drop signal
/**
* @brief Create an initialized DragAndDropDetector.
DragAndDropSignal& EndedSignal();
public: // Not intended for application developers
-
/**
* @brief This constructor is used by DragAndDropDetector::Get().
*
* @param[in] detector A pointer to the drag and drop detector.
*/
- explicit DALI_INTERNAL DragAndDropDetector( Internal::DragAndDropDetector* detector );
+ explicit DALI_INTERNAL DragAndDropDetector(Internal::DragAndDropDetector* detector);
};
} // namespace Toolkit
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelKeyboardFocusManager
{
-
void SetCustomAlgorithm(KeyboardFocusManager keyboardFocusManager, CustomAlgorithmInterface& interface)
{
GetImpl(keyboardFocusManager).SetCustomAlgorithm(interface);
#define DALI_TOOLKIT_KEYBOARD_FOCUS_MANAGER_DEVEL_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelKeyboardFocusManager
{
/**
class CustomAlgorithmInterface
{
public:
-
/**
* @brief Virtual destructor.
*/
- virtual ~CustomAlgorithmInterface() {};
+ virtual ~CustomAlgorithmInterface(){};
/**
* @brief Called by the KeyboardFocusManager to get the next focusable actor.
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
KeyInputFocusManager::KeyInputFocusManager()
{
}
KeyInputFocusManager manager;
// Check whether the focus manager is already created
- SingletonService singletonService( SingletonService::Get() );
- if ( singletonService )
+ SingletonService singletonService(SingletonService::Get());
+ if(singletonService)
{
Dali::BaseHandle handle = singletonService.GetSingleton(typeid(KeyInputFocusManager));
if(handle)
return manager;
}
-KeyInputFocusManager::KeyInputFocusManager(Internal::KeyInputFocusManager *impl)
- : BaseHandle(impl)
+KeyInputFocusManager::KeyInputFocusManager(Internal::KeyInputFocusManager* impl)
+: BaseHandle(impl)
{
}
} // namespace Toolkit
} // namespace Dali
-
#define DALI_TOOLKIT_KEYINPUT_FOCUS_MANAGER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class KeyInputFocusManager;
class DALI_TOOLKIT_API KeyInputFocusManager : public BaseHandle
{
public:
-
// KeyInputFocusChanged
- typedef Signal< void (Control, Control) > KeyInputFocusChangedSignalType;
+ typedef Signal<void(Control, Control)> KeyInputFocusChangedSignalType;
public:
-
/**
* Create a KeyInputFocusManager handle; this can be initialised with KeyInputFocusManager::Get()
* Calling member functions with an uninitialised handle is not allowed.
void RemoveFocus(Control control);
public: // Signals
-
/**
* This signal is emitted when the key input focus control changes.
* Two control parameters are sent as part of this signal, the first being the signal that now has the focus, the second
KeyInputFocusChangedSignalType& KeyInputFocusChangedSignal();
private:
-
- explicit DALI_INTERNAL KeyInputFocusManager(Internal::KeyInputFocusManager *impl);
+ explicit DALI_INTERNAL KeyInputFocusManager(Internal::KeyInputFocusManager* impl);
}; // class KeyInputFocusManager
{
namespace DevelAsyncImageLoader
{
-
-uint32_t LoadAnimatedImage( AsyncImageLoader asyncImageLoader,
- Dali::AnimatedImageLoading animatedImageLoading,
- uint32_t frameIndex )
+uint32_t LoadAnimatedImage(AsyncImageLoader asyncImageLoader,
+ Dali::AnimatedImageLoading animatedImageLoading,
+ uint32_t frameIndex)
{
- return GetImplementation( asyncImageLoader ).LoadAnimatedImage( animatedImageLoading, frameIndex );
+ return GetImplementation(asyncImageLoader).LoadAnimatedImage(animatedImageLoading, frameIndex);
}
-uint32_t Load( AsyncImageLoader asyncImageLoader,
- const std::string& url,
- ImageDimensions dimensions,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection,
- DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad )
+uint32_t Load(AsyncImageLoader asyncImageLoader,
+ const std::string& url,
+ ImageDimensions dimensions,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection,
+ DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad)
{
- return GetImplementation( asyncImageLoader ).Load( Toolkit::Internal::VisualUrl(url), dimensions, fittingMode, samplingMode, orientationCorrection, preMultiplyOnLoad);
+ return GetImplementation(asyncImageLoader).Load(Toolkit::Internal::VisualUrl(url), dimensions, fittingMode, samplingMode, orientationCorrection, preMultiplyOnLoad);
}
-uint32_t ApplyMask( AsyncImageLoader asyncImageLoader,
- Devel::PixelBuffer pixelBuffer,
- Devel::PixelBuffer maskPixelBuffer,
- float contentScale,
- bool cropToMask,
- DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad )
+uint32_t ApplyMask(AsyncImageLoader asyncImageLoader,
+ Devel::PixelBuffer pixelBuffer,
+ Devel::PixelBuffer maskPixelBuffer,
+ float contentScale,
+ bool cropToMask,
+ DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad)
{
- return GetImplementation( asyncImageLoader ).ApplyMask( pixelBuffer, maskPixelBuffer, contentScale, cropToMask, preMultiplyOnLoad );
+ return GetImplementation(asyncImageLoader).ApplyMask(pixelBuffer, maskPixelBuffer, contentScale, cropToMask, preMultiplyOnLoad);
}
-PixelBufferLoadedSignalType& PixelBufferLoadedSignal( AsyncImageLoader asyncImageLoader )
+PixelBufferLoadedSignalType& PixelBufferLoadedSignal(AsyncImageLoader asyncImageLoader)
{
- return GetImplementation( asyncImageLoader ).PixelBufferLoadedSignal();
+ return GetImplementation(asyncImageLoader).PixelBufferLoadedSignal();
}
-} // Devel
-} // Toolkit
-} // Dali
+} // namespace DevelAsyncImageLoader
+} // namespace Toolkit
+} // namespace Dali
*/
// EXTERNAL HEADER
-#include <dali/public-api/signals/dali-signal.h>
-#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
#include <dali/devel-api/adaptor-framework/animated-image-loading.h>
+#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
+#include <dali/public-api/signals/dali-signal.h>
// INTERNAL HEADER
#include <dali-toolkit/public-api/image-loader/async-image-loader.h>
{
namespace DevelAsyncImageLoader
{
-
-typedef Signal< void ( uint32_t, Devel::PixelBuffer ) > PixelBufferLoadedSignalType;
+typedef Signal<void(uint32_t, Devel::PixelBuffer)> PixelBufferLoadedSignalType;
/**
* @brief Whether to multiply alpha into color channels on load
enum class PreMultiplyOnLoad
{
OFF = 0, ///< Don't modify the image
- ON ///< Multiply alpha into color channels on load
+ ON ///< Multiply alpha into color channels on load
};
/**
* @param[in] frameIndex The frame index of a frame to be loaded frame
* @return The loading task id
*/
-DALI_TOOLKIT_API uint32_t LoadAnimatedImage( AsyncImageLoader asyncImageLoader,
- Dali::AnimatedImageLoading animatedImageLoading,
- uint32_t frameIndex );
+DALI_TOOLKIT_API uint32_t LoadAnimatedImage(AsyncImageLoader asyncImageLoader,
+ Dali::AnimatedImageLoading animatedImageLoading,
+ uint32_t frameIndex);
/**
* @brief Starts an image loading task.
* @param[in] preMultiplyOnLoad ON if the image color should be multiplied by it's alpha. Set to OFF if there is no alpha or if the image need to be applied alpha mask.
* @return The loading task id
*/
-DALI_TOOLKIT_API uint32_t Load( AsyncImageLoader asyncImageLoader,
- const std::string& url,
- ImageDimensions dimensions,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection,
- DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad );
+DALI_TOOLKIT_API uint32_t Load(AsyncImageLoader asyncImageLoader,
+ const std::string& url,
+ ImageDimensions dimensions,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection,
+ DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad);
/**
* @brief Starts an mask applying task.
* @param[in] preMultiplyOnLoad ON if the image color should be multiplied by it's alpha. Set to OFF if there is no alpha.
* @return The masking task id
*/
-DALI_TOOLKIT_API uint32_t ApplyMask( AsyncImageLoader asyncImageLoader,
- Devel::PixelBuffer pixelBuffer,
- Devel::PixelBuffer maskPixelBuffer,
- float contentScale,
- bool cropToMask,
- DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad );
+DALI_TOOLKIT_API uint32_t ApplyMask(AsyncImageLoader asyncImageLoader,
+ Devel::PixelBuffer pixelBuffer,
+ Devel::PixelBuffer maskPixelBuffer,
+ float contentScale,
+ bool cropToMask,
+ DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad);
/**
* Connect to this signal if you want to load a PixelBuffer instead of a PixelData.
* @note Connecting to this signal prevents the emission of the ImageLoadedSignal.
*/
-DALI_TOOLKIT_API PixelBufferLoadedSignalType& PixelBufferLoadedSignal( AsyncImageLoader asyncImageLoader );
+DALI_TOOLKIT_API PixelBufferLoadedSignalType& PixelBufferLoadedSignal(AsyncImageLoader asyncImageLoader);
-}
-} // Toolkit
-} // Dali
+} // namespace DevelAsyncImageLoader
+} // namespace Toolkit
+} // namespace Dali
#endif
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
AtlasUploadObserver::AtlasUploadObserver()
-{}
+{
+}
AtlasUploadObserver::~AtlasUploadObserver()
{
// Notify the registerd ImageAtlas object about the destruction of observer.
- const std::size_t size( mAtlasList.Count() );
- for( std::size_t i = 0; i < size; ++i )
+ const std::size_t size(mAtlasList.Count());
+ for(std::size_t i = 0; i < size; ++i)
{
- if( mAtlasList[i] )
+ if(mAtlasList[i])
{
- mAtlasList[i]->ObserverDestroyed( this );
+ mAtlasList[i]->ObserverDestroyed(this);
}
}
mAtlasList.Clear();
}
-void AtlasUploadObserver::Register( Internal::ImageAtlas& imageAtlas )
+void AtlasUploadObserver::Register(Internal::ImageAtlas& imageAtlas)
{
// Add to the list so that the ImageAtlas could get notified in the destructor.
// If the same atlas is exist in the list already, we would still save the duplicated copy.
- mAtlasList.PushBack( &imageAtlas );
+ mAtlasList.PushBack(&imageAtlas);
}
-void AtlasUploadObserver::Unregister( Internal::ImageAtlas& imageAtlas )
+void AtlasUploadObserver::Unregister(Internal::ImageAtlas& imageAtlas)
{
- const std::size_t size( mAtlasList.Count() );
- for( std::size_t i = 0; i < size; i++ )
+ const std::size_t size(mAtlasList.Count());
+ for(std::size_t i = 0; i < size; i++)
{
- if( mAtlasList[i] == &imageAtlas )
+ if(mAtlasList[i] == &imageAtlas)
{
// Remove from list
- mAtlasList.Erase( mAtlasList.Begin() + i );
+ mAtlasList.Erase(mAtlasList.Begin() + i);
// If there are duplicated copies of same pointer, only the first one is removed
return;
}
}
}
-}
+} // namespace Toolkit
-}
+} // namespace Dali
#define DALI_TOOLKIT_ATLAS_UPLOAD_OBSERVER_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/signals/callback.h>
-
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal
{
class ImageAtlas;
class DALI_TOOLKIT_API AtlasUploadObserver
{
public:
-
/**
* @brief Constructor.
*/
virtual void UploadCompleted() = 0;
public: // not intended for developer, called by ImageAtlas internally to get notified when this observer dies
-
/**
* @brief Register an ImageAtlas which be notified when the observer is destructing.
* @param[in] imageAtlas The ImageAtlas object to get notification about the destruction of the observer.
*/
- void Register( Internal::ImageAtlas& imageAtlas );
+ void Register(Internal::ImageAtlas& imageAtlas);
/**
* @brief Unregister an ImageAtlas which be notified when the observer is destructing.
* @param[in] imageAtlas The ImageAtlas object to get notification about the destruction of the observer.
*/
- void Unregister( Internal::ImageAtlas& imageAtlas );
+ void Unregister(Internal::ImageAtlas& imageAtlas);
private:
-
Vector<Internal::ImageAtlas*> mAtlasList; ///< The list of the registered ImageAtlas object
-
};
} // namespace Toolkit
- /*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+/*
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
ImageAtlas::ImageAtlas()
{
}
{
}
-Texture ImageAtlas::PackToAtlas( const std::vector<PixelData>& pixelData, Dali::Vector<Vector4>& textureRects )
+Texture ImageAtlas::PackToAtlas(const std::vector<PixelData>& pixelData, Dali::Vector<Vector4>& textureRects)
{
- return Internal::ImageAtlas::PackToAtlas( pixelData, textureRects );
+ return Internal::ImageAtlas::PackToAtlas(pixelData, textureRects);
}
ImageAtlas::ImageAtlas(Internal::ImageAtlas* internal)
-: BaseHandle( internal )
+: BaseHandle(internal)
{
}
-ImageAtlas::ImageAtlas( const ImageAtlas& handle )
-: BaseHandle( handle )
+ImageAtlas::ImageAtlas(const ImageAtlas& handle)
+: BaseHandle(handle)
{
}
-ImageAtlas& ImageAtlas::operator=( const ImageAtlas& handle )
+ImageAtlas& ImageAtlas::operator=(const ImageAtlas& handle)
{
BaseHandle::operator=(handle);
return *this;
}
-ImageAtlas ImageAtlas::New(SizeType width, SizeType height,
- Pixel::Format pixelFormat)
+ImageAtlas ImageAtlas::New(SizeType width, SizeType height, Pixel::Format pixelFormat)
{
- IntrusivePtr<Internal::ImageAtlas> internal = Internal::ImageAtlas::New( width, height, pixelFormat);
- return ImageAtlas( internal.Get() );
+ IntrusivePtr<Internal::ImageAtlas> internal = Internal::ImageAtlas::New(width, height, pixelFormat);
+ return ImageAtlas(internal.Get());
}
Texture ImageAtlas::GetAtlas()
{
- return GetImplementation( *this ).GetAtlas();
+ return GetImplementation(*this).GetAtlas();
}
float ImageAtlas::GetOccupancyRate() const
{
- return GetImplementation( *this ).GetOccupancyRate();
+ return GetImplementation(*this).GetOccupancyRate();
}
-
-void ImageAtlas::SetBrokenImage( const std::string& brokenImageUrl )
+void ImageAtlas::SetBrokenImage(const std::string& brokenImageUrl)
{
- GetImplementation( *this ).SetBrokenImage( brokenImageUrl );
+ GetImplementation(*this).SetBrokenImage(brokenImageUrl);
}
-bool ImageAtlas::Upload( Vector4& textureRect,
- const std::string& url,
- ImageDimensions size,
- FittingMode::Type fittingMode,
- bool orientationCorrection )
+bool ImageAtlas::Upload(Vector4& textureRect,
+ const std::string& url,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ bool orientationCorrection)
{
- return Upload( textureRect, url, size, fittingMode, orientationCorrection, NULL );
+ return Upload(textureRect, url, size, fittingMode, orientationCorrection, NULL);
}
-bool ImageAtlas::Upload( Vector4& textureRect,
- const std::string& url,
- ImageDimensions size,
- FittingMode::Type fittingMode,
- bool orientationCorrection,
- AtlasUploadObserver* atlasUploadObserver )
+bool ImageAtlas::Upload(Vector4& textureRect,
+ const std::string& url,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ bool orientationCorrection,
+ AtlasUploadObserver* atlasUploadObserver)
{
- return GetImplementation(*this).Upload( textureRect, url, size, fittingMode, orientationCorrection, atlasUploadObserver );
+ return GetImplementation(*this).Upload(textureRect, url, size, fittingMode, orientationCorrection, atlasUploadObserver);
}
-bool ImageAtlas::Upload( Vector4& textureRect, PixelData pixelData )
+bool ImageAtlas::Upload(Vector4& textureRect, PixelData pixelData)
{
- return GetImplementation(*this).Upload( textureRect, pixelData );
+ return GetImplementation(*this).Upload(textureRect, pixelData);
}
void ImageAtlas::Remove(const Vector4& textureRect)
{
- GetImplementation(*this).Remove( textureRect );
+ GetImplementation(*this).Remove(textureRect);
}
} // namespace Toolkit
#ifndef DALI_TOOLKIT_IMAGE_ATLAS_H
#define DALI_TOOLKIT_IMAGE_ATLAS_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <string>
-#include <stdint.h>
#include <dali/public-api/common/vector-wrapper.h>
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/images/image-operations.h>
-#include <dali/public-api/images/pixel.h>
#include <dali/public-api/images/pixel-data.h>
+#include <dali/public-api/images/pixel.h>
+#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/rendering/texture.h>
+#include <stdint.h>
+#include <string>
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/image-loader/atlas-upload-observer.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class ImageAtlas;
class DALI_TOOLKIT_API ImageAtlas : public BaseHandle
{
public:
-
typedef uint32_t SizeType;
public:
-
/**
* @brief Pack a group of pixel data into atlas.
* @param[in] pixelData The group of the pixel data to be packed into the atlas.
* @param[out] textureRects The list of texture areas where each frame is located inside the atlas.
* @return The atlas texture.
*/
- static Texture PackToAtlas( const std::vector<PixelData>& pixelData, Dali::Vector<Vector4>& textureRects );
+ static Texture PackToAtlas(const std::vector<PixelData>& pixelData, Dali::Vector<Vector4>& textureRects);
/**
* @brief Create a new ImageAtlas.
* @param [in] pixelFormat The pixel format (rgba 32 bit by default).
* @return A handle to a new ImageAtlas.
*/
- static ImageAtlas New( SizeType width, SizeType height,
- Pixel::Format pixelFormat = Pixel::RGBA8888 );
+ static ImageAtlas New(SizeType width, SizeType height, Pixel::Format pixelFormat = Pixel::RGBA8888);
/**
* @brief Create an empty handle.
*
* @param [in] handle A reference to the copied handle
*/
- ImageAtlas( const ImageAtlas& handle );
+ ImageAtlas(const ImageAtlas& handle);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param [in] handle A reference to the copied handle
* @return A reference to this
*/
- ImageAtlas& operator=( const ImageAtlas& handle );
+ ImageAtlas& operator=(const ImageAtlas& handle);
/**
* @brief Get the atlas image.
*
* @param[in] brokenImageUrl The url of the broken image.
*/
- void SetBrokenImage( const std::string& brokenImageUrl );
+ void SetBrokenImage(const std::string& brokenImageUrl);
/**
* @brief Upload a resource image to the atlas.
* @param [in] orientationCorrection Reorient the image to respect any orientation metadata in its header.
* @return True if there is enough space to fit this image in,false otherwise.
*/
- bool Upload( Vector4& textureRect,
- const std::string& url,
- ImageDimensions size = ImageDimensions(),
- FittingMode::Type fittingMode = FittingMode::DEFAULT,
- bool orientationCorrection = true );
+ bool Upload(Vector4& textureRect,
+ const std::string& url,
+ ImageDimensions size = ImageDimensions(),
+ FittingMode::Type fittingMode = FittingMode::DEFAULT,
+ bool orientationCorrection = true);
/**
* @brief Upload a resource image to the atlas.
* @return True if there is enough space to fit this image in,false otherwise.
* @note The valid callback function here is required to have the signature of void( void ).
*/
- bool Upload( Vector4& textureRect,
- const std::string& url,
- ImageDimensions size,
- FittingMode::Type fittingMode,
- bool orientationCorrection,
- AtlasUploadObserver* atlasUploadObserver );
+ bool Upload(Vector4& textureRect,
+ const std::string& url,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ bool orientationCorrection,
+ AtlasUploadObserver* atlasUploadObserver);
/**
* @brief Upload a pixel buffer to atlas
* @param [out] textureRect The texture area of the resource image in the atlas.
* @param [in] pixelData The pixel data.
*/
- bool Upload( Vector4& textureRect, PixelData pixelData );
+ bool Upload(Vector4& textureRect, PixelData pixelData);
/**
* @brief Remove the image at the given rectangle.
*
* @param [in] textureRect The texture area to be removed.
*/
- void Remove( const Vector4& textureRect );
+ void Remove(const Vector4& textureRect);
public: // Not intended for developer use
-
- explicit DALI_INTERNAL ImageAtlas( Internal::ImageAtlas* impl );
+ explicit DALI_INTERNAL ImageAtlas(Internal::ImageAtlas* impl);
};
} // namespace Toolkit
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace TextureManager
{
-
-std::string AddTexture( Texture& texture )
+std::string AddTexture(Texture& texture)
{
TextureSet set = TextureSet::New();
- set.SetTexture( 0u, texture );
- return AddTexture( set );
+ set.SetTexture(0u, texture);
+ return AddTexture(set);
}
-std::string AddTexture( TextureSet& textureSet )
+std::string AddTexture(TextureSet& textureSet)
{
- auto visualFactory = Toolkit::VisualFactory::Get();
- auto& textureMgr = GetImplementation( visualFactory ).GetTextureManager();
- return textureMgr.AddExternalTexture( textureSet );
+ auto visualFactory = Toolkit::VisualFactory::Get();
+ auto& textureMgr = GetImplementation(visualFactory).GetTextureManager();
+ return textureMgr.AddExternalTexture(textureSet);
}
-TextureSet RemoveTexture( const std::string& textureUrl )
+TextureSet RemoveTexture(const std::string& textureUrl)
{
- auto visualFactory = Toolkit::VisualFactory::Get();
- auto& textureMgr = GetImplementation( visualFactory ).GetTextureManager();
- return textureMgr.RemoveExternalTexture( textureUrl );
+ auto visualFactory = Toolkit::VisualFactory::Get();
+ auto& textureMgr = GetImplementation(visualFactory).GetTextureManager();
+ return textureMgr.RemoveExternalTexture(textureUrl);
}
-} // TextureManager
+} // namespace TextureManager
-} // Toolkit
+} // namespace Toolkit
-} // Dali
+} // namespace Dali
#define DALI_TOOLKIT_DEVEL_API_TEXTURE_MANAGER_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* API to interface with the toolkit texture manager
* Allows developers to add Textures through TextureSets to toolkit so that visuals can use them to render
*/
namespace TextureManager
{
-
/**
* @brief Add a Texture to texture manager
* Toolkit keeps the Texture handle until RemoveTexture is called.
* @param[in] texture the Texture to add
* @return the Url string representing this texture
*/
-DALI_TOOLKIT_API std::string AddTexture( Texture& texture );
+DALI_TOOLKIT_API std::string AddTexture(Texture& texture);
/**
* @brief Add a TextureSet to texture manager
* @param[in] textureSet the TextureSet to add
* @return the Url string representing this texture
*/
-DALI_TOOLKIT_API std::string AddTexture( TextureSet& textureSet );
+DALI_TOOLKIT_API std::string AddTexture(TextureSet& textureSet);
/**
* @brief Removes a TextureSet from toolkit
* @param[in] textureUrl to remove
* @return the handle to the TextureSet or empty handle in case TextureSet is not found
*/
-DALI_TOOLKIT_API TextureSet RemoveTexture( const std::string& textureUrl );
+DALI_TOOLKIT_API TextureSet RemoveTexture(const std::string& textureUrl);
-} // TextureManager
+} // namespace TextureManager
-} // Toolkit
+} // namespace Toolkit
-} // Dali
+} // namespace Dali
#endif // DALI_TOOLKIT_DEVEL_API_TEXTURE_MANAGER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali-toolkit/third-party/yoga/Yoga.h>
#if defined(DEBUG_ENABLED)
-static Debug::Filter* gLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_FLEX" );
+static Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_FLEX");
#endif
namespace Dali
{
namespace Flex
{
-
namespace
{
// Common callback function that is registered when AddChild is called.
// Calls MeasureNode which in turns calls the actual callback passed in AddChild not the common callback.
YGSize MeasureChild(YGNodeRef child, float width, YGMeasureMode measureModeWidth, float height, YGMeasureMode measureModeHeight)
{
- DALI_LOG_INFO( gLogFilter, Debug::General, "MeasureChild\n" );
+ DALI_LOG_INFO(gLogFilter, Debug::General, "MeasureChild\n");
// Get the Node from the YGNodeRef
- Toolkit::Flex::Node* childNode = static_cast<Toolkit::Flex::Node*>(YGNodeGetContext(child));
+ Toolkit::Flex::Node* childNode = static_cast<Toolkit::Flex::Node*>(YGNodeGetContext(child));
- YGSize childSize{ 1, 1 }; // Initialise variable.
+ YGSize childSize{1, 1}; // Initialise variable.
- DALI_ASSERT_DEBUG( childNode );
+ DALI_ASSERT_DEBUG(childNode);
// Call measure function assigned to this Node
- Toolkit::Flex::SizeTuple nodeSize = childNode->MeasureNode( width, measureModeWidth, height, measureModeHeight );
- childSize.width = nodeSize.width;
- childSize.height = nodeSize.height;
- DALI_LOG_INFO( gLogFilter, Debug::General, "MeasureChild, childNode valid %f,%f\n", childSize.width, childSize.height );
+ Toolkit::Flex::SizeTuple nodeSize = childNode->MeasureNode(width, measureModeWidth, height, measureModeHeight);
+ childSize.width = nodeSize.width;
+ childSize.height = nodeSize.height;
+ DALI_LOG_INFO(gLogFilter, Debug::General, "MeasureChild, childNode valid %f,%f\n", childSize.width, childSize.height);
return childSize;
}
-} // unamed namespace
+} // namespace
struct Node;
using NodePtr = std::unique_ptr<Node>;
-using FlexNodeVector = std::vector< NodePtr>;
+using FlexNodeVector = std::vector<NodePtr>;
struct Node::Impl
{
- YGNodeRef mYogaNode;
- MeasureCallback mMeasureCallback;
- WeakHandle< Dali::Actor > mActor;
- FlexNodeVector mChildNodes;
+ YGNodeRef mYogaNode;
+ MeasureCallback mMeasureCallback;
+ WeakHandle<Dali::Actor> mActor;
+ FlexNodeVector mChildNodes;
};
-Node::Node() : mImpl( new Impl )
+Node::Node()
+: mImpl(new Impl)
{
mImpl->mYogaNode = YGNodeNew();
- YGNodeSetContext( mImpl->mYogaNode, this );
+ YGNodeSetContext(mImpl->mYogaNode, this);
mImpl->mMeasureCallback = NULL;
- DALI_LOG_INFO( gLogFilter, Debug::General, "Node() Context [%p] set to mYogaNode[%p]\n", this, mImpl->mYogaNode );
+ DALI_LOG_INFO(gLogFilter, Debug::General, "Node() Context [%p] set to mYogaNode[%p]\n", this, mImpl->mYogaNode);
// Set default style
- YGNodeStyleSetFlexDirection( mImpl->mYogaNode, YGFlexDirectionColumn );
- YGNodeStyleSetFlexWrap( mImpl->mYogaNode, YGWrapNoWrap );
- YGNodeStyleSetJustifyContent( mImpl->mYogaNode, YGJustifyFlexStart );
- YGNodeStyleSetAlignContent( mImpl->mYogaNode, YGAlignFlexStart );
- YGNodeStyleSetAlignItems( mImpl->mYogaNode, YGAlignFlexStart );
+ YGNodeStyleSetFlexDirection(mImpl->mYogaNode, YGFlexDirectionColumn);
+ YGNodeStyleSetFlexWrap(mImpl->mYogaNode, YGWrapNoWrap);
+ YGNodeStyleSetJustifyContent(mImpl->mYogaNode, YGJustifyFlexStart);
+ YGNodeStyleSetAlignContent(mImpl->mYogaNode, YGAlignFlexStart);
+ YGNodeStyleSetAlignItems(mImpl->mYogaNode, YGAlignFlexStart);
}
Node::~Node()
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Destructor() >> \n");
- if( mImpl->mYogaNode )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Destructor() >> \n");
+ if(mImpl->mYogaNode)
{
- YGNodeFreeRecursive( mImpl->mYogaNode );
+ YGNodeFreeRecursive(mImpl->mYogaNode);
mImpl->mYogaNode = nullptr;
}
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Destructor() <<\n");
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Destructor() <<\n");
}
-Node* Node::AddChild( Actor child, Extents margin, MeasureCallback measureFunction, int index )
+Node* Node::AddChild(Actor child, Extents margin, MeasureCallback measureFunction, int index)
{
- if( child )
+ if(child)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "AddChild[%s] to node[%p] at index:%d\n", child.GetProperty< std::string >( Dali::Actor::Property::NAME ).c_str(), mImpl->mYogaNode, index );
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "AddChild[%s] to node[%p] at index:%d\n", child.GetProperty<std::string>(Dali::Actor::Property::NAME).c_str(), mImpl->mYogaNode, index);
- NodePtr childNode( new Node() );
+ NodePtr childNode(new Node());
// Store measure function passed in so can call it when the MeasureChild function is called.
childNode->mImpl->mMeasureCallback = measureFunction;
childNode->mImpl->mActor = child;
- Vector2 minumumSize = child.GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
- Vector2 maximumSize = child.GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
+ Vector2 minumumSize = child.GetProperty<Vector2>(Actor::Property::MINIMUM_SIZE);
+ Vector2 maximumSize = child.GetProperty<Vector2>(Actor::Property::MAXIMUM_SIZE);
- YGNodeStyleSetMaxWidth( childNode->mImpl->mYogaNode, maximumSize.width );
- YGNodeStyleSetMaxHeight( childNode->mImpl->mYogaNode, maximumSize.height );
- YGNodeStyleSetMinWidth( childNode->mImpl->mYogaNode, minumumSize.width );
- YGNodeStyleSetMinHeight( childNode->mImpl->mYogaNode, minumumSize.height );
+ YGNodeStyleSetMaxWidth(childNode->mImpl->mYogaNode, maximumSize.width);
+ YGNodeStyleSetMaxHeight(childNode->mImpl->mYogaNode, maximumSize.height);
+ YGNodeStyleSetMinWidth(childNode->mImpl->mYogaNode, minumumSize.width);
+ YGNodeStyleSetMinHeight(childNode->mImpl->mYogaNode, minumumSize.height);
- YGNodeStyleSetMargin( childNode->mImpl->mYogaNode, YGEdgeLeft, margin.start );
- YGNodeStyleSetMargin( childNode->mImpl->mYogaNode, YGEdgeTop, margin.top );
- YGNodeStyleSetMargin( childNode->mImpl->mYogaNode, YGEdgeRight, margin.end );
- YGNodeStyleSetMargin( childNode->mImpl->mYogaNode, YGEdgeBottom, margin.bottom );
+ YGNodeStyleSetMargin(childNode->mImpl->mYogaNode, YGEdgeLeft, margin.start);
+ YGNodeStyleSetMargin(childNode->mImpl->mYogaNode, YGEdgeTop, margin.top);
+ YGNodeStyleSetMargin(childNode->mImpl->mYogaNode, YGEdgeRight, margin.end);
+ YGNodeStyleSetMargin(childNode->mImpl->mYogaNode, YGEdgeBottom, margin.bottom);
- YGNodeSetMeasureFunc( childNode->mImpl->mYogaNode, &MeasureChild );
+ YGNodeSetMeasureFunc(childNode->mImpl->mYogaNode, &MeasureChild);
- YGNodeInsertChild( mImpl->mYogaNode, childNode->mImpl->mYogaNode, index );
+ YGNodeInsertChild(mImpl->mYogaNode, childNode->mImpl->mYogaNode, index);
Node* result = childNode.get();
- mImpl->mChildNodes.emplace_back( std::move(childNode) );
+ mImpl->mChildNodes.emplace_back(std::move(childNode));
- return result;;
+ return result;
+ ;
}
return nullptr;
}
-void Node::RemoveChild( Actor child )
+void Node::RemoveChild(Actor child)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "RemoveChild child:[%s] from internal nodeCount[%d] childCount[%d]\n", child.GetProperty< std::string >( Dali::Actor::Property::NAME ).c_str(), YGNodeGetChildCount( mImpl->mYogaNode ), mImpl->mChildNodes.size() );
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "RemoveChild child:[%s] from internal nodeCount[%d] childCount[%d]\n", child.GetProperty<std::string>(Dali::Actor::Property::NAME).c_str(), YGNodeGetChildCount(mImpl->mYogaNode), mImpl->mChildNodes.size());
- auto iterator = std::find_if( mImpl->mChildNodes.begin(),mImpl->mChildNodes.end(),
- [&child]( NodePtr& childNode ){ return childNode->mImpl->mActor.GetHandle() == child;});
+ auto iterator = std::find_if(mImpl->mChildNodes.begin(), mImpl->mChildNodes.end(), [&child](NodePtr& childNode) { return childNode->mImpl->mActor.GetHandle() == child; });
- if( iterator != mImpl->mChildNodes.end() )
+ if(iterator != mImpl->mChildNodes.end())
{
- YGNodeRemoveChild( mImpl->mYogaNode, (*iterator)->mImpl->mYogaNode );
- mImpl->mChildNodes.erase(iterator);
+ YGNodeRemoveChild(mImpl->mYogaNode, (*iterator)->mImpl->mYogaNode);
+ mImpl->mChildNodes.erase(iterator);
}
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "RemoveChild internal nodeCount[%d] childCount[%d]\n", YGNodeGetChildCount( mImpl->mYogaNode ), mImpl->mChildNodes.size() );
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "RemoveChild internal nodeCount[%d] childCount[%d]\n", YGNodeGetChildCount(mImpl->mYogaNode), mImpl->mChildNodes.size());
}
-SizeTuple Node::MeasureNode( float width, int widthMode, float height, int heightMode)
+SizeTuple Node::MeasureNode(float width, int widthMode, float height, int heightMode)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "MeasureNode\n" );
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "MeasureNode\n");
// Execute callback registered with AddChild
- Toolkit::Flex::SizeTuple nodeSize{8,8}; // Default size set to 8,8 to aid bug detection.
- if( mImpl->mMeasureCallback && mImpl->mActor.GetHandle() )
+ Toolkit::Flex::SizeTuple nodeSize{8, 8}; // Default size set to 8,8 to aid bug detection.
+ if(mImpl->mMeasureCallback && mImpl->mActor.GetHandle())
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "MeasureNode MeasureCallback executing on %s\n", mImpl->mActor.GetHandle().GetProperty< std::string >( Dali::Actor::Property::NAME ).c_str() );
- nodeSize = mImpl->mMeasureCallback( mImpl->mActor.GetHandle(), width, widthMode, height, heightMode );
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "MeasureNode MeasureCallback executing on %s\n", mImpl->mActor.GetHandle().GetProperty<std::string>(Dali::Actor::Property::NAME).c_str());
+ nodeSize = mImpl->mMeasureCallback(mImpl->mActor.GetHandle(), width, widthMode, height, heightMode);
}
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "MeasureNode nodeSize width:%f height:%f\n", nodeSize.width, nodeSize.height );
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "MeasureNode nodeSize width:%f height:%f\n", nodeSize.width, nodeSize.height);
return nodeSize;
}
void Node::CalculateLayout(float availableWidth, float availableHeight, bool isRTL)
{
- DALI_LOG_INFO( gLogFilter, Debug::General, "CalculateLayout availableSize(%f,%f)\n", availableWidth, availableHeight );
- YGNodeCalculateLayout( mImpl->mYogaNode, availableWidth, availableHeight, isRTL ? YGDirectionRTL : YGDirectionLTR );
+ DALI_LOG_INFO(gLogFilter, Debug::General, "CalculateLayout availableSize(%f,%f)\n", availableWidth, availableHeight);
+ YGNodeCalculateLayout(mImpl->mYogaNode, availableWidth, availableHeight, isRTL ? YGDirectionRTL : YGDirectionLTR);
}
-Dali::Vector4 Node::GetNodeFrame( int index ) const
+Dali::Vector4 Node::GetNodeFrame(int index) const
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GetNodeFrame[%d]\n", index );
- YGNodeRef childNode = YGNodeGetChild( mImpl->mYogaNode, index );
- Dali::Vector4 frame = Vector4::ZERO;
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "GetNodeFrame[%d]\n", index);
+ YGNodeRef childNode = YGNodeGetChild(mImpl->mYogaNode, index);
+ Dali::Vector4 frame = Vector4::ZERO;
if(childNode)
{
- frame.x = YGNodeLayoutGetLeft( childNode );
- frame.y = YGNodeLayoutGetTop( childNode );
- frame.z = frame.x + YGNodeLayoutGetWidth( childNode );
- frame.w = frame.y + YGNodeLayoutGetHeight( childNode );
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GetNodeFrame Node index[%d] child ptr[%p] GetYogaNodeFrame left:%f top:%f right:%f bottom:%f\n",
- index, childNode, frame.x , frame.y, frame.z, frame.w);
+ frame.x = YGNodeLayoutGetLeft(childNode);
+ frame.y = YGNodeLayoutGetTop(childNode);
+ frame.z = frame.x + YGNodeLayoutGetWidth(childNode);
+ frame.w = frame.y + YGNodeLayoutGetHeight(childNode);
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "GetNodeFrame Node index[%d] child ptr[%p] GetYogaNodeFrame left:%f top:%f right:%f bottom:%f\n", index, childNode, frame.x, frame.y, frame.z, frame.w);
}
else
{
- frame.x = YGNodeLayoutGetLeft( mImpl->mYogaNode );
- frame.y = YGNodeLayoutGetTop( mImpl->mYogaNode );
- frame.z = frame.x + YGNodeLayoutGetWidth( mImpl->mYogaNode );
- frame.w = frame.y + YGNodeLayoutGetHeight( mImpl->mYogaNode );
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GetNodeFrame Root index[%d] root ptr[%p] GetYogaNodeFrame left:%f top:%f right:%f bottom:%f\n",
- index, mImpl->mYogaNode, frame.x , frame.y, frame.z, frame.w);
+ frame.x = YGNodeLayoutGetLeft(mImpl->mYogaNode);
+ frame.y = YGNodeLayoutGetTop(mImpl->mYogaNode);
+ frame.z = frame.x + YGNodeLayoutGetWidth(mImpl->mYogaNode);
+ frame.w = frame.y + YGNodeLayoutGetHeight(mImpl->mYogaNode);
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "GetNodeFrame Root index[%d] root ptr[%p] GetYogaNodeFrame left:%f top:%f right:%f bottom:%f\n", index, mImpl->mYogaNode, frame.x, frame.y, frame.z, frame.w);
}
return frame;
}
-void Node::SetFlexDirection( Dali::Toolkit::Flex::FlexDirection flexDirection )
+void Node::SetFlexDirection(Dali::Toolkit::Flex::FlexDirection flexDirection)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set flex direction[%d]\n", flexDirection );
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set flex direction[%d]\n", flexDirection);
- YGNodeStyleSetFlexDirection( mImpl->mYogaNode, static_cast<YGFlexDirection>(flexDirection) );
+ YGNodeStyleSetFlexDirection(mImpl->mYogaNode, static_cast<YGFlexDirection>(flexDirection));
}
Dali::Toolkit::Flex::FlexDirection Node::GetFlexDirection() const
{
- return static_cast<Dali::Toolkit::Flex::FlexDirection>(YGNodeStyleGetFlexDirection( mImpl->mYogaNode ));
+ return static_cast<Dali::Toolkit::Flex::FlexDirection>(YGNodeStyleGetFlexDirection(mImpl->mYogaNode));
}
-void Node::SetFlexJustification( Dali::Toolkit::Flex::Justification flexJustification )
+void Node::SetFlexJustification(Dali::Toolkit::Flex::Justification flexJustification)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set flex justification[%d]\n", flexJustification )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set flex justification[%d]\n", flexJustification)
- YGNodeStyleSetJustifyContent( mImpl->mYogaNode, static_cast<YGJustify>(flexJustification) );
+ YGNodeStyleSetJustifyContent(mImpl->mYogaNode, static_cast<YGJustify>(flexJustification));
}
Dali::Toolkit::Flex::Justification Node::GetFlexJustification() const
{
- return static_cast<Dali::Toolkit::Flex::Justification>(YGNodeStyleGetJustifyContent( mImpl->mYogaNode ));
+ return static_cast<Dali::Toolkit::Flex::Justification>(YGNodeStyleGetJustifyContent(mImpl->mYogaNode));
}
Dali::Toolkit::Flex::WrapType Node::GetFlexWrap() const
{
- return static_cast<Dali::Toolkit::Flex::WrapType>(YGNodeStyleGetFlexWrap( mImpl->mYogaNode ));
+ return static_cast<Dali::Toolkit::Flex::WrapType>(YGNodeStyleGetFlexWrap(mImpl->mYogaNode));
}
-void Node::SetFlexAlignment(Dali::Toolkit::Flex::Alignment flexAlignment )
+void Node::SetFlexAlignment(Dali::Toolkit::Flex::Alignment flexAlignment)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set flex alignment[%d]\n", flexAlignment )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set flex alignment[%d]\n", flexAlignment)
- YGNodeStyleSetAlignContent( mImpl->mYogaNode , static_cast<YGAlign>(flexAlignment) );
+ YGNodeStyleSetAlignContent(mImpl->mYogaNode, static_cast<YGAlign>(flexAlignment));
}
Dali::Toolkit::Flex::Alignment Node::GetFlexAlignment() const
{
- return static_cast<Dali::Toolkit::Flex::Alignment>(YGNodeStyleGetAlignContent( mImpl->mYogaNode ));
+ return static_cast<Dali::Toolkit::Flex::Alignment>(YGNodeStyleGetAlignContent(mImpl->mYogaNode));
}
-void Node::SetFlexItemsAlignment(Dali::Toolkit::Flex::Alignment flexAlignment )
+void Node::SetFlexItemsAlignment(Dali::Toolkit::Flex::Alignment flexAlignment)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set flex items alignment[%d] on mYogaNode[%p]\n", flexAlignment, mImpl->mYogaNode )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set flex items alignment[%d] on mYogaNode[%p]\n", flexAlignment, mImpl->mYogaNode)
- YGNodeStyleSetAlignItems( mImpl->mYogaNode, static_cast<YGAlign>(flexAlignment) );
+ YGNodeStyleSetAlignItems(mImpl->mYogaNode, static_cast<YGAlign>(flexAlignment));
}
Dali::Toolkit::Flex::Alignment Node::GetFlexItemsAlignment() const
{
- return static_cast<Dali::Toolkit::Flex::Alignment>( YGNodeStyleGetAlignItems( mImpl->mYogaNode ));
+ return static_cast<Dali::Toolkit::Flex::Alignment>(YGNodeStyleGetAlignItems(mImpl->mYogaNode));
}
-void Node::SetFlexAlignmentSelf( Dali::Toolkit::Flex::Alignment flexAlignmentSelf )
+void Node::SetFlexAlignmentSelf(Dali::Toolkit::Flex::Alignment flexAlignmentSelf)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set flex alignment self [%d] on mYogaNode[%p]\n", flexAlignmentSelf, mImpl->mYogaNode )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set flex alignment self [%d] on mYogaNode[%p]\n", flexAlignmentSelf, mImpl->mYogaNode)
- YGNodeStyleSetAlignSelf( mImpl->mYogaNode, static_cast<YGAlign>(flexAlignmentSelf) );
+ YGNodeStyleSetAlignSelf(mImpl->mYogaNode, static_cast<YGAlign>(flexAlignmentSelf));
}
Dali::Toolkit::Flex::Alignment Node::GetFlexAlignmentSelf() const
{
- return static_cast<Dali::Toolkit::Flex::Alignment>(YGNodeStyleGetAlignSelf( mImpl->mYogaNode ));
+ return static_cast<Dali::Toolkit::Flex::Alignment>(YGNodeStyleGetAlignSelf(mImpl->mYogaNode));
}
-void Node::SetFlexPositionType( Dali::Toolkit::Flex::PositionType flexPositionType )
+void Node::SetFlexPositionType(Dali::Toolkit::Flex::PositionType flexPositionType)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set flex position type [%d] on mYogaNode[%p]\n", flexPositionType, mImpl->mYogaNode )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set flex position type [%d] on mYogaNode[%p]\n", flexPositionType, mImpl->mYogaNode)
- YGNodeStyleSetPositionType( mImpl->mYogaNode, static_cast<YGPositionType>(flexPositionType) );
+ YGNodeStyleSetPositionType(mImpl->mYogaNode, static_cast<YGPositionType>(flexPositionType));
}
Dali::Toolkit::Flex::PositionType Node::GetFlexPositionType() const
{
- return static_cast<Dali::Toolkit::Flex::PositionType>(YGNodeStyleGetPositionType( mImpl->mYogaNode ));
+ return static_cast<Dali::Toolkit::Flex::PositionType>(YGNodeStyleGetPositionType(mImpl->mYogaNode));
}
-void Node::SetFlexAspectRatio( float flexAspectRatio )
+void Node::SetFlexAspectRatio(float flexAspectRatio)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set flex aspect ratio [%d] on mYogaNode[%p]\n", flexAspectRatio, mImpl->mYogaNode )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set flex aspect ratio [%d] on mYogaNode[%p]\n", flexAspectRatio, mImpl->mYogaNode)
- YGNodeStyleSetAspectRatio( mImpl->mYogaNode, static_cast<float>(flexAspectRatio) );
+ YGNodeStyleSetAspectRatio(mImpl->mYogaNode, static_cast<float>(flexAspectRatio));
}
float Node::GetFlexAspectRatio() const
{
- return static_cast<float>(YGNodeStyleGetAspectRatio( mImpl->mYogaNode ));
+ return static_cast<float>(YGNodeStyleGetAspectRatio(mImpl->mYogaNode));
}
-void Node::SetFlexBasis( float flexBasis )
+void Node::SetFlexBasis(float flexBasis)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set flex basis [%d] on mYogaNode[%p]\n", flexBasis, mImpl->mYogaNode )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set flex basis [%d] on mYogaNode[%p]\n", flexBasis, mImpl->mYogaNode)
- YGNodeStyleSetFlexBasis( mImpl->mYogaNode, static_cast<float>(flexBasis) );
+ YGNodeStyleSetFlexBasis(mImpl->mYogaNode, static_cast<float>(flexBasis));
}
float Node::GetFlexBasis() const
{
- return static_cast<float>(YGNodeStyleGetFlexBasis( mImpl->mYogaNode ).value);
+ return static_cast<float>(YGNodeStyleGetFlexBasis(mImpl->mYogaNode).value);
}
-void Node::SetFlexShrink( float flexShrink )
+void Node::SetFlexShrink(float flexShrink)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set flex shrink [%d] on mYogaNode[%p]\n", flexShrink, mImpl->mYogaNode )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set flex shrink [%d] on mYogaNode[%p]\n", flexShrink, mImpl->mYogaNode)
- YGNodeStyleSetFlexShrink( mImpl->mYogaNode, static_cast<float>(flexShrink) );
+ YGNodeStyleSetFlexShrink(mImpl->mYogaNode, static_cast<float>(flexShrink));
}
float Node::GetFlexShrink() const
{
- return static_cast<float>(YGNodeStyleGetFlexShrink( mImpl->mYogaNode ));
+ return static_cast<float>(YGNodeStyleGetFlexShrink(mImpl->mYogaNode));
}
-void Node::SetFlexGrow( float flexGrow )
+void Node::SetFlexGrow(float flexGrow)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set flex grow [%d] on mYogaNode[%p]\n", flexGrow, mImpl->mYogaNode )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set flex grow [%d] on mYogaNode[%p]\n", flexGrow, mImpl->mYogaNode)
- YGNodeStyleSetFlexGrow( mImpl->mYogaNode, static_cast<float>(flexGrow) );
+ YGNodeStyleSetFlexGrow(mImpl->mYogaNode, static_cast<float>(flexGrow));
}
float Node::GetFlexGrow() const
{
- return static_cast<float>(YGNodeStyleGetFlexGrow( mImpl->mYogaNode ));
+ return static_cast<float>(YGNodeStyleGetFlexGrow(mImpl->mYogaNode));
}
float Node::GetFlexWidth() const
{
- float flexWidth = YGNodeLayoutGetWidth( mImpl->mYogaNode );
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Get flex mYogaNode[%p] width[%f]\n", mImpl->mYogaNode, flexWidth)
+ float flexWidth = YGNodeLayoutGetWidth(mImpl->mYogaNode);
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Get flex mYogaNode[%p] width[%f]\n", mImpl->mYogaNode, flexWidth)
return flexWidth;
}
float Node::GetFlexHeight() const
{
- float flexHeight = YGNodeLayoutGetHeight( mImpl->mYogaNode );
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Get flex mYogaNode[%p] height[%f]\n", mImpl->mYogaNode, flexHeight)
+ float flexHeight = YGNodeLayoutGetHeight(mImpl->mYogaNode);
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Get flex mYogaNode[%p] height[%f]\n", mImpl->mYogaNode, flexHeight)
return flexHeight;
}
-void Node::SetMargin( Extents margin )
+void Node::SetMargin(Extents margin)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set flex margin\n")
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set flex margin\n")
- YGNodeStyleSetMargin( mImpl->mYogaNode, YGEdgeLeft, margin.start );
- YGNodeStyleSetMargin( mImpl->mYogaNode, YGEdgeTop, margin.top );
- YGNodeStyleSetMargin( mImpl->mYogaNode, YGEdgeRight, margin.end );
- YGNodeStyleSetMargin( mImpl->mYogaNode, YGEdgeBottom, margin.bottom );
+ YGNodeStyleSetMargin(mImpl->mYogaNode, YGEdgeLeft, margin.start);
+ YGNodeStyleSetMargin(mImpl->mYogaNode, YGEdgeTop, margin.top);
+ YGNodeStyleSetMargin(mImpl->mYogaNode, YGEdgeRight, margin.end);
+ YGNodeStyleSetMargin(mImpl->mYogaNode, YGEdgeBottom, margin.bottom);
}
-void Node::SetPadding( Extents padding )
+void Node::SetPadding(Extents padding)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set padding\n")
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set padding\n")
- YGNodeStyleSetPadding( mImpl->mYogaNode, YGEdgeLeft, padding.start );
- YGNodeStyleSetPadding( mImpl->mYogaNode, YGEdgeTop, padding.top );
- YGNodeStyleSetPadding( mImpl->mYogaNode, YGEdgeRight, padding.end );
- YGNodeStyleSetPadding( mImpl->mYogaNode, YGEdgeBottom, padding.bottom );
+ YGNodeStyleSetPadding(mImpl->mYogaNode, YGEdgeLeft, padding.start);
+ YGNodeStyleSetPadding(mImpl->mYogaNode, YGEdgeTop, padding.top);
+ YGNodeStyleSetPadding(mImpl->mYogaNode, YGEdgeRight, padding.end);
+ YGNodeStyleSetPadding(mImpl->mYogaNode, YGEdgeBottom, padding.bottom);
}
-void Node::SetFlexWrap( Dali::Toolkit::Flex::WrapType wrapType )
+void Node::SetFlexWrap(Dali::Toolkit::Flex::WrapType wrapType)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Set flex wrap[%d] on mYogaNode[%p]\n", wrapType, mImpl->mYogaNode )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Set flex wrap[%d] on mYogaNode[%p]\n", wrapType, mImpl->mYogaNode)
- YGNodeStyleSetFlexWrap( mImpl->mYogaNode, static_cast<YGWrap>(wrapType) );
+ YGNodeStyleSetFlexWrap(mImpl->mYogaNode, static_cast<YGWrap>(wrapType));
}
-} // Flex
+} // namespace Flex
} // namespace Toolkit
} // namespace Dali
#define DALI_TOOLKIT_LAYOUTING_FLEX_NODE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <memory>
-#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/common/dali-common.h>
+#include <memory>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/dali-toolkit-common.h>
{
namespace Toolkit
{
-
namespace Flex
{
-
class Node;
/**
*/
enum class FlexDirection
{
- COLUMN, ///< The flexible items are displayed vertically as a column
- COLUMN_REVERSE, ///< The flexible items are displayed vertically as a column, but in reverse order
- ROW, ///< The flexible items are displayed horizontally as a row
- ROW_REVERSE ///< The flexible items are displayed horizontally as a row, but in reverse order
+ COLUMN, ///< The flexible items are displayed vertically as a column
+ COLUMN_REVERSE, ///< The flexible items are displayed vertically as a column, but in reverse order
+ ROW, ///< The flexible items are displayed horizontally as a row
+ ROW_REVERSE ///< The flexible items are displayed horizontally as a row, but in reverse order
};
/**
*/
enum class Justification
{
- FLEX_START, ///< Items are positioned at the beginning of the container
- CENTER, ///< Items are positioned at the center of the container
- FLEX_END, ///< Items are positioned at the end of the container
- SPACE_BETWEEN, ///< Items are positioned with equal space between the items
- SPACE_AROUND ///< Items are positioned with equal space before, between, and after the items
+ FLEX_START, ///< Items are positioned at the beginning of the container
+ CENTER, ///< Items are positioned at the center of the container
+ FLEX_END, ///< Items are positioned at the end of the container
+ SPACE_BETWEEN, ///< Items are positioned with equal space between the items
+ SPACE_AROUND ///< Items are positioned with equal space before, between, and after the items
};
/**
*/
enum class WrapType
{
- NO_WRAP, ///< Flex items laid out in single line (shrunk to fit the flex container along the main axis)
- WRAP ///< Flex items laid out in multiple lines if needed
+ NO_WRAP, ///< Flex items laid out in single line (shrunk to fit the flex container along the main axis)
+ WRAP ///< Flex items laid out in multiple lines if needed
};
/**
*/
enum class Alignment
{
- AUTO, ///< Currently unsupported, placeholder for inheritance of parent alignment.
+ AUTO, ///< Currently unsupported, placeholder for inheritance of parent alignment.
- FLEX_START, ///< At the beginning of the container
- CENTER, ///< At the center of the container
- FLEX_END, ///< At the end of the container
- STRETCH ///< Stretch to fit the container
+ FLEX_START, ///< At the beginning of the container
+ CENTER, ///< At the center of the container
+ FLEX_END, ///< At the end of the container
+ STRETCH ///< Stretch to fit the container
};
/**
*/
enum class PositionType
{
- RELATIVE, ///< Flex items laid out relatively
- ABSOLUTE ///< Flex items laid out absolutely
+ RELATIVE, ///< Flex items laid out relatively
+ ABSOLUTE ///< Flex items laid out absolutely
};
/**
*/
struct SizeTuple
{
- SizeTuple( float x, float y ) : width( x ), height( y ){}
+ SizeTuple(float x, float y)
+ : width(x),
+ height(y)
+ {
+ }
float width;
float height;
* @note float, available height for child
* @note int, height measure specification mode
*/
-using MeasureCallback = SizeTuple (*)( Dali::Actor, float , int , float , int );
+using MeasureCallback = SizeTuple (*)(Dali::Actor, float, int, float, int);
/**
* This class provides the API for calling into the Flex layout implementation.
~Node();
Node& operator=(Node&&) = default;
- Node(Node&&) = default;
- Node(const Node&) = delete;
+ Node(Node&&) = default;
+ Node(const Node&) = delete;
Node& operator=(const Node&) = delete;
/**
* @param[in] index to insert at.
* @return child node pointer
*/
- Node* AddChild( Actor child, Extents margin, MeasureCallback measureFunction, int index );
+ Node* AddChild(Actor child, Extents margin, MeasureCallback measureFunction, int index);
/**
* @brief Remove child from the FlexLayout at the given index.
* @param[in] child child to be removed.
*/
- void RemoveChild( Actor child );
+ void RemoveChild(Actor child);
/**
* @brief Return the dimensions of the node.
* @param[in] heightMode height specification mode
* @return Size tuple representing the width and height of the node
*/
- SizeTuple MeasureNode( float width, int widthMode, float height, int heightMode );
+ SizeTuple MeasureNode(float width, int widthMode, float height, int heightMode);
/**
* @brief Perform the layout measure calculations.
* @param[in] availableHeight Amount of space available for layout, height.
* @param[in] isRTL Is the direction of the layout right to left.
*/
- void CalculateLayout( float availableWidth, float availableHeight, bool isRTL );
+ void CalculateLayout(float availableWidth, float availableHeight, bool isRTL);
/**
* @brief Get the calculated width of the given node.
* @param[in] index of the child
* @return Frame structure left x, top y, right z, bottom w
*/
- Vector4 GetNodeFrame(int index ) const;
+ Vector4 GetNodeFrame(int index) const;
/**
* @brief Set the flex direction in the layout.
* The direction of the main-axis which determines the direction that flex items are laid out.
* @param[in] flexDirection The flex direction.
*/
- void SetFlexDirection( FlexDirection flexDirection );
+ void SetFlexDirection(FlexDirection flexDirection);
/**
* @brief Get the flex direction in the layout.
* @brief Set the justification in the layout.
* @param[in] flexJustification The flex justification.
*/
- void SetFlexJustification( Justification flexJustification );
+ void SetFlexJustification(Justification flexJustification);
/**
* @brief Get the flex justification in the layout.
* @brief Set the wrap in the layout.
* @param[in] flexWrap The flex wrap.
*/
- void SetFlexWrap(WrapType flexWrap );
+ void SetFlexWrap(WrapType flexWrap);
/**
* @brief Get the flex wrap in the layout.
* @brief Set the alignment of the layout content.
* @param[in] flexAlignment The alignment of the content.
*/
- void SetFlexAlignment( Alignment flexAlignment );
+ void SetFlexAlignment(Alignment flexAlignment);
/**
* @brief Get the alignment of the layout content.
* @brief Set the alignment of the layout items.
* @param[in] flexAlignment The alignment of the items.
*/
- void SetFlexItemsAlignment( Alignment flexAlignment );
+ void SetFlexItemsAlignment(Alignment flexAlignment);
/**
* @brief Get the alignment of the layout items.
* @brief Set the alignment self of the layout items.
* @param[in] flexAlignmentSelf The alignment self of the items.
*/
- void SetFlexAlignmentSelf( Alignment flexAlignmentSelf );
+ void SetFlexAlignmentSelf(Alignment flexAlignmentSelf);
/**
* @brief Get the alignment self of the layout items.
* @brief Set the position type of the layout items.
* @param[in] flexPositionType The position type of the items.
*/
- void SetFlexPositionType( PositionType flexPositionType );
+ void SetFlexPositionType(PositionType flexPositionType);
/**
* @brief Get the position type of the layout items.
* @brief Set the aspect ratio of the layout items.
* @param[in] flexAspectRatio The aspect ratio of the items.
*/
- void SetFlexAspectRatio( float flexAspectRatio );
+ void SetFlexAspectRatio(float flexAspectRatio);
/**
* @brief Get the aspect ratio of the layout items.
* @brief Set the basis of the layout items.
* @param[in] flexBasis The basis of the items.
*/
- void SetFlexBasis( float flexBasis );
+ void SetFlexBasis(float flexBasis);
/**
* @brief Get the basis of the layout items.
* @brief Set the shrink of the layout items.
* @param[in] flexShrink The shrink of the items.
*/
- void SetFlexShrink( float flexShrink );
+ void SetFlexShrink(float flexShrink);
/**
* @brief Get the shrink of the layout items.
* @brief Set the grow of the layout items.
* @param[in] flexGrow The grow of the items.
*/
- void SetFlexGrow( float flexGrow );
+ void SetFlexGrow(float flexGrow);
/**
* @brief Get the grow of the layout items.
* @brief Set the margin.
* @param[in] margin The margin value.
*/
- void SetMargin( Extents margin );
+ void SetMargin(Extents margin);
/**
* @brief Set the padding.
* @param[in] padding The padding value.
*/
- void SetPadding( Extents padding );
+ void SetPadding(Extents padding);
private:
struct Impl;
- std::unique_ptr< Impl > mImpl;
+ std::unique_ptr<Impl> mImpl;
}; // Node
-
} // namespace Flex
} // namespace Toolkit
} // namespace Dali
#define DALI_TOOLKIT_ALPHA_DISCARD_EFFECT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @brief Creates a new Alpha discard effect
*
inline Property::Map CreateAlphaDiscardEffect()
{
const char* ALPHA_DISCARD_FRAGMENT_SHADER_SOURCE =
- "varying mediump vec2 vTexCoord; \n"
- " \n"
- "uniform sampler2D sTexture; \n"
- "uniform lowp vec4 uColor; \n"
- "void main() \n"
- "{ \n"
- " mediump vec4 color = texture2D( sTexture, vTexCoord ); \n"
- " if(color.a <= 0.0001) \n"
- " { \n"
- " discard; \n"
- " } \n"
- " gl_FragColor = color * uColor; \n"
- "} \n";
+ "varying mediump vec2 vTexCoord; \n"
+ " \n"
+ "uniform sampler2D sTexture; \n"
+ "uniform lowp vec4 uColor; \n"
+ "void main() \n"
+ "{ \n"
+ " mediump vec4 color = texture2D( sTexture, vTexCoord ); \n"
+ " if(color.a <= 0.0001) \n"
+ " { \n"
+ " discard; \n"
+ " } \n"
+ " gl_FragColor = color * uColor; \n"
+ "} \n";
Property::Map map;
Property::Map customShader;
- customShader[ Visual::Shader::Property::FRAGMENT_SHADER ] = ALPHA_DISCARD_FRAGMENT_SHADER_SOURCE;
+ customShader[Visual::Shader::Property::FRAGMENT_SHADER] = ALPHA_DISCARD_FRAGMENT_SHADER_SOURCE;
- map[ Toolkit::Visual::Property::SHADER ] = customShader;
+ map[Toolkit::Visual::Property::SHADER] = customShader;
return map;
}
#define DALI_TOOLKIT_SHADER_EFFECT_DISSOLVE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <string.h>
#include <dali/public-api/rendering/shader.h>
+#include <string.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/visual-properties.h>
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @brief Set the dissolve central line.
*
* @param[in] displacement The direction of the central line
* @param[in] initialProgress The normalised initial progress of the shader
*/
-inline void DissolveEffectSetCentralLine( Actor& actor, const Vector2& position, const Vector2& displacement, float initialProgress )
+inline void DissolveEffectSetCentralLine(Actor& actor, const Vector2& position, const Vector2& displacement, float initialProgress)
{
// the line passes through 'position' and has the direction of 'displacement'
float coefA, coefB, coefC; //line equation: Ax+By+C=0;
coefA = displacement.y;
coefB = -displacement.x;
- coefC = -displacement.y*position.x + displacement.x*position.y;
+ coefC = -displacement.y * position.x + displacement.x * position.y;
- float inversedAABB = 1.f / (coefA*coefA+coefB*coefB);
+ float inversedAABB = 1.f / (coefA * coefA + coefB * coefB);
float inversedSqrtAABB = sqrtf(inversedAABB);
float saddleA;
Vector3 saddleParam; // [0]: a*a, [1]: b*b, [2] b
Vector2 translation;
Vector2 rotation;
- float toNext = -1.f;
- if( displacement.x > 0.f || (EqualsZero(displacement.x) && displacement.y > 0.f) )
+ float toNext = -1.f;
+ if(displacement.x > 0.f || (EqualsZero(displacement.x) && displacement.y > 0.f))
{
toNext = 1.f;
}
- if( (displacement.y * displacement.x < 0.0f) )
+ if((displacement.y * displacement.x < 0.0f))
{
//distance from (0,0) to the line
- float distanceTopLeft = fabsf(coefC) * inversedSqrtAABB;
+ float distanceTopLeft = fabsf(coefC) * inversedSqrtAABB;
//distance from (1, 1 ) to the line
- float distanceBottomRight = fabsf(coefA+coefB+coefC) * inversedSqrtAABB;
- saddleA = std::max( distanceTopLeft, distanceBottomRight );
+ float distanceBottomRight = fabsf(coefA + coefB + coefC) * inversedSqrtAABB;
+ saddleA = std::max(distanceTopLeft, distanceBottomRight);
//foot of a perpendicular: (1,0) to the line
- float footX1 = ( coefB*coefB - coefA*coefC) * inversedAABB;
- float footY1 = (-coefA*coefB - coefB*coefC) * inversedAABB;
+ float footX1 = (coefB * coefB - coefA * coefC) * inversedAABB;
+ float footY1 = (-coefA * coefB - coefB * coefC) * inversedAABB;
//foot of a perpendicular: (0,1) to the line
- float footX2 = (-coefA*coefB - coefA*coefC) * inversedAABB;
- float footY2 = ( coefA*coefA - coefB*coefC) * inversedAABB;
- saddleParam[1] = (footX1-footX2)*(footX1-footX2) + (footY1-footY2)*(footY1-footY2);
- translation = Vector2(-footX2,-footY2);
+ float footX2 = (-coefA * coefB - coefA * coefC) * inversedAABB;
+ float footY2 = (coefA * coefA - coefB * coefC) * inversedAABB;
+ saddleParam[1] = (footX1 - footX2) * (footX1 - footX2) + (footY1 - footY2) * (footY1 - footY2);
+ translation = Vector2(-footX2, -footY2);
}
else
{
//distance from(1,0) to the line
- float distanceTopRight = fabsf(coefA+coefC) * inversedSqrtAABB;
+ float distanceTopRight = fabsf(coefA + coefC) * inversedSqrtAABB;
//distance from(0,1) to the line
- float distanceBottomLeft = fabsf(coefB+coefC) * inversedSqrtAABB;
- saddleA = std::max( distanceTopRight, distanceBottomLeft );
+ float distanceBottomLeft = fabsf(coefB + coefC) * inversedSqrtAABB;
+ saddleA = std::max(distanceTopRight, distanceBottomLeft);
//foot of a perpendicular: (0,0) to the line
- float footX3 = (-coefA*coefC) * inversedAABB;
- float footY3 = (-coefB*coefC) * inversedAABB;
+ float footX3 = (-coefA * coefC) * inversedAABB;
+ float footY3 = (-coefB * coefC) * inversedAABB;
//foot of a perpendicular: (1.0,1.0) to the line
- float footX4 = ( coefB*coefB - coefA*coefB - coefA*coefC) * inversedAABB;
- float footY4 = (-coefA*coefB + coefA*coefA- coefB*coefC) * inversedAABB;
- saddleParam[1] = (footX3-footX4)*(footX3-footX4) + (footY3-footY4)*(footY3-footY4);
- translation = Vector2(-footX3, -footY3);
+ float footX4 = (coefB * coefB - coefA * coefB - coefA * coefC) * inversedAABB;
+ float footY4 = (-coefA * coefB + coefA * coefA - coefB * coefC) * inversedAABB;
+ saddleParam[1] = (footX3 - footX4) * (footX3 - footX4) + (footY3 - footY4) * (footY3 - footY4);
+ translation = Vector2(-footX3, -footY3);
}
saddleParam[2] = sqrtf(saddleParam[1]);
- saddleParam[0] = saddleA*saddleA;
- rotation = Vector2(-displacement.x, displacement.y);
+ saddleParam[0] = saddleA * saddleA;
+ rotation = Vector2(-displacement.x, displacement.y);
rotation.Normalize();
- actor.RegisterProperty( "uSaddleParam", saddleParam );
- actor.RegisterProperty( "uTranslation", translation );
- actor.RegisterProperty( "uRotation", rotation );
- actor.RegisterProperty( "uToNext", toNext );
- actor.RegisterProperty( "uPercentage", initialProgress, Dali::Property::ANIMATABLE );
+ actor.RegisterProperty("uSaddleParam", saddleParam);
+ actor.RegisterProperty("uTranslation", translation);
+ actor.RegisterProperty("uRotation", rotation);
+ actor.RegisterProperty("uToNext", toNext);
+ actor.RegisterProperty("uPercentage", initialProgress, Dali::Property::ANIMATABLE);
}
/**
* @brief Create a new Dissolve effect
* @return The newly created Property::Map with the dissolve effect
*/
-inline Property::Map CreateDissolveEffect( bool useHighPrecision = true )
+inline Property::Map CreateDissolveEffect(bool useHighPrecision = true)
{
- const char* prefixHighPrecision( "precision highp float;\n");
- const char* prefixMediumPrecision( "precision mediump float;\n" );
-
- const char* vertexShader( DALI_COMPOSE_SHADER(
- attribute mediump vec2 aPosition;\n
- \n
- uniform mediump mat4 uMvpMatrix;\n
- uniform vec3 uSize;\n
- uniform vec4 uTextureRect;
- \n
- uniform float uPercentage;\n
- uniform vec3 uSaddleParam;\n
- uniform vec2 uTranslation;\n
- uniform vec2 uRotation; \n
- uniform float uToNext;\n
- \n
- varying float vPercentage;\n
- varying vec2 vTexCoord;\n
-
- void main()\n
- {\n
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
- vertexPosition.xyz *= uSize;\n
- vertexPosition = uMvpMatrix * vertexPosition;\n
- gl_Position = vertexPosition;\n
-
- vec2 texCoord = aPosition + vec2(0.5);
- vTexCoord = texCoord;\n
- //Calculate the distortion value given the dissolve central line
- vec2 value = texCoord + uTranslation; \n
- mat2 rotateMatrix = mat2( uRotation.s, uRotation.t, -uRotation.t, uRotation.s ); \n
- value = rotateMatrix * value; \n
- if(uToNext == 1.0) \n
- value.s = uSaddleParam[2] + value.s; \n
- float delay = value.t*value.t / uSaddleParam[0] - value.s*value.s/uSaddleParam[1];\n
- vPercentage = clamp( uPercentage*2.0 - 0.5*sin(delay*1.571) - 0.5, 0.0, 1.0 ); \n
- })
- );
-
- const char* fragmentShader( DALI_COMPOSE_SHADER(
- varying float vPercentage;\n
- varying mediump vec2 vTexCoord;\n
- \n
- uniform sampler2D sTexture;\n
- uniform lowp vec4 uColor;\n
- uniform vec4 uTextureRect;
- \n
- float rand(vec2 co) \n
- {\n
- return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453); \n
- }\n
- \n
- void main()\n
- {\n
-
- //Calculate the randomness
- float offsetS = rand( vTexCoord * vPercentage ) - vTexCoord.s; \n
- float offsetT = rand( vec2(vTexCoord.t*vPercentage, vTexCoord.s * vPercentage) ) - vTexCoord.t; \n
- vec2 lookupCoord = vTexCoord + vec2(offsetS, offsetT) * vPercentage; \n
- gl_FragColor = texture2D( sTexture, lookupCoord ) * uColor; \n
- gl_FragColor.a *= 1.0 - vPercentage; \n
- } )
- );
+ const char* prefixHighPrecision("precision highp float;\n");
+ const char* prefixMediumPrecision("precision mediump float;\n");
+
+ const char* vertexShader(
+ "attribute mediump vec2 aPosition;\n"
+ "\n"
+ "uniform mediump mat4 uMvpMatrix;\n"
+ "uniform vec3 uSize;\n"
+ "uniform vec4 uTextureRect;"
+ "\n"
+ "uniform float uPercentage;\n"
+ "uniform vec3 uSaddleParam;\n"
+ "uniform vec2 uTranslation;\n"
+ "uniform vec2 uRotation; \n"
+ "uniform float uToNext;\n"
+ "\n"
+ "varying float vPercentage;\n"
+ "varying vec2 vTexCoord;\n"
+ "\n"
+ "void main()\n"
+ "{\n"
+ " mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n"
+ " vertexPosition.xyz *= uSize;\n"
+ " vertexPosition = uMvpMatrix * vertexPosition;\n"
+ " gl_Position = vertexPosition;\n"
+ "\n"
+ " vec2 texCoord = aPosition + vec2(0.5);\n"
+ " vTexCoord = texCoord;\n"
+ "\n"
+ " //Calculate the distortion value given the dissolve central line\n"
+ " vec2 value = texCoord + uTranslation;\n"
+ " mat2 rotateMatrix = mat2(uRotation.s, uRotation.t, -uRotation.t, uRotation.s);\n"
+ " value = rotateMatrix * value;\n"
+ " if(uToNext == 1.0)\n"
+ " value.s = uSaddleParam[2] + value.s;\n"
+ " float delay = value.t * value.t / uSaddleParam[0] - value.s * value.s / uSaddleParam[1];\n"
+ " vPercentage = clamp(uPercentage * 2.0 - 0.5 * sin(delay * 1.571) - 0.5, 0.0, 1.0);\n"
+ "}\n");
+
+ const char* fragmentShader(
+ "varying float vPercentage;\n"
+ "varying mediump vec2 vTexCoord;\n"
+ "\n"
+ "uniform sampler2D sTexture;\n"
+ "uniform lowp vec4 uColor;\n"
+ "uniform vec4 uTextureRect;\n"
+ "float rand(vec2 co)\n"
+ "{\n"
+ " return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);\n"
+ "}\n"
+ "void main()\n"
+ "{\n"
+ " //Calculate the randomness\n"
+ " float offsetS = rand(vTexCoord * vPercentage) - vTexCoord.s;\n"
+ " float offsetT = rand(vec2(vTexCoord.t * vPercentage, vTexCoord.s * vPercentage)) - vTexCoord.t;\n"
+ " vec2 lookupCoord = vTexCoord + vec2(offsetS, offsetT) * vPercentage;\n"
+ " gl_FragColor = texture2D(sTexture, lookupCoord) * uColor;\n"
+ " gl_FragColor.a *= 1.0 - vPercentage;\n"
+ "}\n");
Property::Map map;
std::string vertexShaderString;
std::string fragmentShaderString;
- if( useHighPrecision )
+ if(useHighPrecision)
{
- vertexShaderString.reserve(strlen( prefixHighPrecision ) + strlen( vertexShader ));
- vertexShaderString.append( prefixHighPrecision );
+ vertexShaderString.reserve(strlen(prefixHighPrecision) + strlen(vertexShader));
+ vertexShaderString.append(prefixHighPrecision);
- fragmentShaderString.reserve(strlen( prefixHighPrecision ) + strlen( fragmentShader ));
- fragmentShaderString.append( prefixHighPrecision );
+ fragmentShaderString.reserve(strlen(prefixHighPrecision) + strlen(fragmentShader));
+ fragmentShaderString.append(prefixHighPrecision);
}
else
{
- vertexShaderString.reserve(strlen( prefixMediumPrecision ) + strlen( vertexShader ));
- vertexShaderString.append( prefixMediumPrecision );
+ vertexShaderString.reserve(strlen(prefixMediumPrecision) + strlen(vertexShader));
+ vertexShaderString.append(prefixMediumPrecision);
- fragmentShaderString.reserve(strlen( prefixMediumPrecision ) + strlen( fragmentShader ));
- fragmentShaderString.append( prefixMediumPrecision );
+ fragmentShaderString.reserve(strlen(prefixMediumPrecision) + strlen(fragmentShader));
+ fragmentShaderString.append(prefixMediumPrecision);
}
- vertexShaderString.append( vertexShader );
- fragmentShaderString.append( fragmentShader );
+ vertexShaderString.append(vertexShader);
+ fragmentShaderString.append(fragmentShader);
- customShader[ Visual::Shader::Property::VERTEX_SHADER ] = vertexShaderString;
- customShader[ Visual::Shader::Property::FRAGMENT_SHADER ] = fragmentShaderString;
+ customShader[Visual::Shader::Property::VERTEX_SHADER] = vertexShaderString;
+ customShader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShaderString;
- customShader[ Visual::Shader::Property::SUBDIVIDE_GRID_X ] = 20;
- customShader[ Visual::Shader::Property::SUBDIVIDE_GRID_Y ] = 20;
+ customShader[Visual::Shader::Property::SUBDIVIDE_GRID_X] = 20;
+ customShader[Visual::Shader::Property::SUBDIVIDE_GRID_Y] = 20;
- customShader[ Visual::Shader::Property::HINTS ] = Shader::Hint::OUTPUT_IS_TRANSPARENT;
+ customShader[Visual::Shader::Property::HINTS] = Shader::Hint::OUTPUT_IS_TRANSPARENT;
- map[ Toolkit::Visual::Property::SHADER ] = customShader;
+ map[Toolkit::Visual::Property::SHADER] = customShader;
return map;
}
#define DALI_TOOLKIT_SHADER_EFFECT_DISTANCEFIELD_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <string.h>
#include <dali/public-api/object/property-map.h>
+#include <string.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/visual-properties.h>
namespace Dali
{
-
namespace Toolkit
{
-
/**
* Creates a new DistanceFieldEffect
*
*/
inline Dali::Property::Map CreateDistanceFieldEffect()
{
- const char* fragmentShaderPrefix( "#extension GL_OES_standard_derivatives : enable\n" );
-
- const char* fragmentShader( DALI_COMPOSE_SHADER(
- varying mediump vec2 vTexCoord;\n
- \n
- uniform mediump float uGlowBoundary;\n
- uniform mediump vec2 uOutlineParams;\n
- uniform lowp vec4 uOutlineColor;\n
- uniform lowp vec4 uShadowColor;\n
- uniform mediump vec2 uShadowOffset;\n
- uniform lowp vec4 uGlowColor;\n
- uniform lowp float uDoOutline;\n
- uniform lowp float uDoShadow;\n
- uniform lowp float uDoGlow;\n
- \n
- uniform sampler2D sTexture;\n
- uniform lowp vec4 uColor;\n
- \n
- void main()\n
- {\n
- // sample distance field\n
- mediump float smoothing = 0.5;\n
-
- mediump float distance = texture2D(sTexture, vTexCoord).a;\n
- mediump float smoothWidth = fwidth(distance);\n
- mediump float alphaFactor = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, distance);\n
- lowp vec4 color;\n
- if (uDoShadow == 0.0)\n
- {\n
- mediump float alpha = uColor.a * alphaFactor;\n
- lowp vec4 rgb = uColor;\n
- \n
- if (uDoOutline > 0.0)\n
- {\n
- mediump float outlineWidth = uOutlineParams[1] + smoothWidth;\n
- mediump float outlineBlend = smoothstep(uOutlineParams[0] - outlineWidth, uOutlineParams[0] + outlineWidth, distance);\n
- alpha = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, distance);\n
- rgb = mix(uOutlineColor, uColor, outlineBlend);\n
- }\n
- \n
- if (uDoGlow > 0.0)\n
- {\n
- rgb = mix(uGlowColor, rgb, alphaFactor);\n
- alpha = smoothstep(uGlowBoundary, smoothing, distance);\n
- }\n
- \n
- // set fragment color\n
- color = vec4(rgb.rgb, alpha);\n
- }\n
- \n
- else // (uDoShadow > 0.0)\n
- {\n
- mediump float shadowDistance = texture2D(sTexture, vTexCoord - uShadowOffset).a;\n
- mediump float inText = alphaFactor;\n
- mediump float inShadow = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, shadowDistance);\n
- \n
- // inside object, outside shadow\n
- if (inText == 1.0)\n
- {\n
- color = uColor;\n
- }\n
- // inside object, outside shadow\n
- else if ((inText != 0.0) && (inShadow == 0.0))\n
- {\n
- color = uColor;\n
- color.a *= inText;\n
- }\n
- // outside object, completely inside shadow\n
- else if ((inText == 0.0) && (inShadow == 1.0))\n
- {\n
- color = uShadowColor;\n
- }\n
- // inside object, completely inside shadow\n
- else if ((inText != 0.0) && (inShadow == 1.0))\n
- {\n
- color = mix(uShadowColor, uColor, inText);\n
- color.a = uShadowColor.a;\n
- }\n
- // inside object, inside shadow's border\n
- else if ((inText != 0.0) && (inShadow != 0.0))\n
- {\n
- color = mix(uShadowColor, uColor, inText);\n
- color.a *= max(inText, inShadow);\n
- }\n
- // inside shadow's border\n
- else if (inShadow != 0.0)\n
- {\n
- color = uShadowColor;\n
- color.a *= inShadow;\n
- }\n
- // outside shadow and object\n
- else \n
- {\n
- color.a = 0.0;\n
- }\n
- \n
- }\n
- \n
- gl_FragColor = color;\n
- \n
- } )
- );
+ const char* fragmentShaderPrefix("#extension GL_OES_standard_derivatives : enable\n");
+
+ const char* fragmentShader(
+ "varying mediump vec2 vTexCoord;\n"
+ "\n"
+ "uniform mediump float uGlowBoundary;\n"
+ "uniform mediump vec2 uOutlineParams;\n"
+ "uniform lowp vec4 uOutlineColor;\n"
+ "uniform lowp vec4 uShadowColor;\n"
+ "uniform mediump vec2 uShadowOffset;\n"
+ "uniform lowp vec4 uGlowColor;\n"
+ "uniform lowp float uDoOutline;\n"
+ "uniform lowp float uDoShadow;\n"
+ "uniform lowp float uDoGlow;\n"
+ "\n"
+ "uniform sampler2D sTexture;\n"
+ "uniform lowp vec4 uColor;\n"
+ "\n"
+ "void main()\n"
+ "{\n"
+ " // sample distance field\n"
+ " mediump float smoothing = 0.5;\n"
+ " \n"
+ " mediump float distance = texture2D(sTexture, vTexCoord).a;\n"
+ " mediump float smoothWidth = fwidth(distance);\n"
+ " mediump float alphaFactor = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, distance);\n"
+ " lowp vec4 color;\n"
+ " if (uDoShadow == 0.0)\n"
+ " {\n"
+ " mediump float alpha = uColor.a * alphaFactor;\n"
+ " lowp vec4 rgb = uColor;\n"
+ "\n"
+ " if (uDoOutline > 0.0)\n"
+ " {\n"
+ " mediump float outlineWidth = uOutlineParams[1] + smoothWidth;\n"
+ " mediump float outlineBlend = smoothstep(uOutlineParams[0] - outlineWidth, uOutlineParams[0] + outlineWidth, distance);\n"
+ " alpha = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, distance);\n"
+ " rgb = mix(uOutlineColor, uColor, outlineBlend);\n"
+ " }\n"
+ "\n"
+ " if (uDoGlow > 0.0)\n"
+ " {\n"
+ " rgb = mix(uGlowColor, rgb, alphaFactor);\n"
+ " alpha = smoothstep(uGlowBoundary, smoothing, distance);\n"
+ " }\n"
+ "\n"
+ " // set fragment color\n"
+ " color = vec4(rgb.rgb, alpha);\n"
+ " }\n"
+ "\n"
+ " else // (uDoShadow > 0.0)\n"
+ " {\n"
+ " mediump float shadowDistance = texture2D(sTexture, vTexCoord - uShadowOffset).a;\n"
+ " mediump float inText = alphaFactor;\n"
+ " mediump float inShadow = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, shadowDistance);\n"
+ "\n"
+ " // inside object, outside shadow\n"
+ " if (inText == 1.0)\n"
+ " {\n"
+ " color = uColor;\n"
+ " }\n"
+ " // inside object, outside shadow\n"
+ " else if ((inText != 0.0) && (inShadow == 0.0))\n"
+ " {\n"
+ " color = uColor;\n"
+ " color.a *= inText;\n"
+ " }\n"
+ " // outside object, completely inside shadow\n"
+ " else if ((inText == 0.0) && (inShadow == 1.0))\n"
+ " {\n"
+ " color = uShadowColor;\n"
+ " }\n"
+ " // inside object, completely inside shadow\n"
+ " else if ((inText != 0.0) && (inShadow == 1.0))\n"
+ " {\n"
+ " color = mix(uShadowColor, uColor, inText);\n"
+ " color.a = uShadowColor.a;\n"
+ " }\n"
+ " // inside object, inside shadow's border\n"
+ " else if ((inText != 0.0) && (inShadow != 0.0))\n"
+ " {\n"
+ " color = mix(uShadowColor, uColor, inText);\n"
+ " color.a *= max(inText, inShadow);\n"
+ " }\n"
+ " // inside shadow's border\n"
+ " else if (inShadow != 0.0)\n"
+ " {\n"
+ " color = uShadowColor;\n"
+ " color.a *= inShadow;\n"
+ " }\n"
+ " // outside shadow and object\n"
+ " else \n"
+ " {\n"
+ " color.a = 0.0;\n"
+ " }\n"
+ "\n"
+ " }\n"
+ "\n"
+ " gl_FragColor = color;\n"
+ "\n"
+ "}\n");
Property::Map map;
Property::Map customShader;
std::string fragmentShaderString;
- fragmentShaderString.reserve( strlen( fragmentShaderPrefix ) + strlen( fragmentShader ) );
- fragmentShaderString.append( fragmentShaderPrefix );
- fragmentShaderString.append( fragmentShader );
+ fragmentShaderString.reserve(strlen(fragmentShaderPrefix) + strlen(fragmentShader));
+ fragmentShaderString.append(fragmentShaderPrefix);
+ fragmentShaderString.append(fragmentShader);
- customShader[ Visual::Shader::Property::FRAGMENT_SHADER ] = fragmentShaderString;
- customShader[ Visual::Shader::Property::HINTS ] = Shader::Hint::OUTPUT_IS_TRANSPARENT;
+ customShader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShaderString;
+ customShader[Visual::Shader::Property::HINTS] = Shader::Hint::OUTPUT_IS_TRANSPARENT;
- map[ Toolkit::Visual::Property::SHADER ] = customShader;
+ map[Toolkit::Visual::Property::SHADER] = customShader;
return map;
}
-
} // namespace Toolkit
} // namespace Dali
#define DALI_TOOLKIT_IMAGE_REGION_EFFECT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @brief Creates a new ImageRegionEffect
*
inline Property::Map CreateImageRegionEffect()
{
std::string vertexShader(
- "attribute mediump vec2 aPosition;\n"
- "\n"
- "uniform mediump mat4 uMvpMatrix;\n"
- "uniform vec3 uSize;\n"
- "uniform vec4 uTextureRect;"
- "\n"
- "varying vec2 vTexCoord;\n"
+ "attribute mediump vec2 aPosition;\n"
+ "\n"
+ "uniform mediump mat4 uMvpMatrix;\n"
+ "uniform vec3 uSize;\n"
+ "uniform vec4 uTextureRect;"
+ "\n"
+ "varying vec2 vTexCoord;\n"
- "uniform mediump vec2 uTopLeft;\n"
- "uniform mediump vec2 uBottomRight;\n"
- "void main()\n"
- "{\n"
- " mediump vec4 position = vec4(aPosition, 0.0, 1.0);\n"
- " position.xyz *= uSize;\n"
- " gl_Position = uMvpMatrix * position;\n"
- // The line below is doing the same as the following commented lines:
- //" vec2 imageSize = uTextureRect.zw - uTextureRect.xy;\n"
- //" vec2 topLeft = uTextureRect.xy + uTopLeft * imageSize;\n"
- //" vec2 bottomRight = uTextureRect.xy + uBottomRight * imageSize;\n"
- //" vec2 texCoord = (aTexCoord - uTextureRect.xy) / imageSize;\n"
- //" vTexCoord = topLeft + texCoord * ( bottomRight - topLeft );\n"
+ "uniform mediump vec2 uTopLeft;\n"
+ "uniform mediump vec2 uBottomRight;\n"
+ "void main()\n"
+ "{\n"
+ " mediump vec4 position = vec4(aPosition, 0.0, 1.0);\n"
+ " position.xyz *= uSize;\n"
+ " gl_Position = uMvpMatrix * position;\n"
+ // The line below is doing the same as the following commented lines:
+ //" vec2 imageSize = uTextureRect.zw - uTextureRect.xy;\n"
+ //" vec2 topLeft = uTextureRect.xy + uTopLeft * imageSize;\n"
+ //" vec2 bottomRight = uTextureRect.xy + uBottomRight * imageSize;\n"
+ //" vec2 texCoord = (aTexCoord - uTextureRect.xy) / imageSize;\n"
+ //" vTexCoord = topLeft + texCoord * ( bottomRight - topLeft );\n"
- " vec2 texCoord = aPosition + vec2(0.5);\n"
- " vTexCoord = uTextureRect.xy + uTopLeft * ( uTextureRect.zw - uTextureRect.xy ) + ( texCoord - uTextureRect.xy ) * ( uBottomRight - uTopLeft );\n"
- "}\n"
- );
+ " vec2 texCoord = aPosition + vec2(0.5);\n"
+ " vTexCoord = uTextureRect.xy + uTopLeft * ( uTextureRect.zw - uTextureRect.xy ) + ( texCoord - uTextureRect.xy ) * ( uBottomRight - uTopLeft );\n"
+ "}\n");
Property::Map map;
Property::Map customShader;
- customShader[ Visual::Shader::Property::VERTEX_SHADER ] = vertexShader;
+ customShader[Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
- map[ Toolkit::Visual::Property::SHADER ] = customShader;
+ map[Toolkit::Visual::Property::SHADER] = customShader;
return map;
}
#define DALI_TOOLKIT_SHADER_EFFECT_MOTION_BLUR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @brief Set the properties for the motion blur
*
* @param[in] actor The actor that registers the uniform properties
* @param[in] numBlurSamples Number of samples used by the shader
*/
-inline void SetMotionBlurProperties( Actor& actor, unsigned int numBlurSamples = 8 )
+inline void SetMotionBlurProperties(Actor& actor, unsigned int numBlurSamples = 8)
{
- actor.RegisterProperty( "uBlurTexCoordScale", 0.125f );
- actor.RegisterProperty( "uGeometryStretchFactor", 0.05f );
- actor.RegisterProperty( "uSpeedScalingFactor", 0.5f );
- actor.RegisterProperty( "uObjectFadeStart", Vector2( 0.25f, 0.25f ) );
- actor.RegisterProperty( "uObjectFadeEnd", Vector2( 0.5f, 0.5f ) );
- actor.RegisterProperty( "uAlphaScale", 0.75f );
- actor.RegisterProperty( "uNumSamples", static_cast<float>( numBlurSamples ) );
- actor.RegisterProperty( "uRecipNumSamples", 1.0f / static_cast<float>( numBlurSamples ) );
- actor.RegisterProperty( "uRecipNumSamplesMinusOne", 1.0f / static_cast<float>( numBlurSamples - 1.0f ) );
- Property::Index uModelProperty = actor.RegisterProperty( "uModelLastFrame", Matrix::IDENTITY );
-
- Constraint constraint = Constraint::New<Matrix>( actor, uModelProperty, EqualToConstraint() );
- constraint.AddSource( Source( actor , Actor::Property::WORLD_MATRIX ) );
+ actor.RegisterProperty("uBlurTexCoordScale", 0.125f);
+ actor.RegisterProperty("uGeometryStretchFactor", 0.05f);
+ actor.RegisterProperty("uSpeedScalingFactor", 0.5f);
+ actor.RegisterProperty("uObjectFadeStart", Vector2(0.25f, 0.25f));
+ actor.RegisterProperty("uObjectFadeEnd", Vector2(0.5f, 0.5f));
+ actor.RegisterProperty("uAlphaScale", 0.75f);
+ actor.RegisterProperty("uNumSamples", static_cast<float>(numBlurSamples));
+ actor.RegisterProperty("uRecipNumSamples", 1.0f / static_cast<float>(numBlurSamples));
+ actor.RegisterProperty("uRecipNumSamplesMinusOne", 1.0f / static_cast<float>(numBlurSamples - 1.0f));
+ Property::Index uModelProperty = actor.RegisterProperty("uModelLastFrame", Matrix::IDENTITY);
+
+ Constraint constraint = Constraint::New<Matrix>(actor, uModelProperty, EqualToConstraint());
+ constraint.AddSource(Source(actor, Actor::Property::WORLD_MATRIX));
constraint.Apply();
}
{
std::string vertexSource;
vertexSource =
- "precision mediump float;\n"
-
- "attribute vec2 aPosition;\n"
-
- "uniform mat4 uMvpMatrix;\n"
- "uniform mat4 uModelView;\n"
- "uniform mat4 uViewMatrix;\n"
- "uniform mat4 uProjection;\n"
- "uniform vec3 uSize;\n"
-
- "uniform mat4 uModelLastFrame;\n"
- "float timeDelta = 0.0167;\n"
-
- "uniform float uGeometryStretchFactor;\n"
- "uniform float uSpeedScalingFactor;\n"
-
- // outputs
- "varying vec2 vModelSpaceCenterToPos;\n"
- "varying vec2 vScreenSpaceVelocityVector;\n"
- "varying float vSpeed;\n"
- "varying vec2 vTexCoord;\n"
-
- "void main()\n"
- "{\n"
- // get view space position of vertex this frame and last frame
- " vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n"
- " vertexPosition.xyz *= uSize;\n"
-
- " vec4 viewSpaceVertex = uModelView * vertexPosition;\n"
- " vec4 viewSpaceVertexLastFrame = (uViewMatrix * uModelLastFrame) * vertexPosition;\n"
- " float reciprocalTimeDelta = 1.0 / timeDelta;\n"
-
- // work out vertex's last movement in view space
- " vec3 viewSpacePosDelta = viewSpaceVertex.xyz - viewSpaceVertexLastFrame.xyz;\n"
-
- // get clip space position of vertex this frame and last frame
- " vec4 clipSpaceVertex = uMvpMatrix * vertexPosition;\n"
- " vec4 clipSpaceVertexLastFrame = uProjection * viewSpaceVertexLastFrame;\n"
-
- // decide how much this vertex is 'trailing', i.e. at the back of the object relative to its direction of motion. We do this
- // by assuming the objects model space origin is at its center and taking the dot product of the vector from center to vertex with the motion direction
- " float t = 0.0;\n"
- " float posDeltaLength = length(viewSpacePosDelta);\n"
- " if(posDeltaLength > 0.001)\n" // avoid div by 0 if object has barely moved
- " {\n"
- " vec4 viewSpaceCenterToPos = uModelView * vec4(vertexPosition.xy, 0.0, 0.0);\n"
- " float centerToVertexDist = length(viewSpaceCenterToPos);\n"
- " if(centerToVertexDist > 0.001)\n" // avoid div by 0 if object has vertex at model space origin
- " {\n"
- " vec3 viewSpacePosDeltaNormalised = viewSpacePosDelta / posDeltaLength;\n"
- " vec3 viewSpaceCenterToPosNormalised = viewSpaceCenterToPos.xyz / centerToVertexDist;\n"
- " t = (dot(viewSpacePosDeltaNormalised, viewSpaceCenterToPosNormalised) * 0.5 ) + 0.5;\n" // scale and bias from [-1..1] to [0..1]
- " }\n"
- " }\n"
- // output vertex position lerped with its last position, based on how much it is trailing,
- // this stretches the geom back along where it has just been, giving a warping effect
- // Note: we must take account of time delta to convert position delta into a velocity, so changes are smooth (take into account frame time correctly)
- " gl_Position = mix(clipSpaceVertexLastFrame, clipSpaceVertex, t * uGeometryStretchFactor * reciprocalTimeDelta);\n"
-
- // work out vertex's last movement in normalised device coordinates [-1..1] space, i.e. perspective divide
- " vec2 ndcVertex = clipSpaceVertex.xy / clipSpaceVertex.w;\n"
- " vec2 ndcVertexLastFrame = clipSpaceVertexLastFrame.xy / clipSpaceVertexLastFrame.w;\n"
- // scale and bias so that a value of 1.0 corresponds to screen size (NDC is [-1..1] = 2)
- " vScreenSpaceVelocityVector = ((ndcVertex - ndcVertexLastFrame) * 0.5 * reciprocalTimeDelta);\n"
- " vScreenSpaceVelocityVector.y = -vScreenSpaceVelocityVector.y;\n" // TODO negated due to y being inverted in our coordinate system?
- // calculate a scaling factor proportional to velocity, which we can use to tweak how things look
- " vSpeed = length(vScreenSpaceVelocityVector) * uSpeedScalingFactor;\n"
- " vSpeed = clamp(vSpeed, 0.0, 1.0);\n"
-
- // provide fragment shader with vector from center of object to pixel (assumes the objects model space origin is at its center and verts have same z)
- " vModelSpaceCenterToPos = viewSpaceVertex.xy;\n"
-
- " vec2 texCoord = aPosition + vec2(0.5);"
- " vTexCoord = texCoord;\n"
- "}\n";
-
+ "precision mediump float;\n"
+
+ "attribute vec2 aPosition;\n"
+
+ "uniform mat4 uMvpMatrix;\n"
+ "uniform mat4 uModelView;\n"
+ "uniform mat4 uViewMatrix;\n"
+ "uniform mat4 uProjection;\n"
+ "uniform vec3 uSize;\n"
+
+ "uniform mat4 uModelLastFrame;\n"
+ "float timeDelta = 0.0167;\n"
+
+ "uniform float uGeometryStretchFactor;\n"
+ "uniform float uSpeedScalingFactor;\n"
+
+ // outputs
+ "varying vec2 vModelSpaceCenterToPos;\n"
+ "varying vec2 vScreenSpaceVelocityVector;\n"
+ "varying float vSpeed;\n"
+ "varying vec2 vTexCoord;\n"
+
+ "void main()\n"
+ "{\n"
+ // get view space position of vertex this frame and last frame
+ " vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n"
+ " vertexPosition.xyz *= uSize;\n"
+
+ " vec4 viewSpaceVertex = uModelView * vertexPosition;\n"
+ " vec4 viewSpaceVertexLastFrame = (uViewMatrix * uModelLastFrame) * vertexPosition;\n"
+ " float reciprocalTimeDelta = 1.0 / timeDelta;\n"
+
+ // work out vertex's last movement in view space
+ " vec3 viewSpacePosDelta = viewSpaceVertex.xyz - viewSpaceVertexLastFrame.xyz;\n"
+
+ // get clip space position of vertex this frame and last frame
+ " vec4 clipSpaceVertex = uMvpMatrix * vertexPosition;\n"
+ " vec4 clipSpaceVertexLastFrame = uProjection * viewSpaceVertexLastFrame;\n"
+
+ // decide how much this vertex is 'trailing', i.e. at the back of the object relative to its direction of motion. We do this
+ // by assuming the objects model space origin is at its center and taking the dot product of the vector from center to vertex with the motion direction
+ " float t = 0.0;\n"
+ " float posDeltaLength = length(viewSpacePosDelta);\n"
+ " if(posDeltaLength > 0.001)\n" // avoid div by 0 if object has barely moved
+ " {\n"
+ " vec4 viewSpaceCenterToPos = uModelView * vec4(vertexPosition.xy, 0.0, 0.0);\n"
+ " float centerToVertexDist = length(viewSpaceCenterToPos);\n"
+ " if(centerToVertexDist > 0.001)\n" // avoid div by 0 if object has vertex at model space origin
+ " {\n"
+ " vec3 viewSpacePosDeltaNormalised = viewSpacePosDelta / posDeltaLength;\n"
+ " vec3 viewSpaceCenterToPosNormalised = viewSpaceCenterToPos.xyz / centerToVertexDist;\n"
+ " t = (dot(viewSpacePosDeltaNormalised, viewSpaceCenterToPosNormalised) * 0.5 ) + 0.5;\n" // scale and bias from [-1..1] to [0..1]
+ " }\n"
+ " }\n"
+ // output vertex position lerped with its last position, based on how much it is trailing,
+ // this stretches the geom back along where it has just been, giving a warping effect
+ // Note: we must take account of time delta to convert position delta into a velocity, so changes are smooth (take into account frame time correctly)
+ " gl_Position = mix(clipSpaceVertexLastFrame, clipSpaceVertex, t * uGeometryStretchFactor * reciprocalTimeDelta);\n"
+
+ // work out vertex's last movement in normalised device coordinates [-1..1] space, i.e. perspective divide
+ " vec2 ndcVertex = clipSpaceVertex.xy / clipSpaceVertex.w;\n"
+ " vec2 ndcVertexLastFrame = clipSpaceVertexLastFrame.xy / clipSpaceVertexLastFrame.w;\n"
+ // scale and bias so that a value of 1.0 corresponds to screen size (NDC is [-1..1] = 2)
+ " vScreenSpaceVelocityVector = ((ndcVertex - ndcVertexLastFrame) * 0.5 * reciprocalTimeDelta);\n"
+ " vScreenSpaceVelocityVector.y = -vScreenSpaceVelocityVector.y;\n" // TODO negated due to y being inverted in our coordinate system?
+ // calculate a scaling factor proportional to velocity, which we can use to tweak how things look
+ " vSpeed = length(vScreenSpaceVelocityVector) * uSpeedScalingFactor;\n"
+ " vSpeed = clamp(vSpeed, 0.0, 1.0);\n"
+
+ // provide fragment shader with vector from center of object to pixel (assumes the objects model space origin is at its center and verts have same z)
+ " vModelSpaceCenterToPos = viewSpaceVertex.xy;\n"
+
+ " vec2 texCoord = aPosition + vec2(0.5);"
+ " vTexCoord = texCoord;\n"
+ "}\n";
std::string fragmentSource;
fragmentSource =
- "precision mediump float;\n"
-
- "uniform sampler2D sTexture;\n"
- "uniform vec4 uColor;\n"
-
- "uniform vec2 uObjectFadeStart;\n"
- "uniform vec2 uObjectFadeEnd;\n"
- "uniform float uAlphaScale;\n"
- "uniform float uBlurTexCoordScale;\n"
- "uniform float uNumSamples;\n"
- "uniform float uRecipNumSamples;\n"
- "uniform float uRecipNumSamplesMinusOne;\n"
- // inputs
- "varying vec2 vModelSpaceCenterToPos;\n"
- "varying vec2 vScreenSpaceVelocityVector;\n"
- "varying float vSpeed;\n"
- "varying vec2 vTexCoord;\n"
-
- "void main()\n"
- "{\n"
- // calculate an alpha value that will fade the object towards its extremities, we need this to avoid an unsightly hard edge between color values of
- // the blurred object and the unblurred background. Use smoothstep also to hide any hard edges (discontinuities) in rate of change of this alpha gradient
- " vec2 centerToPixel = abs(vModelSpaceCenterToPos);\n"
- " vec2 fadeToEdges = smoothstep(0.0, 1.0, 1.0 - ((centerToPixel - uObjectFadeStart) / (uObjectFadeEnd - uObjectFadeStart)));\n"
- " float fadeToEdgesScale = fadeToEdges.x * fadeToEdges.y * uAlphaScale;\n" // apply global scaler
- " fadeToEdgesScale = mix(1.0, fadeToEdgesScale, vSpeed);\n" // fade proportional to speed, so opaque when at rest
-
- // scale velocity vector by user requirements
- " vec2 velocity = vScreenSpaceVelocityVector * uBlurTexCoordScale;\n"
-
- // standard actor texel
- " vec4 colActor = texture2D(sTexture, vTexCoord);\n"
-
- // blurred actor - gather texture samples from the actor texture in the direction of motion
- " vec4 col = colActor * uRecipNumSamples;\n"
- " for(float i = 1.0; i < uNumSamples; i += 1.0)\n"
- " {\n"
- " float t = i * uRecipNumSamplesMinusOne;\n"
- " col += texture2D(sTexture, vTexCoord + (velocity * t)) * uRecipNumSamples;\n"
- " }\n"
- " gl_FragColor = mix(colActor, col, vSpeed);\n" // lerp blurred and non-blurred actor based on speed of motion
- " gl_FragColor.a = fadeToEdgesScale;//colActor.a * fadeToEdgesScale;\n" // fade blurred actor to its edges based on speed of motion
- " gl_FragColor *= uColor;\n"
- "}\n";
-
+ "precision mediump float;\n"
+
+ "uniform sampler2D sTexture;\n"
+ "uniform vec4 uColor;\n"
+
+ "uniform vec2 uObjectFadeStart;\n"
+ "uniform vec2 uObjectFadeEnd;\n"
+ "uniform float uAlphaScale;\n"
+ "uniform float uBlurTexCoordScale;\n"
+ "uniform float uNumSamples;\n"
+ "uniform float uRecipNumSamples;\n"
+ "uniform float uRecipNumSamplesMinusOne;\n"
+ // inputs
+ "varying vec2 vModelSpaceCenterToPos;\n"
+ "varying vec2 vScreenSpaceVelocityVector;\n"
+ "varying float vSpeed;\n"
+ "varying vec2 vTexCoord;\n"
+
+ "void main()\n"
+ "{\n"
+ // calculate an alpha value that will fade the object towards its extremities, we need this to avoid an unsightly hard edge between color values of
+ // the blurred object and the unblurred background. Use smoothstep also to hide any hard edges (discontinuities) in rate of change of this alpha gradient
+ " vec2 centerToPixel = abs(vModelSpaceCenterToPos);\n"
+ " vec2 fadeToEdges = smoothstep(0.0, 1.0, 1.0 - ((centerToPixel - uObjectFadeStart) / (uObjectFadeEnd - uObjectFadeStart)));\n"
+ " float fadeToEdgesScale = fadeToEdges.x * fadeToEdges.y * uAlphaScale;\n" // apply global scaler
+ " fadeToEdgesScale = mix(1.0, fadeToEdgesScale, vSpeed);\n" // fade proportional to speed, so opaque when at rest
+
+ // scale velocity vector by user requirements
+ " vec2 velocity = vScreenSpaceVelocityVector * uBlurTexCoordScale;\n"
+
+ // standard actor texel
+ " vec4 colActor = texture2D(sTexture, vTexCoord);\n"
+
+ // blurred actor - gather texture samples from the actor texture in the direction of motion
+ " vec4 col = colActor * uRecipNumSamples;\n"
+ " for(float i = 1.0; i < uNumSamples; i += 1.0)\n"
+ " {\n"
+ " float t = i * uRecipNumSamplesMinusOne;\n"
+ " col += texture2D(sTexture, vTexCoord + (velocity * t)) * uRecipNumSamples;\n"
+ " }\n"
+ " gl_FragColor = mix(colActor, col, vSpeed);\n" // lerp blurred and non-blurred actor based on speed of motion
+ " gl_FragColor.a = fadeToEdgesScale;//colActor.a * fadeToEdgesScale;\n" // fade blurred actor to its edges based on speed of motion
+ " gl_FragColor *= uColor;\n"
+ "}\n";
Property::Map map;
Property::Map customShader;
- customShader[ Visual::Shader::Property::VERTEX_SHADER ] = vertexSource;
- customShader[ Visual::Shader::Property::FRAGMENT_SHADER ] = fragmentSource;
+ customShader[Visual::Shader::Property::VERTEX_SHADER] = vertexSource;
+ customShader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentSource;
- customShader[ Visual::Shader::Property::SUBDIVIDE_GRID_X ] = 10;
- customShader[ Visual::Shader::Property::SUBDIVIDE_GRID_Y ] = 10;
+ customShader[Visual::Shader::Property::SUBDIVIDE_GRID_X] = 10;
+ customShader[Visual::Shader::Property::SUBDIVIDE_GRID_Y] = 10;
- customShader[ Visual::Shader::Property::HINTS ] = Shader::Hint::OUTPUT_IS_TRANSPARENT;
+ customShader[Visual::Shader::Property::HINTS] = Shader::Hint::OUTPUT_IS_TRANSPARENT;
- map[ Toolkit::Visual::Property::SHADER ] = customShader;
+ map[Toolkit::Visual::Property::SHADER] = customShader;
return map;
}
-}
+} // namespace Toolkit
-}
+} // namespace Dali
#endif // DALI_TOOLKIT_SHADER_EFFECT_MOTION_BLUR_H
#define DALI_TOOLKIT_SHADER_EFFECT_MOTION_STRETCH_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @brief Set the properties for the motion stretch
*/
-inline void SetMotionStretchProperties( Actor& actor )
+inline void SetMotionStretchProperties(Actor& actor)
{
- actor.RegisterProperty( "uGeometryStretchFactor", 0.5f );
- actor.RegisterProperty( "uSpeedScalingFactor", 0.5f );
- actor.RegisterProperty( "uObjectFadeStart", Vector2( 0.25f, 0.25f ) );
- actor.RegisterProperty( "uObjectFadeEnd", Vector2( 0.5f, 0.5f ) );
- actor.RegisterProperty( "uAlphaScale", 0.75f );
- Property::Index uModelProperty = actor.RegisterProperty( "uModelLastFrame", Matrix::IDENTITY );
-
- Constraint constraint = Constraint::New<Matrix>( actor, uModelProperty, EqualToConstraint() );
- constraint.AddSource( Source( actor , Actor::Property::WORLD_MATRIX ) );
+ actor.RegisterProperty("uGeometryStretchFactor", 0.5f);
+ actor.RegisterProperty("uSpeedScalingFactor", 0.5f);
+ actor.RegisterProperty("uObjectFadeStart", Vector2(0.25f, 0.25f));
+ actor.RegisterProperty("uObjectFadeEnd", Vector2(0.5f, 0.5f));
+ actor.RegisterProperty("uAlphaScale", 0.75f);
+ Property::Index uModelProperty = actor.RegisterProperty("uModelLastFrame", Matrix::IDENTITY);
+
+ Constraint constraint = Constraint::New<Matrix>(actor, uModelProperty, EqualToConstraint());
+ constraint.AddSource(Source(actor, Actor::Property::WORLD_MATRIX));
constraint.Apply();
}
{
std::string vertexSource;
vertexSource =
- "precision mediump float;\n"
-
- "attribute vec2 aPosition;\n"
-
- "uniform mat4 uMvpMatrix;\n"
- "uniform mat4 uModelView;\n"
- "uniform mat4 uViewMatrix;\n"
- "uniform mat4 uProjection;\n"
- "uniform vec3 uSize;\n"
-
- "uniform mat4 uModelLastFrame;\n"
- "float timeDelta = 0.0167;\n"
-
- "uniform float uGeometryStretchFactor;\n"
- "uniform float uSpeedScalingFactor;\n"
-
- // outputs
- "varying vec2 vModelSpaceCenterToPos;\n"
- "varying vec2 vScreenSpaceVelocityVector;\n"
- "varying float vSpeed;\n"
- "varying vec2 vTexCoord;\n"
-
- "void main()\n"
- "{\n"
- // get view space position of vertex this frame and last frame
- " vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n"
- " vertexPosition.xyz *= uSize;\n"
-
- " vec4 viewSpaceVertex = uModelView * vertexPosition;\n"
- " vec4 viewSpaceVertexLastFrame = uViewMatrix * uModelLastFrame * vertexPosition;\n"
-
- // work out vertex's last movement in view space
- " vec3 viewSpacePosDelta = viewSpaceVertex.xyz - viewSpaceVertexLastFrame.xyz;\n"
- " float reciprocalTimeDelta = 1.0 / timeDelta;\n"
-
- // get clip space position of vertex this frame and last frame
- " vec4 clipSpaceVertex = uMvpMatrix * vertexPosition;\n"
- " vec4 clipSpaceVertexLastFrame = uProjection * viewSpaceVertexLastFrame;\n"
-
- // decide how much this vertex is 'trailing', i.e. at the back of the object relative to its direction of motion. We do this
- // by assuming the objects model space origin is at its center and taking the dot product of the vector from center to vertex with the motion direction
- " float t = 0.0;\n"
- " float posDeltaLength = length(viewSpacePosDelta);\n"
- " if(posDeltaLength > 0.001)\n" // avoid div by 0 if object has barely moved
- " {\n"
- " vec4 viewSpaceCenterToPos = uModelView * vec4(aPosition, 0.0, 0.0);\n"
- " float centerToVertexDist = length(viewSpaceCenterToPos);\n"
- " if(centerToVertexDist > 0.001)\n" // avoid div by 0 if object has vertex at model space origin
- " {\n"
- " vec3 viewSpacePosDeltaNormalised = viewSpacePosDelta / posDeltaLength;\n"
- " vec3 viewSpaceCenterToPosNormalised = viewSpaceCenterToPos.xyz / centerToVertexDist;\n"
- " t = (dot(viewSpacePosDeltaNormalised, viewSpaceCenterToPosNormalised) * 0.5 ) + 0.5;\n" // scale and bias from [-1..1] to [0..1]
- " }\n"
- " }\n"
- // output vertex position lerped with its last position, based on how much it is trailing,
- // this stretches the geom back along where it has just been, giving a warping effect
- // We raise t to a power in order that non-trailing vertices are effected much more than trailing ones
- // Note: we must take account of time delta to convert position delta into a velocity, so changes are smooth (take into account frame time correctly)
- " gl_Position = mix(clipSpaceVertexLastFrame, clipSpaceVertex, t * t * t * uGeometryStretchFactor * reciprocalTimeDelta);\n"
-
- // work out vertex's last movement in normalised device coordinates [-1..1] space, i.e. perspective divide
- " vec2 ndcVertex = clipSpaceVertex.xy / clipSpaceVertex.w;\n"
- " vec2 ndcVertexLastFrame = clipSpaceVertexLastFrame.xy / clipSpaceVertexLastFrame.w;\n"
- // scale and bias so that a value of 1.0 corresponds to screen size (NDC is [-1..1] = 2)
- " vScreenSpaceVelocityVector = ((ndcVertex - ndcVertexLastFrame) * 0.5 * reciprocalTimeDelta);\n"
- " vScreenSpaceVelocityVector.y = -vScreenSpaceVelocityVector.y;\n" // TODO negated due to y being inverted in our coordinate system?
- // calculate a scaling factor proportional to velocity, which we can use to tweak how things look
- " vSpeed = length(vScreenSpaceVelocityVector) * uSpeedScalingFactor;\n"
- " vSpeed = clamp(vSpeed, 0.0, 1.0);\n"
-
- // provide fragment shader with vector from center of object to pixel (assumes the objects model space origin is at its center and verts have same z)
- " vModelSpaceCenterToPos = viewSpaceVertex.xy;\n"
-
- " vec2 texCoord = aPosition + vec2(0.5);"
- " vTexCoord = texCoord;\n"
- "}\n";
+ "precision mediump float;\n"
+
+ "attribute vec2 aPosition;\n"
+
+ "uniform mat4 uMvpMatrix;\n"
+ "uniform mat4 uModelView;\n"
+ "uniform mat4 uViewMatrix;\n"
+ "uniform mat4 uProjection;\n"
+ "uniform vec3 uSize;\n"
+
+ "uniform mat4 uModelLastFrame;\n"
+ "float timeDelta = 0.0167;\n"
+
+ "uniform float uGeometryStretchFactor;\n"
+ "uniform float uSpeedScalingFactor;\n"
+
+ // outputs
+ "varying vec2 vModelSpaceCenterToPos;\n"
+ "varying vec2 vScreenSpaceVelocityVector;\n"
+ "varying float vSpeed;\n"
+ "varying vec2 vTexCoord;\n"
+
+ "void main()\n"
+ "{\n"
+ // get view space position of vertex this frame and last frame
+ " vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n"
+ " vertexPosition.xyz *= uSize;\n"
+
+ " vec4 viewSpaceVertex = uModelView * vertexPosition;\n"
+ " vec4 viewSpaceVertexLastFrame = uViewMatrix * uModelLastFrame * vertexPosition;\n"
+
+ // work out vertex's last movement in view space
+ " vec3 viewSpacePosDelta = viewSpaceVertex.xyz - viewSpaceVertexLastFrame.xyz;\n"
+ " float reciprocalTimeDelta = 1.0 / timeDelta;\n"
+
+ // get clip space position of vertex this frame and last frame
+ " vec4 clipSpaceVertex = uMvpMatrix * vertexPosition;\n"
+ " vec4 clipSpaceVertexLastFrame = uProjection * viewSpaceVertexLastFrame;\n"
+
+ // decide how much this vertex is 'trailing', i.e. at the back of the object relative to its direction of motion. We do this
+ // by assuming the objects model space origin is at its center and taking the dot product of the vector from center to vertex with the motion direction
+ " float t = 0.0;\n"
+ " float posDeltaLength = length(viewSpacePosDelta);\n"
+ " if(posDeltaLength > 0.001)\n" // avoid div by 0 if object has barely moved
+ " {\n"
+ " vec4 viewSpaceCenterToPos = uModelView * vec4(aPosition, 0.0, 0.0);\n"
+ " float centerToVertexDist = length(viewSpaceCenterToPos);\n"
+ " if(centerToVertexDist > 0.001)\n" // avoid div by 0 if object has vertex at model space origin
+ " {\n"
+ " vec3 viewSpacePosDeltaNormalised = viewSpacePosDelta / posDeltaLength;\n"
+ " vec3 viewSpaceCenterToPosNormalised = viewSpaceCenterToPos.xyz / centerToVertexDist;\n"
+ " t = (dot(viewSpacePosDeltaNormalised, viewSpaceCenterToPosNormalised) * 0.5 ) + 0.5;\n" // scale and bias from [-1..1] to [0..1]
+ " }\n"
+ " }\n"
+ // output vertex position lerped with its last position, based on how much it is trailing,
+ // this stretches the geom back along where it has just been, giving a warping effect
+ // We raise t to a power in order that non-trailing vertices are effected much more than trailing ones
+ // Note: we must take account of time delta to convert position delta into a velocity, so changes are smooth (take into account frame time correctly)
+ " gl_Position = mix(clipSpaceVertexLastFrame, clipSpaceVertex, t * t * t * uGeometryStretchFactor * reciprocalTimeDelta);\n"
+
+ // work out vertex's last movement in normalised device coordinates [-1..1] space, i.e. perspective divide
+ " vec2 ndcVertex = clipSpaceVertex.xy / clipSpaceVertex.w;\n"
+ " vec2 ndcVertexLastFrame = clipSpaceVertexLastFrame.xy / clipSpaceVertexLastFrame.w;\n"
+ // scale and bias so that a value of 1.0 corresponds to screen size (NDC is [-1..1] = 2)
+ " vScreenSpaceVelocityVector = ((ndcVertex - ndcVertexLastFrame) * 0.5 * reciprocalTimeDelta);\n"
+ " vScreenSpaceVelocityVector.y = -vScreenSpaceVelocityVector.y;\n" // TODO negated due to y being inverted in our coordinate system?
+ // calculate a scaling factor proportional to velocity, which we can use to tweak how things look
+ " vSpeed = length(vScreenSpaceVelocityVector) * uSpeedScalingFactor;\n"
+ " vSpeed = clamp(vSpeed, 0.0, 1.0);\n"
+
+ // provide fragment shader with vector from center of object to pixel (assumes the objects model space origin is at its center and verts have same z)
+ " vModelSpaceCenterToPos = viewSpaceVertex.xy;\n"
+
+ " vec2 texCoord = aPosition + vec2(0.5);"
+ " vTexCoord = texCoord;\n"
+ "}\n";
std::string fragmentSource;
fragmentSource =
- "precision mediump float;\n"
-
- "uniform sampler2D sTexture;\n"
- "uniform vec4 uColor;\n"
-
- "uniform vec2 uObjectFadeStart;\n"
- "uniform vec2 uObjectFadeEnd;\n"
- "uniform float uAlphaScale;\n"
-
- // inputs
- "varying vec2 vModelSpaceCenterToPos;\n"
- "varying vec2 vScreenSpaceVelocityVector;\n"
- "varying float vSpeed;\n"
- "varying vec2 vTexCoord;\n"
-
- "void main()\n"
- "{\n"
- // calculate an alpha value that will fade the object towards its extremities, we need this to avoid an unsightly hard edge between color values of
- // the stretched object and the background. Use smoothstep also to hide any hard edges (discontinuities) in rate of change of this alpha gradient
- " vec2 centerToPixel = abs( vModelSpaceCenterToPos );\n"
- " vec2 fadeToEdges = smoothstep(0.0, 1.0, 1.0 - ((centerToPixel - uObjectFadeStart) / (uObjectFadeEnd - uObjectFadeStart)));\n"
- " float fadeToEdgesScale = fadeToEdges.x * fadeToEdges.y * uAlphaScale;\n" // apply global scaler
- " fadeToEdgesScale = mix(1.0, fadeToEdgesScale, vSpeed);\n" // fade proportional to speed, so opaque when at rest
-
- // standard actor texel
- " vec4 colActor = texture2D(sTexture, vTexCoord);\n"
- " gl_FragColor = colActor;\n"
- " gl_FragColor.a *= fadeToEdgesScale;\n" // fade actor to its edges based on speed of motion
- " gl_FragColor *= uColor;\n"
- "}";
+ "precision mediump float;\n"
+
+ "uniform sampler2D sTexture;\n"
+ "uniform vec4 uColor;\n"
+
+ "uniform vec2 uObjectFadeStart;\n"
+ "uniform vec2 uObjectFadeEnd;\n"
+ "uniform float uAlphaScale;\n"
+
+ // inputs
+ "varying vec2 vModelSpaceCenterToPos;\n"
+ "varying vec2 vScreenSpaceVelocityVector;\n"
+ "varying float vSpeed;\n"
+ "varying vec2 vTexCoord;\n"
+
+ "void main()\n"
+ "{\n"
+ // calculate an alpha value that will fade the object towards its extremities, we need this to avoid an unsightly hard edge between color values of
+ // the stretched object and the background. Use smoothstep also to hide any hard edges (discontinuities) in rate of change of this alpha gradient
+ " vec2 centerToPixel = abs( vModelSpaceCenterToPos );\n"
+ " vec2 fadeToEdges = smoothstep(0.0, 1.0, 1.0 - ((centerToPixel - uObjectFadeStart) / (uObjectFadeEnd - uObjectFadeStart)));\n"
+ " float fadeToEdgesScale = fadeToEdges.x * fadeToEdges.y * uAlphaScale;\n" // apply global scaler
+ " fadeToEdgesScale = mix(1.0, fadeToEdgesScale, vSpeed);\n" // fade proportional to speed, so opaque when at rest
+
+ // standard actor texel
+ " vec4 colActor = texture2D(sTexture, vTexCoord);\n"
+ " gl_FragColor = colActor;\n"
+ " gl_FragColor.a *= fadeToEdgesScale;\n" // fade actor to its edges based on speed of motion
+ " gl_FragColor *= uColor;\n"
+ "}";
Property::Map map;
Property::Map customShader;
- customShader[ Visual::Shader::Property::VERTEX_SHADER ] = vertexSource;
- customShader[ Visual::Shader::Property::FRAGMENT_SHADER ] = fragmentSource;
+ customShader[Visual::Shader::Property::VERTEX_SHADER] = vertexSource;
+ customShader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentSource;
- customShader[ Visual::Shader::Property::SUBDIVIDE_GRID_X ] = 10;
- customShader[ Visual::Shader::Property::SUBDIVIDE_GRID_Y ] = 10;
+ customShader[Visual::Shader::Property::SUBDIVIDE_GRID_X] = 10;
+ customShader[Visual::Shader::Property::SUBDIVIDE_GRID_Y] = 10;
- customShader[ Visual::Shader::Property::HINTS ] = Shader::Hint::OUTPUT_IS_TRANSPARENT;
+ customShader[Visual::Shader::Property::HINTS] = Shader::Hint::OUTPUT_IS_TRANSPARENT;
- map[ Toolkit::Visual::Property::SHADER ] = customShader;
+ map[Toolkit::Visual::Property::SHADER] = customShader;
return map;
}
-}
+} // namespace Toolkit
-}
+} // namespace Dali
#endif // DALI_TOOLKIT_SHADER_EFFECT_MOTION_STRETCH_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelStyleManager
{
-
-const Property::Map GetConfigurations( StyleManager styleManager )
+const Property::Map GetConfigurations(StyleManager styleManager)
{
return GetImpl(styleManager).GetConfigurations();
}
#define DALI_TOOLKIT_STYLE_MANAGER_DEVEL_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelStyleManager
{
-
-
/**
* @brief Gets all currently defined configurations.
*
* @param[in] styleManager The instance of StyleManager
* @return A property map to the currently defined configurations
**/
-DALI_TOOLKIT_API const Property::Map GetConfigurations( StyleManager styleManager );
+DALI_TOOLKIT_API const Property::Map GetConfigurations(StyleManager styleManager);
} // namespace DevelStyleManager
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelText
{
-
Glyph::Glyph()
: url{},
utf8{},
- ascender{ 0.f },
- descender{ 0.f }
-{}
+ ascender{0.f},
+ descender{0.f}
+{
+}
-Glyph::Glyph( const std::string& url, const std::string utf8Character, float ascender, float descender )
-: url{ url },
+Glyph::Glyph(const std::string& url, const std::string utf8Character, float ascender, float descender)
+: url{url},
utf8{},
- ascender{ ascender },
- descender{ descender }
+ ascender{ascender},
+ descender{descender}
{
- DALI_ASSERT_DEBUG( utf8Character.size() <= 4u );
+ DALI_ASSERT_DEBUG(utf8Character.size() <= 4u);
- std::copy( utf8Character.begin(), utf8Character.end(), utf8 );
+ std::copy(utf8Character.begin(), utf8Character.end(), utf8);
}
Glyph::~Glyph()
-{}
+{
+}
BitmapFontDescription::BitmapFontDescription()
: glyphs{},
name{},
- underlinePosition{ 0.f },
- underlineThickness{ 1.f },
- isColorFont{ false }
-{}
+ underlinePosition{0.f},
+ underlineThickness{1.f},
+ isColorFont{false}
+{
+}
BitmapFontDescription::~BitmapFontDescription()
-{}
+{
+}
-void CreateBitmapFont( const BitmapFontDescription& description, TextAbstraction::BitmapFont& bitmapFont )
+void CreateBitmapFont(const BitmapFontDescription& description, TextAbstraction::BitmapFont& bitmapFont)
{
- bitmapFont.glyphs.reserve( description.glyphs.size() );
- bitmapFont.name = description.name;
- bitmapFont.underlinePosition = description.underlinePosition;
+ bitmapFont.glyphs.reserve(description.glyphs.size());
+ bitmapFont.name = description.name;
+ bitmapFont.underlinePosition = description.underlinePosition;
bitmapFont.underlineThickness = description.underlineThickness;
- bitmapFont.isColorFont = description.isColorFont;
+ bitmapFont.isColorFont = description.isColorFont;
- for( const auto& glyph : description.glyphs )
+ for(const auto& glyph : description.glyphs)
{
uint32_t c = 0u;
- Text::Utf8ToUtf32( glyph.utf8, Text::GetUtf8Length( glyph.utf8[0u] ), &c );
+ Text::Utf8ToUtf32(glyph.utf8, Text::GetUtf8Length(glyph.utf8[0u]), &c);
- TextAbstraction::BitmapGlyph bitmapGlyph( glyph.url, c, glyph.ascender, glyph.descender );
+ TextAbstraction::BitmapGlyph bitmapGlyph(glyph.url, c, glyph.ascender, glyph.descender);
- bitmapFont.glyphs.push_back( std::move( bitmapGlyph ) );
+ bitmapFont.glyphs.push_back(std::move(bitmapGlyph));
}
}
#define DALI_TOOLKIT_FONT_BITMAP_DEVEL_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/common/vector-wrapper.h>
#include <dali-toolkit/public-api/dali-toolkit-common.h>
+#include <dali/public-api/common/vector-wrapper.h>
#include <string>
namespace Dali
{
-
namespace TextAbstraction
{
// Forward declarations
struct BitmapFont;
-}
+} // namespace TextAbstraction
namespace Toolkit
{
-
namespace DevelText
{
-
/**
* @brief Struct that stores the needed info to create a bitmap glyph.
*/
* @param[in] ascender The ascender of the glyph.
* @param[in] descender The descender of the glyph.
*/
- Glyph( const std::string& url, const std::string utf8, float ascender, float descender );
+ Glyph(const std::string& url, const std::string utf8, float ascender, float descender);
/**
* @brief Default destructor.
*/
~Glyph();
- std::string url; ///< The url of the glyph.
- uint8_t utf8[4]; ///< the glyph encoded in utf8
- float ascender; ///< The ascender. The distance from the base line to the top of the glyph.
- float descender; ///< The descender. The distance from the base line to the bottom of the glyph.
+ std::string url; ///< The url of the glyph.
+ uint8_t utf8[4]; ///< the glyph encoded in utf8
+ float ascender; ///< The ascender. The distance from the base line to the top of the glyph.
+ float descender; ///< The descender. The distance from the base line to the bottom of the glyph.
};
/**
*/
~BitmapFontDescription();
- std::vector<Glyph> glyphs; ///< Vector of glyphs.
- std::string name; ///< Name of the font.
- float underlinePosition; ///< The position of the underline from the base line.
- float underlineThickness; ///< The thickness of the underline.
- bool isColorFont:1; ///< Whether the glyphs of this font have their own colors.
+ std::vector<Glyph> glyphs; ///< Vector of glyphs.
+ std::string name; ///< Name of the font.
+ float underlinePosition; ///< The position of the underline from the base line.
+ float underlineThickness; ///< The thickness of the underline.
+ bool isColorFont : 1; ///< Whether the glyphs of this font have their own colors.
};
/**
*
* @note If the @e ascender and @e descender of the glyphs are zero, the @e descender value will be left as zero and all the bitmaps will be loaded to find out the @e ascender value.
*/
-DALI_TOOLKIT_API void CreateBitmapFont( const BitmapFontDescription& description, TextAbstraction::BitmapFont& bitmapFont );
+DALI_TOOLKIT_API void CreateBitmapFont(const BitmapFontDescription& description, TextAbstraction::BitmapFont& bitmapFont);
} // namespace DevelText
namespace Dali
{
-
namespace Toolkit
{
/**
namespace DevelText
{
-
/**
* @brief Enumeration for the type of text renderer required.
*/
#define DALI_TOOLKIT_TEXT_ENUMERATIONS_DEVEL_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelText
{
-
namespace TextDirection
{
-
enum Type
{
LEFT_TO_RIGHT,
namespace VerticalLineAlignment
{
-
enum Type
{
TOP,
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali-toolkit/devel-api/text/text-utils-devel.h>
// EXTERNAL INCLUDES
+#include <dali/devel-api/scripting/enum-helper.h>
#include <dali/devel-api/text-abstraction/font-client.h>
-#include <dali/devel-api/text-abstraction/text-renderer.h>
#include <dali/devel-api/text-abstraction/text-renderer-layout-helper.h>
+#include <dali/devel-api/text-abstraction/text-renderer.h>
#include <dali/integration-api/debug.h>
-#include <dali/devel-api/scripting/enum-helper.h>
#include <cstring>
#include <limits>
namespace Dali
{
-
using namespace TextAbstraction;
namespace Toolkit
namespace DevelText
{
-
namespace Layout
{
-
/**
* @brief The text's layout.
*/
namespace CircularAlignment
{
-
/**
* @brief The enumerations for the circular alignment.
*/
} // namespace CircularAlignment
const float TO_POINT_26_DOT_6 = 64.f;
-const float TO_FLOAT = 1.f / 255.f;
-const float TO_UCHAR = 255.f;
-const bool RTL = true;
-const float TWO_PI = 2.f * Dali::Math::PI; ///< 360 degrees in radians
-const float RAD_135 = Math::PI_2 + Math::PI_4; ///< 135 degrees in radians;
-const float RAD_225 = RAD_135 + Math::PI_2; ///< 225 degrees in radians;
-const float RAD_270 = 3.f * Math::PI_2; ///< 270 degrees in radians;
-const float RAD_315 = RAD_225 + Math::PI_2; ///< 315 degrees in radians;
-const float MAX_INT = std::numeric_limits<int>::max();
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( LAYOUT_TYPE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DevelText::Layout, SINGLELINE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DevelText::Layout, MULTILINE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DevelText::Layout, CIRCULAR )
-DALI_ENUM_TO_STRING_TABLE_END( LAYOUT_TYPE )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( CIRCULAR_ALIGNMENT_TYPE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DevelText::CircularAlignment, BEGIN )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DevelText::CircularAlignment, CENTER )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DevelText::CircularAlignment, END )
-DALI_ENUM_TO_STRING_TABLE_END( CIRCULAR_ALIGNMENT_TYPE )
+const float TO_FLOAT = 1.f / 255.f;
+const float TO_UCHAR = 255.f;
+const bool RTL = true;
+const float TWO_PI = 2.f * Dali::Math::PI; ///< 360 degrees in radians
+const float RAD_135 = Math::PI_2 + Math::PI_4; ///< 135 degrees in radians;
+const float RAD_225 = RAD_135 + Math::PI_2; ///< 225 degrees in radians;
+const float RAD_270 = 3.f * Math::PI_2; ///< 270 degrees in radians;
+const float RAD_315 = RAD_225 + Math::PI_2; ///< 315 degrees in radians;
+const float MAX_INT = std::numeric_limits<int>::max();
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN(LAYOUT_TYPE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(DevelText::Layout, SINGLELINE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(DevelText::Layout, MULTILINE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(DevelText::Layout, CIRCULAR)
+DALI_ENUM_TO_STRING_TABLE_END(LAYOUT_TYPE)
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN(CIRCULAR_ALIGNMENT_TYPE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(DevelText::CircularAlignment, BEGIN)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(DevelText::CircularAlignment, CENTER)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(DevelText::CircularAlignment, END)
+DALI_ENUM_TO_STRING_TABLE_END(CIRCULAR_ALIGNMENT_TYPE)
struct InternalDataModel
{
- InternalDataModel( FontClient& fontClient,
- MetricsPtr metrics,
- Text::ModelPtr textModel )
- : fontClient( fontClient ),
- metrics( metrics ),
- textModel( textModel ),
- numberOfCharacters{ 0u },
- isTextMirrored{ false },
- numberOfGlyphs{ 0u }
+ InternalDataModel(FontClient& fontClient,
+ MetricsPtr metrics,
+ Text::ModelPtr textModel)
+ : fontClient(fontClient),
+ metrics(metrics),
+ textModel(textModel),
+ numberOfCharacters{0u},
+ isTextMirrored{false},
+ numberOfGlyphs{0u}
{
- layoutEngine.SetMetrics( metrics );
+ layoutEngine.SetMetrics(metrics);
}
- FontClient& fontClient;
- MetricsPtr metrics;
- Text::Layout::Engine layoutEngine; ///< The layout engine.
- Text::ModelPtr textModel; ///< Pointer to the text's model.
- Vector<ColorBlendingMode> blendingMode; ///< How embedded items and bitmap font glyphs are blended with color text.
- Vector<bool> isEmoji; ///< Whether the glyph is an emoji.
+ FontClient& fontClient;
+ MetricsPtr metrics;
+ Text::Layout::Engine layoutEngine; ///< The layout engine.
+ Text::ModelPtr textModel; ///< Pointer to the text's model.
+ Vector<ColorBlendingMode> blendingMode; ///< How embedded items and bitmap font glyphs are blended with color text.
+ Vector<bool> isEmoji; ///< Whether the glyph is an emoji.
- Vector<Character> mirroredUtf32Characters; // The utf32Characters Characters but mirrored if there are RTL text.
+ Vector<Character> mirroredUtf32Characters; // The utf32Characters Characters but mirrored if there are RTL text.
- Length numberOfCharacters; // The number of characters (not glyphs!).
- bool isTextMirrored ; // Whether the text has been mirrored.
+ Length numberOfCharacters; // The number of characters (not glyphs!).
+ bool isTextMirrored; // Whether the text has been mirrored.
Length numberOfGlyphs;
- Size textLayoutArea;
+ Size textLayoutArea;
};
bool GetLayoutEnumeration(const Property::Value& propertyValue, DevelText::Layout::Type& layout)
return Scripting::GetEnumerationProperty(propertyValue, CIRCULAR_ALIGNMENT_TYPE_TABLE, CIRCULAR_ALIGNMENT_TYPE_TABLE_COUNT, circularAlignment);
}
-void ShapeTextPreprocess( const RendererParameters& textParameters, TextAbstraction::TextRenderer::Parameters& rendererParameters, InternalDataModel& internalDataModel )
+void ShapeTextPreprocess(const RendererParameters& textParameters, TextAbstraction::TextRenderer::Parameters& rendererParameters, InternalDataModel& internalDataModel)
{
-
MultilanguageSupport multilanguageSupport = MultilanguageSupport::Get();
- const uint8_t* utf8 = NULL; // pointer to the first character of the text (encoded in utf8)
- Length textSize = 0u; // The length of the utf8 string.
+ const uint8_t* utf8 = NULL; // pointer to the first character of the text (encoded in utf8)
+ Length textSize = 0u; // The length of the utf8 string.
- Length& numberOfCharacters = internalDataModel.numberOfCharacters;
+ Length& numberOfCharacters = internalDataModel.numberOfCharacters;
Vector<Character>& mirroredUtf32Characters = internalDataModel.mirroredUtf32Characters;
- Text::ModelPtr& textModel = internalDataModel.textModel;
+ Text::ModelPtr& textModel = internalDataModel.textModel;
- Vector<Character>& utf32Characters = textModel->mLogicalModel->mText; // Characters encoded in utf32.
- Vector<LineBreakInfo>& lineBreakInfo = textModel->mLogicalModel->mLineBreakInfo; // The line break info.
- Vector<ScriptRun>& scripts = textModel->mLogicalModel->mScriptRuns; // Charactes's script.
- Vector<FontDescriptionRun>& fontDescriptionRuns = textModel->mLogicalModel->mFontDescriptionRuns; // Desired font descriptions.
- Vector<FontRun>& validFonts = textModel->mLogicalModel->mFontRuns; // Validated fonts.
- Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = textModel->mLogicalModel->mBidirectionalParagraphInfo; // The bidirectional info per paragraph.
- Vector<CharacterDirection>& directions = textModel->mLogicalModel->mCharacterDirections; // Character's directions.
- Vector<ColorRun>& colorRuns = textModel->mLogicalModel->mColorRuns; // colors of the text.
+ Vector<Character>& utf32Characters = textModel->mLogicalModel->mText; // Characters encoded in utf32.
+ Vector<LineBreakInfo>& lineBreakInfo = textModel->mLogicalModel->mLineBreakInfo; // The line break info.
+ Vector<ScriptRun>& scripts = textModel->mLogicalModel->mScriptRuns; // Charactes's script.
+ Vector<FontDescriptionRun>& fontDescriptionRuns = textModel->mLogicalModel->mFontDescriptionRuns; // Desired font descriptions.
+ Vector<FontRun>& validFonts = textModel->mLogicalModel->mFontRuns; // Validated fonts.
+ Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = textModel->mLogicalModel->mBidirectionalParagraphInfo; // The bidirectional info per paragraph.
+ Vector<CharacterDirection>& directions = textModel->mLogicalModel->mCharacterDirections; // Character's directions.
+ Vector<ColorRun>& colorRuns = textModel->mLogicalModel->mColorRuns; // colors of the text.
// the default font's description.
FontDescription defaultFontDescription;
// Process the markup string if the mark-up processor is enabled.
////////////////////////////////////////////////////////////////////////////////
- MarkupProcessData markupProcessData( colorRuns,
+ MarkupProcessData markupProcessData(colorRuns,
fontDescriptionRuns,
- textModel->mLogicalModel->mEmbeddedItems );
+ textModel->mLogicalModel->mEmbeddedItems);
- if (textParameters.markupEnabled)
+ if(textParameters.markupEnabled)
{
ProcessMarkupString(textParameters.text, markupProcessData);
textSize = markupProcessData.markupProcessedText.size();
// Transform a text array encoded in utf8 into an array encoded in utf32.
// It returns the actual number of characters.
- numberOfCharacters = Utf8ToUtf32( utf8, textSize, utf32Characters.Begin() );
- utf32Characters.Resize( numberOfCharacters );
+ numberOfCharacters = Utf8ToUtf32(utf8, textSize, utf32Characters.Begin());
+ utf32Characters.Resize(numberOfCharacters);
////////////////////////////////////////////////////////////////////////////////
// Retrieve the Line and Word Break Info.
////////////////////////////////////////////////////////////////////////////////
- lineBreakInfo.Resize( numberOfCharacters, LINE_NO_BREAK );
+ lineBreakInfo.Resize(numberOfCharacters, LINE_NO_BREAK);
- SetLineBreakInfo( utf32Characters,
- 0u,
- numberOfCharacters,
- lineBreakInfo );
+ SetLineBreakInfo(utf32Characters,
+ 0u,
+ numberOfCharacters,
+ lineBreakInfo);
////////////////////////////////////////////////////////////////////////////////
// Retrieve the script runs.
////////////////////////////////////////////////////////////////////////////////
- multilanguageSupport.SetScripts( utf32Characters,
+ multilanguageSupport.SetScripts(utf32Characters,
0u,
numberOfCharacters,
- scripts );
+ scripts);
// Check if there are emojis.
// If there are an RGBA8888 pixel format is needed.
- for( const auto& run : scripts )
+ for(const auto& run : scripts)
{
- if( run.script == TextAbstraction::Script::EMOJI )
+ if(run.script == TextAbstraction::Script::EMOJI)
{
rendererParameters.pixelFormat = TextAbstraction::TextRenderer::Parameters::RGBA8888;
break;
// Set the description font run with the given text parameters.
FontDescriptionRun fontDescriptionRun;
- fontDescriptionRun.characterRun.characterIndex = 0u;
+ fontDescriptionRun.characterRun.characterIndex = 0u;
fontDescriptionRun.characterRun.numberOfCharacters = numberOfCharacters;
- fontDescriptionRun.familyLength = 0u;
- fontDescriptionRun.familyName = nullptr;
+ fontDescriptionRun.familyLength = 0u;
+ fontDescriptionRun.familyName = nullptr;
fontDescriptionRun.familyDefined = !textParameters.fontFamily.empty();
- if( fontDescriptionRun.familyDefined )
+ if(fontDescriptionRun.familyDefined)
{
// The allocated memory will be freed when the logical model is destroyed.
fontDescriptionRun.familyLength = textParameters.fontFamily.size();
- fontDescriptionRun.familyName = new char[fontDescriptionRun.familyLength];
- memcpy( fontDescriptionRun.familyName, textParameters.fontFamily.c_str(), fontDescriptionRun.familyLength );
+ fontDescriptionRun.familyName = new char[fontDescriptionRun.familyLength];
+ memcpy(fontDescriptionRun.familyName, textParameters.fontFamily.c_str(), fontDescriptionRun.familyLength);
}
fontDescriptionRun.weightDefined = !textParameters.fontWeight.empty();
- if( fontDescriptionRun.weightDefined )
+ if(fontDescriptionRun.weightDefined)
{
- fontDescriptionRun.weight = StringToWeight( textParameters.fontWeight.c_str() );
+ fontDescriptionRun.weight = StringToWeight(textParameters.fontWeight.c_str());
}
fontDescriptionRun.widthDefined = !textParameters.fontWidth.empty();
- if( fontDescriptionRun.widthDefined )
+ if(fontDescriptionRun.widthDefined)
{
- fontDescriptionRun.width = StringToWidth( textParameters.fontWidth.c_str() );
+ fontDescriptionRun.width = StringToWidth(textParameters.fontWidth.c_str());
}
fontDescriptionRun.slantDefined = !textParameters.fontSlant.empty();
- if( fontDescriptionRun.slantDefined )
+ if(fontDescriptionRun.slantDefined)
{
- fontDescriptionRun.slant = StringToSlant( textParameters.fontSlant.c_str() );
+ fontDescriptionRun.slant = StringToSlant(textParameters.fontSlant.c_str());
}
- fontDescriptionRun.sizeDefined = !EqualsZero( textParameters.fontSize );
- if( fontDescriptionRun.sizeDefined )
+ fontDescriptionRun.sizeDefined = !EqualsZero(textParameters.fontSize);
+ if(fontDescriptionRun.sizeDefined)
{
- fontDescriptionRun.size = static_cast<unsigned int>( textParameters.fontSize * TO_POINT_26_DOT_6 );
+ fontDescriptionRun.size = static_cast<unsigned int>(textParameters.fontSize * TO_POINT_26_DOT_6);
}
- fontDescriptionRuns.PushBack( fontDescriptionRun );
+ fontDescriptionRuns.PushBack(fontDescriptionRun);
// Validates the fonts. If there is a character with no assigned font it sets a default one.
// After this call, fonts are validated.
- multilanguageSupport.ValidateFonts( utf32Characters,
- scripts,
- fontDescriptionRuns,
- defaultFontDescription,
- defaultPointSize,
- 0u,
- numberOfCharacters,
- validFonts );
+ multilanguageSupport.ValidateFonts(utf32Characters,
+ scripts,
+ fontDescriptionRuns,
+ defaultFontDescription,
+ defaultPointSize,
+ 0u,
+ numberOfCharacters,
+ validFonts);
////////////////////////////////////////////////////////////////////////////////
// Retrieve the Bidirectional info.
////////////////////////////////////////////////////////////////////////////////
- bidirectionalInfo.Reserve( 1u );
+ bidirectionalInfo.Reserve(1u);
- SetBidirectionalInfo( utf32Characters,
- scripts,
- lineBreakInfo,
- 0u,
- numberOfCharacters,
- bidirectionalInfo );
+ SetBidirectionalInfo(utf32Characters,
+ scripts,
+ lineBreakInfo,
+ 0u,
+ numberOfCharacters,
+ bidirectionalInfo);
const bool hasBidirectionalText = 0u != bidirectionalInfo.Count();
- if( hasBidirectionalText )
+ if(hasBidirectionalText)
{
// Only set the character directions if there is right to left characters.
- GetCharactersDirection( bidirectionalInfo,
- numberOfCharacters,
- 0u,
- numberOfCharacters,
- directions );
+ GetCharactersDirection(bidirectionalInfo,
+ numberOfCharacters,
+ 0u,
+ numberOfCharacters,
+ directions);
// This paragraph has right to left text. Some characters may need to be mirrored.
// TODO: consider if the mirrored string can be stored as well.
- internalDataModel.isTextMirrored = GetMirroredText( utf32Characters,
- directions,
- bidirectionalInfo,
- 0u,
- numberOfCharacters,
- mirroredUtf32Characters );
+ internalDataModel.isTextMirrored = GetMirroredText(utf32Characters,
+ directions,
+ bidirectionalInfo,
+ 0u,
+ numberOfCharacters,
+ mirroredUtf32Characters);
}
}
-void ShapeText( TextAbstraction::TextRenderer::Parameters& rendererParameters, Vector<EmbeddedItemInfo>& embeddedItemLayout, InternalDataModel& internalDataModel )
+void ShapeText(TextAbstraction::TextRenderer::Parameters& rendererParameters, Vector<EmbeddedItemInfo>& embeddedItemLayout, InternalDataModel& internalDataModel)
{
- Vector<GlyphIndex> newParagraphGlyphs; // Glyphs for the new paragraph characters.
- const Length numberOfCharacters = internalDataModel.numberOfCharacters;
- const bool isTextMirrored = internalDataModel.isTextMirrored;
- Text::ModelPtr& textModel = internalDataModel.textModel;
- const Vector<Character>& mirroredUtf32Characters = internalDataModel.mirroredUtf32Characters;
- FontClient& fontClient = internalDataModel.fontClient;
- const Vector<Character>& utf32Characters = textModel->mLogicalModel->mText; // Characters encoded in utf32.
- const Vector<LineBreakInfo>& lineBreakInfo = textModel->mLogicalModel->mLineBreakInfo; // The line break info.
- const Vector<ScriptRun>& scripts = textModel->mLogicalModel->mScriptRuns; // Charactes's script.
- const Vector<FontRun>& validFonts = textModel->mLogicalModel->mFontRuns; // Validated fonts.
-
- Vector<CharacterIndex>& glyphsToCharacters = textModel->mVisualModel->mGlyphsToCharacters; // Glyphs to character map.
- Vector<Length>& charactersPerGlyph = textModel->mVisualModel->mCharactersPerGlyph; // Number of characters per glyph.
+ Vector<GlyphIndex> newParagraphGlyphs; // Glyphs for the new paragraph characters.
+ const Length numberOfCharacters = internalDataModel.numberOfCharacters;
+ const bool isTextMirrored = internalDataModel.isTextMirrored;
+ Text::ModelPtr& textModel = internalDataModel.textModel;
+ const Vector<Character>& mirroredUtf32Characters = internalDataModel.mirroredUtf32Characters;
+ FontClient& fontClient = internalDataModel.fontClient;
+ const Vector<Character>& utf32Characters = textModel->mLogicalModel->mText; // Characters encoded in utf32.
+ const Vector<LineBreakInfo>& lineBreakInfo = textModel->mLogicalModel->mLineBreakInfo; // The line break info.
+ const Vector<ScriptRun>& scripts = textModel->mLogicalModel->mScriptRuns; // Charactes's script.
+ const Vector<FontRun>& validFonts = textModel->mLogicalModel->mFontRuns; // Validated fonts.
+
+ Vector<CharacterIndex>& glyphsToCharacters = textModel->mVisualModel->mGlyphsToCharacters; // Glyphs to character map.
+ Vector<Length>& charactersPerGlyph = textModel->mVisualModel->mCharactersPerGlyph; // Number of characters per glyph.
////////////////////////////////////////////////////////////////////////////////
// Retrieve the glyphs. Text shaping
const Vector<Character>& textToShape = isTextMirrored ? mirroredUtf32Characters : utf32Characters;
- newParagraphGlyphs.Reserve( 1u );
+ newParagraphGlyphs.Reserve(1u);
// Shapes the text.
- ShapeText( textToShape,
- lineBreakInfo,
- scripts,
- validFonts,
- 0u,
- 0u,
- numberOfCharacters,
- rendererParameters.glyphs,
- glyphsToCharacters,
- charactersPerGlyph,
- newParagraphGlyphs );
+ ShapeText(textToShape,
+ lineBreakInfo,
+ scripts,
+ validFonts,
+ 0u,
+ 0u,
+ numberOfCharacters,
+ rendererParameters.glyphs,
+ glyphsToCharacters,
+ charactersPerGlyph,
+ newParagraphGlyphs);
// Create the 'number of glyphs' per character and the glyph to character conversion tables.
- textModel->mVisualModel->CreateGlyphsPerCharacterTable( 0u, 0u, numberOfCharacters );
- textModel->mVisualModel->CreateCharacterToGlyphTable( 0u, 0u, numberOfCharacters );
+ textModel->mVisualModel->CreateGlyphsPerCharacterTable(0u, 0u, numberOfCharacters);
+ textModel->mVisualModel->CreateCharacterToGlyphTable(0u, 0u, numberOfCharacters);
internalDataModel.numberOfGlyphs = rendererParameters.glyphs.Count();
// Once the text has been shaped and the glyphs created it's possible to replace the font id of those glyphs
// that represent an image or an item and create the embedded item layout info.
// Note: the position of the embedded item can't be set until the text is laid-out.
- embeddedItemLayout.Reserve( textModel->mLogicalModel->mEmbeddedItems.Count() );
- for( const auto& item : textModel->mLogicalModel->mEmbeddedItems )
+ embeddedItemLayout.Reserve(textModel->mLogicalModel->mEmbeddedItems.Count());
+ for(const auto& item : textModel->mLogicalModel->mEmbeddedItems)
{
// Get the glyph that matches with the character index.
const GlyphIndex glyphIndex = textModel->mVisualModel->mCharactersToGlyph[item.characterIndex];
- GlyphInfo& glyph = rendererParameters.glyphs[glyphIndex];
+ GlyphInfo& glyph = rendererParameters.glyphs[glyphIndex];
- glyph.fontId = 0u;
- Pixel::Format pixelFormat = Pixel::A8;
- TextAbstraction::FontClient::EmbeddedItemDescription description = { std::string( item.url, item.urlLength ), item.width, item.height, item.colorBlendingMode };
- glyph.index = fontClient.CreateEmbeddedItem( description, pixelFormat ); // Set here an index to an item.
+ glyph.fontId = 0u;
+ Pixel::Format pixelFormat = Pixel::A8;
+ TextAbstraction::FontClient::EmbeddedItemDescription description = {std::string(item.url, item.urlLength), item.width, item.height, item.colorBlendingMode};
+ glyph.index = fontClient.CreateEmbeddedItem(description, pixelFormat); // Set here an index to an item.
- if( ( Pixel::RGBA8888 == pixelFormat ) || ( Pixel::BGRA8888 == pixelFormat ) )
+ if((Pixel::RGBA8888 == pixelFormat) || (Pixel::BGRA8888 == pixelFormat))
{
rendererParameters.pixelFormat = TextAbstraction::TextRenderer::Parameters::RGBA8888;
}
// If the url is empty the item is going to be added after the text is rendered. It's needed to store the layout here.
- if( description.url.empty() )
+ if(description.url.empty())
{
EmbeddedItemInfo embeddedInfo =
- {
- item.characterIndex,
- glyphIndex,
- Vector2::ZERO,
- Size( static_cast<float>( item.width ), static_cast<float>( item.height ) ),
- Size( static_cast<float>( item.width ), static_cast<float>( item.height ) ),
- Degree( 0.f ),
- item.colorBlendingMode
- };
-
- embeddedItemLayout.PushBack( embeddedInfo );
+ {
+ item.characterIndex,
+ glyphIndex,
+ Vector2::ZERO,
+ Size(static_cast<float>(item.width), static_cast<float>(item.height)),
+ Size(static_cast<float>(item.width), static_cast<float>(item.height)),
+ Degree(0.f),
+ item.colorBlendingMode};
+
+ embeddedItemLayout.PushBack(embeddedInfo);
}
}
}
-void SetColorSegmentation( const RendererParameters& textParameters, InternalDataModel& internalDataModel )
+void SetColorSegmentation(const RendererParameters& textParameters, InternalDataModel& internalDataModel)
{
-
- Text::ModelPtr& textModel = internalDataModel.textModel;
+ Text::ModelPtr& textModel = internalDataModel.textModel;
Vector<ColorBlendingMode>& blendingMode = internalDataModel.blendingMode;
- Vector<ColorRun>& colorRuns = textModel->mLogicalModel->mColorRuns; // colors of the text.
+ Vector<ColorRun>& colorRuns = textModel->mLogicalModel->mColorRuns; // colors of the text.
- Vector<GlyphIndex>& charactersToGlyph = textModel->mVisualModel->mCharactersToGlyph; // Characters to glyphs map.
- Vector<Length>& glyphsPerCharacter = textModel->mVisualModel->mGlyphsPerCharacter; // The number of glyphs that are shaped.
+ Vector<GlyphIndex>& charactersToGlyph = textModel->mVisualModel->mCharactersToGlyph; // Characters to glyphs map.
+ Vector<Length>& glyphsPerCharacter = textModel->mVisualModel->mGlyphsPerCharacter; // The number of glyphs that are shaped.
////////////////////////////////////////////////////////////////////////////////
// Set the color runs in glyphs.
////////////////////////////////////////////////////////////////////////////////
- SetColorSegmentationInfo( colorRuns,
- charactersToGlyph,
- glyphsPerCharacter,
- 0u,
- 0u,
- internalDataModel.numberOfCharacters,
- textModel->mVisualModel->mColors,
- textModel->mVisualModel->mColorIndices );
+ SetColorSegmentationInfo(colorRuns,
+ charactersToGlyph,
+ glyphsPerCharacter,
+ 0u,
+ 0u,
+ internalDataModel.numberOfCharacters,
+ textModel->mVisualModel->mColors,
+ textModel->mVisualModel->mColorIndices);
// Insert the default color at the beginning of the vector.
- textModel->mVisualModel->mColors.Insert( textModel->mVisualModel->mColors.Begin(),textParameters.textColor );
+ textModel->mVisualModel->mColors.Insert(textModel->mVisualModel->mColors.Begin(), textParameters.textColor);
// Set how the embedded items are blended with text color.
- blendingMode.Resize( internalDataModel.numberOfGlyphs, textParameters.isTextColorSet ? ColorBlendingMode::MULTIPLY : ColorBlendingMode::NONE );
+ blendingMode.Resize(internalDataModel.numberOfGlyphs, textParameters.isTextColorSet ? ColorBlendingMode::MULTIPLY : ColorBlendingMode::NONE);
- if( !textParameters.isTextColorSet )
+ if(!textParameters.isTextColorSet)
{
// Traverse the color runs.
- for( const auto& run : colorRuns )
+ for(const auto& run : colorRuns)
{
- const GlyphIndex firstGlyph = textModel->mVisualModel->mCharactersToGlyph[run.characterRun.characterIndex];
- const CharacterIndex lastCharacter = run.characterRun.characterIndex + run.characterRun.numberOfCharacters - 1u;
- const GlyphIndex lastGlyphPlusOne = textModel->mVisualModel->mCharactersToGlyph[lastCharacter] + textModel->mVisualModel->mGlyphsPerCharacter[lastCharacter];
+ const GlyphIndex firstGlyph = textModel->mVisualModel->mCharactersToGlyph[run.characterRun.characterIndex];
+ const CharacterIndex lastCharacter = run.characterRun.characterIndex + run.characterRun.numberOfCharacters - 1u;
+ const GlyphIndex lastGlyphPlusOne = textModel->mVisualModel->mCharactersToGlyph[lastCharacter] + textModel->mVisualModel->mGlyphsPerCharacter[lastCharacter];
- for( GlyphIndex index = firstGlyph; index < lastGlyphPlusOne; ++index )
+ for(GlyphIndex index = firstGlyph; index < lastGlyphPlusOne; ++index)
{
blendingMode[index] = ColorBlendingMode::MULTIPLY;
}
}
// Traverse the embedded items and update the blending mode vector.
- for( const auto& item : textModel->mLogicalModel->mEmbeddedItems )
+ for(const auto& item : textModel->mLogicalModel->mEmbeddedItems)
{
const GlyphIndex glyphIndex = textModel->mVisualModel->mCharactersToGlyph[item.characterIndex];
- blendingMode[glyphIndex] = item.colorBlendingMode;
+ blendingMode[glyphIndex] = item.colorBlendingMode;
}
}
-void SetEmojiVector( InternalDataModel& internalDataModel )
+void SetEmojiVector(InternalDataModel& internalDataModel)
{
- Vector<bool>& isEmoji = internalDataModel.isEmoji;
- Text::ModelPtr& textModel = internalDataModel.textModel;
- const Length numberOfGlyphs = internalDataModel.numberOfGlyphs;
+ Vector<bool>& isEmoji = internalDataModel.isEmoji;
+ Text::ModelPtr& textModel = internalDataModel.textModel;
+ const Length numberOfGlyphs = internalDataModel.numberOfGlyphs;
- const Vector<ScriptRun>& scripts = textModel->mLogicalModel->mScriptRuns; // Charactes's script.
+ const Vector<ScriptRun>& scripts = textModel->mLogicalModel->mScriptRuns; // Charactes's script.
////////////////////////////////////////////////////////////////////////////////
// Set the isEmoji Vector
////////////////////////////////////////////////////////////////////////////////
- isEmoji.Resize( numberOfGlyphs, false );
+ isEmoji.Resize(numberOfGlyphs, false);
- for( const auto& run : scripts )
+ for(const auto& run : scripts)
{
- if( run.script == TextAbstraction::Script::EMOJI )
+ if(run.script == TextAbstraction::Script::EMOJI)
{
- const GlyphIndex firstGlyph = textModel->mVisualModel->mCharactersToGlyph[run.characterRun.characterIndex];
- const CharacterIndex lastCharacter = run.characterRun.characterIndex + run.characterRun.numberOfCharacters - 1u;
- const GlyphIndex lastGlyphPlusOne = textModel->mVisualModel->mCharactersToGlyph[lastCharacter] + textModel->mVisualModel->mGlyphsPerCharacter[lastCharacter];
+ const GlyphIndex firstGlyph = textModel->mVisualModel->mCharactersToGlyph[run.characterRun.characterIndex];
+ const CharacterIndex lastCharacter = run.characterRun.characterIndex + run.characterRun.numberOfCharacters - 1u;
+ const GlyphIndex lastGlyphPlusOne = textModel->mVisualModel->mCharactersToGlyph[lastCharacter] + textModel->mVisualModel->mGlyphsPerCharacter[lastCharacter];
- for( GlyphIndex index = firstGlyph; index < lastGlyphPlusOne; ++index )
+ for(GlyphIndex index = firstGlyph; index < lastGlyphPlusOne; ++index)
{
isEmoji[index] = true;
}
}
}
-
-void Align( const RendererParameters& textParameters, TextAbstraction::TextRenderer::Parameters& rendererParameters,
- Vector<EmbeddedItemInfo>& embeddedItemLayout, InternalDataModel& internalDataModel,
- const Size& newLayoutSize )
+void Align(const RendererParameters& textParameters, TextAbstraction::TextRenderer::Parameters& rendererParameters, Vector<EmbeddedItemInfo>& embeddedItemLayout, InternalDataModel& internalDataModel, const Size& newLayoutSize)
{
- Text::Layout::Engine& layoutEngine = internalDataModel.layoutEngine;
- Text::ModelPtr& textModel = internalDataModel.textModel;
- const Length numberOfCharacters = internalDataModel.numberOfCharacters;
- Size& textLayoutArea = internalDataModel.textLayoutArea;
+ Text::Layout::Engine& layoutEngine = internalDataModel.layoutEngine;
+ Text::ModelPtr& textModel = internalDataModel.textModel;
+ const Length numberOfCharacters = internalDataModel.numberOfCharacters;
+ Size& textLayoutArea = internalDataModel.textLayoutArea;
- Vector<LineRun>& lines = textModel->mVisualModel->mLines; // The laid out lines.
+ Vector<LineRun>& lines = textModel->mVisualModel->mLines; // The laid out lines.
////////////////////////////////////////////////////////////////////////////////
// Align the text.
////////////////////////////////////////////////////////////////////////////////
- HorizontalAlignment::Type horizontalAlignment = Toolkit::HorizontalAlignment::CENTER;
+ HorizontalAlignment::Type horizontalAlignment = Toolkit::HorizontalAlignment::CENTER;
HorizontalAlignment::Type horizontalCircularAlignment = Toolkit::HorizontalAlignment::CENTER;
- VerticalAlignment::Type verticalAlignment = VerticalAlignment::CENTER;
- CircularAlignment::Type circularAlignment = CircularAlignment::BEGIN;
+ VerticalAlignment::Type verticalAlignment = VerticalAlignment::CENTER;
+ CircularAlignment::Type circularAlignment = CircularAlignment::BEGIN;
Layout::Type layout = Layout::SINGLELINE;
// Sets the alignment
- Property::Value horizontalAlignmentStr( textParameters.horizontalAlignment );
- GetHorizontalAlignmentEnumeration( horizontalAlignmentStr, horizontalAlignment );
+ Property::Value horizontalAlignmentStr(textParameters.horizontalAlignment);
+ GetHorizontalAlignmentEnumeration(horizontalAlignmentStr, horizontalAlignment);
horizontalCircularAlignment = horizontalAlignment;
- Property::Value verticalAlignmentStr( textParameters.verticalAlignment );
- GetVerticalAlignmentEnumeration( verticalAlignmentStr, verticalAlignment );
+ Property::Value verticalAlignmentStr(textParameters.verticalAlignment);
+ GetVerticalAlignmentEnumeration(verticalAlignmentStr, verticalAlignment);
- Property::Value circularAlignmentStr( textParameters.circularAlignment );
- GetCircularAlignmentEnumeration( circularAlignmentStr, circularAlignment );
+ Property::Value circularAlignmentStr(textParameters.circularAlignment);
+ GetCircularAlignmentEnumeration(circularAlignmentStr, circularAlignment);
- Property::Value layoutStr( textParameters.layout );
- GetLayoutEnumeration( layoutStr, layout );
+ Property::Value layoutStr(textParameters.layout);
+ GetLayoutEnumeration(layoutStr, layout);
// Whether the layout is circular.
const bool isCircularTextLayout = (Layout::CIRCULAR == layout);
- const bool isClockwise = isCircularTextLayout && ( 0.f < textParameters.incrementAngle );
+ const bool isClockwise = isCircularTextLayout && (0.f < textParameters.incrementAngle);
// Convert CircularAlignment to HorizontalAlignment.
- if( isCircularTextLayout )
+ if(isCircularTextLayout)
{
- switch( circularAlignment )
+ switch(circularAlignment)
{
case CircularAlignment::BEGIN:
{
// Retrieve the line of text to know the direction and the width. @todo multi-line
const LineRun& line = lines[0u];
- if( isCircularTextLayout )
+ if(isCircularTextLayout)
{
// Set the circular alignment.
rendererParameters.circularLayout = isClockwise ? TextRenderer::Parameters::CLOCKWISE : TextRenderer::Parameters::COUNTER_CLOCKWISE;
textLayoutArea.height = newLayoutSize.height;
// Set the size of the text laid out on a straight horizontal line.
- rendererParameters.circularWidth = static_cast<unsigned int>( newLayoutSize.width );
- rendererParameters.circularHeight = static_cast<unsigned int>( newLayoutSize.height );
+ rendererParameters.circularWidth = static_cast<unsigned int>(newLayoutSize.width);
+ rendererParameters.circularHeight = static_cast<unsigned int>(newLayoutSize.height);
// Calculate the center of the circular text according the horizontal and vertical alingments and the radius.
- switch( horizontalAlignment )
+ switch(horizontalAlignment)
{
case HorizontalAlignment::BEGIN:
{
}
case HorizontalAlignment::CENTER:
{
- rendererParameters.centerX = static_cast<int>( textParameters.textWidth / 2u );
+ rendererParameters.centerX = static_cast<int>(textParameters.textWidth / 2u);
break;
}
case HorizontalAlignment::END:
{
- rendererParameters.centerX = static_cast<int>( textParameters.textWidth ) - static_cast<int>(textParameters.radius);
+ rendererParameters.centerX = static_cast<int>(textParameters.textWidth) - static_cast<int>(textParameters.radius);
break;
}
}
- switch( verticalAlignment )
+ switch(verticalAlignment)
{
case VerticalAlignment::TOP:
{
}
case VerticalAlignment::CENTER:
{
- rendererParameters.centerY = static_cast<int>( textParameters.textHeight / 2u );
+ rendererParameters.centerY = static_cast<int>(textParameters.textHeight / 2u);
break;
}
case VerticalAlignment::BOTTOM:
{
- rendererParameters.centerY = static_cast<int>( textParameters.textHeight ) - static_cast<int>(textParameters.radius);
+ rendererParameters.centerY = static_cast<int>(textParameters.textHeight) - static_cast<int>(textParameters.radius);
break;
}
}
const bool isRTL = RTL == line.direction;
CircularAlignment::Type alignment = circularAlignment;
- if( isRTL )
+ if(isRTL)
{
// Swap the alignment type if the line is right to left.
- switch( alignment )
+ switch(alignment)
{
case CircularAlignment::BEGIN:
{
float angleOffset = 0.f;
- switch( alignment )
+ switch(alignment)
{
case CircularAlignment::BEGIN:
{
}
case CircularAlignment::CENTER:
{
- const bool isNeg = textParameters.incrementAngle < 0.f;
- const float textWidth = static_cast<float>( rendererParameters.circularWidth );
- angleOffset = ( isNeg ? -0.5f : 0.5f ) * ( textLayoutArea.width - textWidth ) / static_cast<float>( rendererParameters.radius );
+ const bool isNeg = textParameters.incrementAngle < 0.f;
+ const float textWidth = static_cast<float>(rendererParameters.circularWidth);
+ angleOffset = (isNeg ? -0.5f : 0.5f) * (textLayoutArea.width - textWidth) / static_cast<float>(rendererParameters.radius);
break;
}
case CircularAlignment::END:
{
- const bool isNeg = textParameters.incrementAngle < 0.f;
- const float textWidth = static_cast<float>( rendererParameters.circularWidth );
- angleOffset = ( isNeg ? -1.f : 1.f ) * ( textLayoutArea.width - textWidth ) / static_cast<float>( rendererParameters.radius );
+ const bool isNeg = textParameters.incrementAngle < 0.f;
+ const float textWidth = static_cast<float>(rendererParameters.circularWidth);
+ angleOffset = (isNeg ? -1.f : 1.f) * (textLayoutArea.width - textWidth) / static_cast<float>(rendererParameters.radius);
break;
}
}
// Update the beginning angle with the calculated offset.
- rendererParameters.beginAngle = Radian( Degree( textParameters.beginAngle ) ) + angleOffset;
+ rendererParameters.beginAngle = Radian(Degree(textParameters.beginAngle)) + angleOffset;
// Set the vertical position of the glyphs.
- for( auto& position : rendererParameters.positions )
+ for(auto& position : rendererParameters.positions)
{
position.y = 0.f;
}
// Calculate the vertical offset according with the given alignment.
float penY = 0.f;
- switch( verticalAlignment )
+ switch(verticalAlignment)
{
case VerticalAlignment::TOP:
{
}
case VerticalAlignment::CENTER:
{
- penY = line.ascender + 0.5f * ( textLayoutArea.height - ( line.ascender - line.descender ) );
+ penY = line.ascender + 0.5f * (textLayoutArea.height - (line.ascender - line.descender));
break;
}
case VerticalAlignment::BOTTOM:
// Calculate the horizontal offset according with the given alignment.
float alignmentOffset = 0.f;
- layoutEngine.Align( textLayoutArea,
- 0u,
- numberOfCharacters,
- horizontalAlignment,
- lines,
- alignmentOffset,
- Dali::LayoutDirection::LEFT_TO_RIGHT,
- false );
+ layoutEngine.Align(textLayoutArea,
+ 0u,
+ numberOfCharacters,
+ horizontalAlignment,
+ lines,
+ alignmentOffset,
+ Dali::LayoutDirection::LEFT_TO_RIGHT,
+ false);
// Update the position of the glyphs with the calculated offsets.
- for( auto& position : rendererParameters.positions )
+ for(auto& position : rendererParameters.positions)
{
position.x += line.alignmentOffset;
position.y = penY;
// Cairo adds the bearing to the position of the glyph
// that has already been added by the DALi's layout engine,
// so it's needed to be removed here.
- for( unsigned int index = 0u; index < rendererParameters.glyphs.Count(); ++index )
+ for(unsigned int index = 0u; index < rendererParameters.glyphs.Count(); ++index)
{
- const GlyphInfo& glyph = rendererParameters.glyphs[index];
- Vector2& position = rendererParameters.positions[index];
+ const GlyphInfo& glyph = rendererParameters.glyphs[index];
+ Vector2& position = rendererParameters.positions[index];
position.x -= glyph.xBearing;
}
// Set the position of the embedded items (if there is any).
EmbeddedItemInfo* embeddedItemLayoutBuffer = embeddedItemLayout.Begin();
- for( Length index = 0u, endIndex = embeddedItemLayout.Count(); index < endIndex; ++index )
+ for(Length index = 0u, endIndex = embeddedItemLayout.Count(); index < endIndex; ++index)
{
- EmbeddedItemInfo& embeddedItem = *( embeddedItemLayoutBuffer + index );
+ EmbeddedItemInfo& embeddedItem = *(embeddedItemLayoutBuffer + index);
embeddedItem.position = rendererParameters.positions[embeddedItem.glyphIndex];
- if( isCircularTextLayout )
+ if(isCircularTextLayout)
{
// Calculate the new position of the embedded item in the circular path.
// Center of the bitmap.
- const float halfWidth = 0.5f * embeddedItem.size.width;
+ const float halfWidth = 0.5f * embeddedItem.size.width;
const float halfHeight = 0.5f * embeddedItem.size.height;
- double centerX = static_cast<double>( embeddedItem.position.x + halfWidth );
- double centerY = static_cast<double>(embeddedItem.position.y - halfHeight);
+ double centerX = static_cast<double>(embeddedItem.position.x + halfWidth);
+ double centerY = static_cast<double>(embeddedItem.position.y - halfHeight);
Dali::TextAbstraction::CircularTextParameters circularTextParameters;
- circularTextParameters.radius = static_cast<double>( rendererParameters.radius );
- circularTextParameters.invRadius = 1.0 / circularTextParameters.radius;
- circularTextParameters.beginAngle = static_cast<double>( -rendererParameters.beginAngle + Dali::Math::PI_2 );
- circularTextParameters.centerX = 0.5f * static_cast<double>( textParameters.textWidth );
- circularTextParameters.centerY = 0.5f * static_cast<double>( textParameters.textHeight );
+ circularTextParameters.radius = static_cast<double>(rendererParameters.radius);
+ circularTextParameters.invRadius = 1.0 / circularTextParameters.radius;
+ circularTextParameters.beginAngle = static_cast<double>(-rendererParameters.beginAngle + Dali::Math::PI_2);
+ circularTextParameters.centerX = 0.5f * static_cast<double>(textParameters.textWidth);
+ circularTextParameters.centerY = 0.5f * static_cast<double>(textParameters.textHeight);
// Calculate the rotation angle.
float radians = rendererParameters.beginAngle;
- if( isClockwise )
+ if(isClockwise)
{
- radians += static_cast<float>( circularTextParameters.invRadius * centerX );
+ radians += static_cast<float>(circularTextParameters.invRadius * centerX);
radians = -radians;
}
else
{
- radians -= static_cast<float>( circularTextParameters.invRadius * centerX );
+ radians -= static_cast<float>(circularTextParameters.invRadius * centerX);
radians = -radians + Dali::Math::PI;
}
- embeddedItem.angle = Degree( Radian( radians ) );
+ embeddedItem.angle = Degree(Radian(radians));
- Dali::TextAbstraction::TransformToArc( circularTextParameters, centerX, centerY );
+ Dali::TextAbstraction::TransformToArc(circularTextParameters, centerX, centerY);
// Recalculate the size of the embedded item after the rotation to position it correctly.
- float width = embeddedItem.size.width;
+ float width = embeddedItem.size.width;
float height = embeddedItem.size.height;
// Transform the input angle into the range [0..2PI]
- radians = fmod( radians, TWO_PI );
- radians += ( radians < 0.f ) ? TWO_PI : 0.f;
+ radians = fmod(radians, TWO_PI);
+ radians += (radians < 0.f) ? TWO_PI : 0.f;
// Does the same operations than rotate by shear.
- if( ( radians > Math::PI_4 ) && ( radians <= RAD_135 ) )
+ if((radians > Math::PI_4) && (radians <= RAD_135))
{
- std::swap( width, height );
+ std::swap(width, height);
radians -= Math::PI_2;
}
- else if( ( radians > RAD_135 ) && ( radians <= RAD_225 ) )
+ else if((radians > RAD_135) && (radians <= RAD_225))
{
radians -= Math::PI;
}
- else if( ( radians > RAD_225 ) && ( radians <= RAD_315 ) )
+ else if((radians > RAD_225) && (radians <= RAD_315))
{
- std::swap( width, height );
+ std::swap(width, height);
radians -= RAD_270;
}
- if( fabs( radians ) > Dali::Math::MACHINE_EPSILON_10 )
+ if(fabs(radians) > Dali::Math::MACHINE_EPSILON_10)
{
- const float angleSinus = fabs( sin( radians ) );
- const float angleCosinus = cos( radians );
+ const float angleSinus = fabs(sin(radians));
+ const float angleCosinus = cos(radians);
// Calculate the rotated image dimensions.
embeddedItem.rotatedSize.height = width * angleSinus + height * angleCosinus;
- embeddedItem.rotatedSize.width = height * angleSinus + width * angleCosinus + 1.f;
+ embeddedItem.rotatedSize.width = height * angleSinus + width * angleCosinus + 1.f;
}
- embeddedItem.position.x = floor( static_cast<float>( centerX ) - 0.5f * embeddedItem.rotatedSize.width );
- embeddedItem.position.y = floor( static_cast<float>( centerY ) - 0.5f * embeddedItem.rotatedSize.height );
+ embeddedItem.position.x = floor(static_cast<float>(centerX) - 0.5f * embeddedItem.rotatedSize.width);
+ embeddedItem.position.y = floor(static_cast<float>(centerY) - 0.5f * embeddedItem.rotatedSize.height);
}
else
{
embeddedItem.position.y -= embeddedItem.size.height;
}
}
-
}
-void Ellipsis( const RendererParameters& textParameters, TextAbstraction::TextRenderer::Parameters& rendererParameters,
- Vector<EmbeddedItemInfo>& embeddedItemLayout, InternalDataModel& internalDataModel )
+void Ellipsis(const RendererParameters& textParameters, TextAbstraction::TextRenderer::Parameters& rendererParameters, Vector<EmbeddedItemInfo>& embeddedItemLayout, InternalDataModel& internalDataModel)
{
- Text::ModelPtr& textModel = internalDataModel.textModel;
- FontClient& fontClient = internalDataModel.fontClient;
+ Text::ModelPtr& textModel = internalDataModel.textModel;
+ FontClient& fontClient = internalDataModel.fontClient;
- Vector<LineRun>& lines = textModel->mVisualModel->mLines; // The laid out lines.
- Vector<bool>& isEmoji = internalDataModel.isEmoji;
- const Size textLayoutArea = internalDataModel.textLayoutArea;
+ Vector<LineRun>& lines = textModel->mVisualModel->mLines; // The laid out lines.
+ Vector<bool>& isEmoji = internalDataModel.isEmoji;
+ const Size textLayoutArea = internalDataModel.textLayoutArea;
////////////////////////////////////////////////////////////////////////////////
// Ellipsis the text.
////////////////////////////////////////////////////////////////////////////////
- if( textParameters.ellipsisEnabled )
+ if(textParameters.ellipsisEnabled)
{
const LineRun& line = lines[0u]; // TODO: multi-line
- if( line.ellipsis )
+ if(line.ellipsis)
{
Length finalNumberOfGlyphs = 0u;
- if( ( line.ascender - line.descender ) > textLayoutArea.height )
+ if((line.ascender - line.descender) > textLayoutArea.height)
{
// The height of the line is bigger than the height of the text area.
// Show the ellipsis glyph even if it doesn't fit in the text area.
// until is find out that the text area is too small.
// Get the first glyph which is going to be replaced and the ellipsis glyph.
- GlyphInfo& glyphInfo = rendererParameters.glyphs[0u];
- const GlyphInfo& ellipsisGlyph = fontClient.GetEllipsisGlyph( fontClient.GetPointSize( glyphInfo.fontId ) );
+ GlyphInfo& glyphInfo = rendererParameters.glyphs[0u];
+ const GlyphInfo& ellipsisGlyph = fontClient.GetEllipsisGlyph(fontClient.GetPointSize(glyphInfo.fontId));
// Change the 'x' and 'y' position of the ellipsis glyph.
Vector2& position = rendererParameters.positions[0u];
- position.x = ellipsisGlyph.xBearing;
- position.y = textLayoutArea.height - ellipsisGlyph.yBearing;
+ position.x = ellipsisGlyph.xBearing;
+ position.y = textLayoutArea.height - ellipsisGlyph.yBearing;
// Replace the glyph by the ellipsis glyph.
glyphInfo = ellipsisGlyph;
}
else
{
-
// firstPenX, penY and firstPenSet are used to position the ellipsis glyph if needed.
- float firstPenX = 0.f; // Used if rtl text is elided.
- bool firstPenSet = false;
+ float firstPenX = 0.f; // Used if rtl text is elided.
+ bool firstPenSet = false;
// Add the ellipsis glyph.
- bool inserted = false;
- float removedGlypsWidth = 0.f;
+ bool inserted = false;
+ float removedGlypsWidth = 0.f;
Length numberOfRemovedGlyphs = 0u;
- if (line.glyphRun.numberOfGlyphs > 0u)
+ if(line.glyphRun.numberOfGlyphs > 0u)
{
GlyphIndex index = line.glyphRun.numberOfGlyphs - 1u;
- GlyphInfo* glyphs = rendererParameters.glyphs.Begin();
- Vector2* glyphPositions = rendererParameters.positions.Begin();
+ GlyphInfo* glyphs = rendererParameters.glyphs.Begin();
+ Vector2* glyphPositions = rendererParameters.positions.Begin();
float penY = 0.f;
// The ellipsis glyph has to fit in the place where the last glyph(s) is(are) removed.
- while( !inserted )
+ while(!inserted)
{
- const GlyphInfo& glyphToRemove = *( glyphs + index );
+ const GlyphInfo& glyphToRemove = *(glyphs + index);
- if( 0u != glyphToRemove.fontId )
+ if(0u != glyphToRemove.fontId)
{
// i.e. The font id of the glyph shaped from the '\n' character is zero.
// Need to reshape the glyph as the font may be different in size.
- const GlyphInfo& ellipsisGlyph = fontClient.GetEllipsisGlyph( fontClient.GetPointSize( glyphToRemove.fontId ) );
+ const GlyphInfo& ellipsisGlyph = fontClient.GetEllipsisGlyph(fontClient.GetPointSize(glyphToRemove.fontId));
- if( !firstPenSet )
+ if(!firstPenSet)
{
- const Vector2& position = *( glyphPositions + index );
+ const Vector2& position = *(glyphPositions + index);
// Calculates the penY of the current line. It will be used to position the ellipsis glyph.
penY = position.y;
// Calculates the first penX which will be used if rtl text is elided.
firstPenX = position.x - glyphToRemove.xBearing;
- if( firstPenX < -ellipsisGlyph.xBearing )
+ if(firstPenX < -ellipsisGlyph.xBearing)
{
// Avoids to exceed the bounding box when rtl text is elided.
firstPenX = -ellipsisGlyph.xBearing;
firstPenSet = true;
}
- removedGlypsWidth += std::min( glyphToRemove.advance, ( glyphToRemove.xBearing + glyphToRemove.width ) );
+ removedGlypsWidth += std::min(glyphToRemove.advance, (glyphToRemove.xBearing + glyphToRemove.width));
// Calculate the width of the ellipsis glyph and check if it fits.
const float ellipsisGlyphWidth = ellipsisGlyph.width + ellipsisGlyph.xBearing;
- if( ellipsisGlyphWidth < removedGlypsWidth )
+ if(ellipsisGlyphWidth < removedGlypsWidth)
{
- GlyphInfo& glyphInfo = *( glyphs + index );
- Vector2& position = *( glyphPositions + index );
- position.x -= ( 0.f > glyphInfo.xBearing ) ? glyphInfo.xBearing : 0.f;
+ GlyphInfo& glyphInfo = *(glyphs + index);
+ Vector2& position = *(glyphPositions + index);
+ position.x -= (0.f > glyphInfo.xBearing) ? glyphInfo.xBearing : 0.f;
// Replace the glyph by the ellipsis glyph.
glyphInfo = ellipsisGlyph;
// Change the 'x' and 'y' position of the ellipsis glyph.
- if( position.x > firstPenX )
+ if(position.x > firstPenX)
{
position.x = firstPenX + removedGlypsWidth - ellipsisGlyphWidth;
}
}
}
- if( !inserted )
+ if(!inserted)
{
- if( index > 0u )
+ if(index > 0u)
{
--index;
}
}
// Resize the number of glyphs/positions
- rendererParameters.glyphs.Resize( finalNumberOfGlyphs );
- rendererParameters.positions.Resize( finalNumberOfGlyphs );
+ rendererParameters.glyphs.Resize(finalNumberOfGlyphs);
+ rendererParameters.positions.Resize(finalNumberOfGlyphs);
// Remove from the embedded items those exceding the last laid out glyph.
- embeddedItemLayout.Erase( std::remove_if( embeddedItemLayout.Begin(),
- embeddedItemLayout.End(),
- [finalNumberOfGlyphs]( const EmbeddedItemInfo& item )
- {
- return item.glyphIndex >= finalNumberOfGlyphs;
- } ),
- embeddedItemLayout.End() );
+ embeddedItemLayout.Erase(std::remove_if(embeddedItemLayout.Begin(),
+ embeddedItemLayout.End(),
+ [finalNumberOfGlyphs](const EmbeddedItemInfo& item) {
+ return item.glyphIndex >= finalNumberOfGlyphs;
+ }),
+ embeddedItemLayout.End());
}
}
}
}
-Size LayoutText( const RendererParameters& textParameters, TextAbstraction::TextRenderer::Parameters& rendererParameters,
- Vector<EmbeddedItemInfo>& embeddedItemLayout, InternalDataModel& internalDataModel )
+Size LayoutText(const RendererParameters& textParameters, TextAbstraction::TextRenderer::Parameters& rendererParameters, Vector<EmbeddedItemInfo>& embeddedItemLayout, InternalDataModel& internalDataModel)
{
////////////////////////////////////////////////////////////////////////////////
// Layout the text.
////////////////////////////////////////////////////////////////////////////////
- Text::ModelPtr& textModel = internalDataModel.textModel;
- Text::Layout::Engine& layoutEngine = internalDataModel.layoutEngine;
- FontClient& fontClient = internalDataModel.fontClient;
- const Length numberOfGlyphs = internalDataModel.numberOfGlyphs;
- const bool isTextMirrored = internalDataModel.isTextMirrored;
+ Text::ModelPtr& textModel = internalDataModel.textModel;
+ Text::Layout::Engine& layoutEngine = internalDataModel.layoutEngine;
+ FontClient& fontClient = internalDataModel.fontClient;
+ const Length numberOfGlyphs = internalDataModel.numberOfGlyphs;
+ const bool isTextMirrored = internalDataModel.isTextMirrored;
const Vector<Character>& mirroredUtf32Characters = internalDataModel.mirroredUtf32Characters;
- const Length numberOfCharacters = internalDataModel.numberOfCharacters;
+ const Length numberOfCharacters = internalDataModel.numberOfCharacters;
Layout::Type layout = Layout::SINGLELINE;
- Property::Value layoutStr( textParameters.layout );
- GetLayoutEnumeration( layoutStr, layout );
+ Property::Value layoutStr(textParameters.layout);
+ GetLayoutEnumeration(layoutStr, layout);
// Whether the layout is multi-line.
- const Text::Layout::Engine::Type horizontalLayout = ( Layout::MULTILINE == layout ) ? Text::Layout::Engine::MULTI_LINE_BOX : Text::Layout::Engine::SINGLE_LINE_BOX;
- layoutEngine.SetLayout( horizontalLayout ); // TODO: multi-line.
+ const Text::Layout::Engine::Type horizontalLayout = (Layout::MULTILINE == layout) ? Text::Layout::Engine::MULTI_LINE_BOX : Text::Layout::Engine::SINGLE_LINE_BOX;
+ layoutEngine.SetLayout(horizontalLayout); // TODO: multi-line.
// Set minimun line size
- layoutEngine.SetDefaultLineSize( textParameters.minLineSize );
+ layoutEngine.SetDefaultLineSize(textParameters.minLineSize);
// Whether the layout is circular.
const bool isCircularTextLayout = (Layout::CIRCULAR == layout);
- const bool isClockwise = isCircularTextLayout && ( 0.f < textParameters.incrementAngle );
+ const bool isClockwise = isCircularTextLayout && (0.f < textParameters.incrementAngle);
// Calculates the max ascender or the max descender.
// Is used to calculate the radius of the base line of the text.
float maxAscenderDescender = 0.f;
- if( isCircularTextLayout )
+ if(isCircularTextLayout)
{
FontId currentFontId = 0u;
- for( const auto& glyph : rendererParameters.glyphs )
+ for(const auto& glyph : rendererParameters.glyphs)
{
- if( currentFontId != glyph.fontId )
+ if(currentFontId != glyph.fontId)
{
currentFontId = glyph.fontId;
FontMetrics metrics;
fontClient.GetFontMetrics(currentFontId, metrics);
- maxAscenderDescender = std::max( maxAscenderDescender, isClockwise ? metrics.ascender : metrics.descender );
+ maxAscenderDescender = std::max(maxAscenderDescender, isClockwise ? metrics.ascender : metrics.descender);
}
}
}
- const unsigned int radius = textParameters.radius - static_cast<unsigned int>( maxAscenderDescender );
+ const unsigned int radius = textParameters.radius - static_cast<unsigned int>(maxAscenderDescender);
// Set the layout parameters.
- internalDataModel.textLayoutArea = Size( static_cast<float>( textParameters.textWidth ),
- static_cast<float>( textParameters.textHeight ) );
+ internalDataModel.textLayoutArea = Size(static_cast<float>(textParameters.textWidth),
+ static_cast<float>(textParameters.textHeight));
- if( isCircularTextLayout )
+ if(isCircularTextLayout)
{
// In a circular layout, the length of the text area depends on the radius.
- rendererParameters.radius = radius;
- internalDataModel.textLayoutArea.width = fabs( Radian( Degree( textParameters.incrementAngle ) ) * static_cast<float>( rendererParameters.radius ) );
+ rendererParameters.radius = radius;
+ internalDataModel.textLayoutArea.width = fabs(Radian(Degree(textParameters.incrementAngle)) * static_cast<float>(rendererParameters.radius));
}
// Resize the vector of positions to have the same size than the vector of glyphs.
- rendererParameters.positions.Resize( numberOfGlyphs );
+ rendererParameters.positions.Resize(numberOfGlyphs);
- textModel->mLineWrapMode = LineWrap::WORD;
- textModel->mIgnoreSpacesAfterText = false;
+ textModel->mLineWrapMode = LineWrap::WORD;
+ textModel->mIgnoreSpacesAfterText = false;
textModel->mMatchSystemLanguageDirection = false;
- Text::Layout::Parameters layoutParameters( internalDataModel.textLayoutArea,
- textModel );
-
+ Text::Layout::Parameters layoutParameters(internalDataModel.textLayoutArea,
+ textModel);
// Whether the last character is a new paragraph character.
const Vector<Character>& textToShape = isTextMirrored ? mirroredUtf32Characters : textModel->mLogicalModel->mText;
- layoutParameters.isLastNewParagraph = TextAbstraction::IsNewParagraph( textToShape[numberOfCharacters - 1u] );
+ layoutParameters.isLastNewParagraph = TextAbstraction::IsNewParagraph(textToShape[numberOfCharacters - 1u]);
// The initial glyph and the number of glyphs to layout.
- layoutParameters.startGlyphIndex = 0u;
- layoutParameters.numberOfGlyphs = numberOfGlyphs;
- layoutParameters.startLineIndex = 0u;
+ layoutParameters.startGlyphIndex = 0u;
+ layoutParameters.numberOfGlyphs = numberOfGlyphs;
+ layoutParameters.startLineIndex = 0u;
layoutParameters.estimatedNumberOfLines = 1u;
layoutParameters.interGlyphExtraAdvance = 0.f;
// Update the visual model.
Size newLayoutSize;
bool isAutoScrollEnabled = false;
- layoutEngine.LayoutText( layoutParameters,
- newLayoutSize,
- textParameters.ellipsisEnabled,
- isAutoScrollEnabled );
+ layoutEngine.LayoutText(layoutParameters,
+ newLayoutSize,
+ textParameters.ellipsisEnabled,
+ isAutoScrollEnabled);
return newLayoutSize;
-
}
-
-Devel::PixelBuffer RenderText( const RendererParameters& textParameters, TextAbstraction::TextRenderer::Parameters& rendererParameters )
+Devel::PixelBuffer RenderText(const RendererParameters& textParameters, TextAbstraction::TextRenderer::Parameters& rendererParameters)
{
////////////////////////////////////////////////////////////////////////////////
// Render the text.
////////////////////////////////////////////////////////////////////////////////
- rendererParameters.width = textParameters.textWidth;
+ rendererParameters.width = textParameters.textWidth;
rendererParameters.height = textParameters.textHeight;
TextAbstraction::TextRenderer renderer = TextAbstraction::TextRenderer::Get();
- return renderer.Render( rendererParameters );
+ return renderer.Render(rendererParameters);
}
-
-Devel::PixelBuffer Render( const RendererParameters& textParameters, Vector<EmbeddedItemInfo>& embeddedItemLayout )
+Devel::PixelBuffer Render(const RendererParameters& textParameters, Vector<EmbeddedItemInfo>& embeddedItemLayout)
{
- if( textParameters.text.empty() )
+ if(textParameters.text.empty())
{
- Dali::Devel::PixelBuffer pixelBuffer = Dali::Devel::PixelBuffer::New( textParameters.textWidth,
- textParameters.textHeight,
- Dali::Pixel::RGBA8888 );
+ Dali::Devel::PixelBuffer pixelBuffer = Dali::Devel::PixelBuffer::New(textParameters.textWidth,
+ textParameters.textHeight,
+ Dali::Pixel::RGBA8888);
const unsigned int bufferSize = textParameters.textWidth * textParameters.textHeight * Dali::Pixel::GetBytesPerPixel(Dali::Pixel::RGBA8888);
- unsigned char* buffer = pixelBuffer.GetBuffer();
+ unsigned char* buffer = pixelBuffer.GetBuffer();
memset(buffer, 0, bufferSize);
return pixelBuffer;
FontClient fontClient = FontClient::Get();
MetricsPtr metrics;
// Use this to access FontClient i.e. to get down-scaled Emoji metrics.
- metrics = Metrics::New( fontClient );
+ metrics = Metrics::New(fontClient);
- Text::ModelPtr textModel = Text::Model::New();
- InternalDataModel internalData( fontClient, metrics, textModel );
+ Text::ModelPtr textModel = Text::Model::New();
+ InternalDataModel internalData(fontClient, metrics, textModel);
- TextAbstraction::TextRenderer::Parameters rendererParameters( internalData.textModel->mVisualModel->mGlyphs,
- internalData.textModel->mVisualModel->mGlyphPositions,
- internalData.textModel->mVisualModel->mColors,
- internalData.textModel->mVisualModel->mColorIndices,
- internalData.blendingMode,
- internalData.isEmoji );
+ TextAbstraction::TextRenderer::Parameters rendererParameters(internalData.textModel->mVisualModel->mGlyphs,
+ internalData.textModel->mVisualModel->mGlyphPositions,
+ internalData.textModel->mVisualModel->mColors,
+ internalData.textModel->mVisualModel->mColorIndices,
+ internalData.blendingMode,
+ internalData.isEmoji);
-
- rendererParameters.width = textParameters.textWidth;
- rendererParameters.height = textParameters.textHeight;
+ rendererParameters.width = textParameters.textWidth;
+ rendererParameters.height = textParameters.textHeight;
rendererParameters.pixelFormat = TextAbstraction::TextRenderer::Parameters::RGBA8888; // @note: At the moment all textures are generated RGBA8888
-
////////////////////////////////////////////////////////////////////////////////
// Process the markup string if the mark-up processor is enabled.
////////////////////////////////////////////////////////////////////////////////
- ShapeTextPreprocess( textParameters, rendererParameters, internalData );
+ ShapeTextPreprocess(textParameters, rendererParameters, internalData);
////////////////////////////////////////////////////////////////////////////////
// Retrieve the glyphs. Text shaping
////////////////////////////////////////////////////////////////////////////////
- ShapeText( rendererParameters, embeddedItemLayout, internalData );
-
+ ShapeText(rendererParameters, embeddedItemLayout, internalData);
////////////////////////////////////////////////////////////////////////////////
// Retrieve the glyph's metrics.
////////////////////////////////////////////////////////////////////////////////
- metrics->GetGlyphMetrics( rendererParameters.glyphs.Begin(), internalData.numberOfGlyphs );
+ metrics->GetGlyphMetrics(rendererParameters.glyphs.Begin(), internalData.numberOfGlyphs);
////////////////////////////////////////////////////////////////////////////////
// Set the color runs in glyphs.
////////////////////////////////////////////////////////////////////////////////
- SetColorSegmentation( textParameters, internalData );
-
+ SetColorSegmentation(textParameters, internalData);
////////////////////////////////////////////////////////////////////////////////
// Set the isEmoji Vector
////////////////////////////////////////////////////////////////////////////////
- SetEmojiVector( internalData );
+ SetEmojiVector(internalData);
////////////////////////////////////////////////////////////////////////////////
// Layout the text
////////////////////////////////////////////////////////////////////////////////
- Size newLayoutSize = LayoutText( textParameters, rendererParameters, embeddedItemLayout, internalData );
+ Size newLayoutSize = LayoutText(textParameters, rendererParameters, embeddedItemLayout, internalData);
////////////////////////////////////////////////////////////////////////////////
// Align the text.
////////////////////////////////////////////////////////////////////////////////
- Align( textParameters, rendererParameters, embeddedItemLayout, internalData, newLayoutSize );
-
+ Align(textParameters, rendererParameters, embeddedItemLayout, internalData, newLayoutSize);
////////////////////////////////////////////////////////////////////////////////
// Ellipsis the text.
////////////////////////////////////////////////////////////////////////////////
- Ellipsis( textParameters, rendererParameters, embeddedItemLayout, internalData );
+ Ellipsis(textParameters, rendererParameters, embeddedItemLayout, internalData);
////////////////////////////////////////////////////////////////////////////////
// Render the text.
////////////////////////////////////////////////////////////////////////////////
- return RenderText( textParameters, rendererParameters );
+ return RenderText(textParameters, rendererParameters);
}
-
-Devel::PixelBuffer CreateShadow( const ShadowParameters& shadowParameters )
+Devel::PixelBuffer CreateShadow(const ShadowParameters& shadowParameters)
{
// The size of the pixel data.
- const int width = static_cast<int>(shadowParameters.input.GetWidth());
+ const int width = static_cast<int>(shadowParameters.input.GetWidth());
const int height = static_cast<int>(shadowParameters.input.GetHeight());
// The shadow's offset.
- const int xOffset = static_cast<int>( shadowParameters.offset.x );
- const int yOffset = static_cast<int>( shadowParameters.offset.y );
+ const int xOffset = static_cast<int>(shadowParameters.offset.x);
+ const int yOffset = static_cast<int>(shadowParameters.offset.y);
// The size in bytes of the pixel of the input's buffer.
- const Pixel::Format inputFormat = shadowParameters.input.GetPixelFormat();
- const unsigned int inputPixelSize = Pixel::GetBytesPerPixel( inputFormat );
- const bool isA8 = Pixel::A8 == inputFormat;
+ const Pixel::Format inputFormat = shadowParameters.input.GetPixelFormat();
+ const unsigned int inputPixelSize = Pixel::GetBytesPerPixel(inputFormat);
+ const bool isA8 = Pixel::A8 == inputFormat;
// Creates the output pixel buffer.
Devel::PixelBuffer outputPixelBuffer = Devel::PixelBuffer::New(width, height, Pixel::RGBA8888);
const unsigned char* const inputPixelBuffer = shadowParameters.input.GetBuffer();
float textColor[4u];
- if (isA8)
+ if(isA8)
{
memcpy(textColor, shadowParameters.textColor.AsFloat(), 4u * sizeof(float));
}
const float* const shadowColor = shadowParameters.color.AsFloat();
// Traverse the input pixel buffer and write the text on the foreground and the shadow on the background.
- for (int rowIndex = 0; rowIndex < height; ++rowIndex)
+ for(int rowIndex = 0; rowIndex < height; ++rowIndex)
{
// Calculates the rowIndex to the input pixel buffer for the shadow and whether it's within the boundaries.
- const int yOffsetIndex = rowIndex - yOffset;
+ const int yOffsetIndex = rowIndex - yOffset;
const bool isValidRowIndex = ((yOffsetIndex >= 0) && (yOffsetIndex < height));
- const int rows = rowIndex * width;
+ const int rows = rowIndex * width;
const int offsetRows = yOffsetIndex * width;
- for (int columnIndex = 0; columnIndex < width; ++columnIndex)
+ for(int columnIndex = 0; columnIndex < width; ++columnIndex)
{
// Index to the input buffer to retrieve the alpha value of the foreground text.
const unsigned int index = inputPixelSize * static_cast<unsigned int>(rows + columnIndex);
// Build the index to the input buffer to retrieve the alpha value of the background shadow.
- unsigned int shadowIndex = 0u;
- bool isValidShadowIndex = false;
- if (isValidRowIndex)
+ unsigned int shadowIndex = 0u;
+ bool isValidShadowIndex = false;
+ if(isValidRowIndex)
{
const int xOffsetIndex = columnIndex - xOffset;
- isValidShadowIndex = ((xOffsetIndex >= 0) && (xOffsetIndex < width));
+ isValidShadowIndex = ((xOffsetIndex >= 0) && (xOffsetIndex < width));
- if (isValidShadowIndex)
+ if(isValidShadowIndex)
{
shadowIndex = inputPixelSize * static_cast<unsigned int>(offsetRows + xOffsetIndex);
}
// If the input buffer is an alpha mask, retrieve the values for the foreground text and the background shadow.
// If not retrieve the color.
float inputShadowOffsetAlphaValue = 1.f;
- float inputAlphaValue = 1.f;
- if (isA8)
+ float inputAlphaValue = 1.f;
+ if(isA8)
{
// Retrieve the alpha value for the shadow.
inputShadowOffsetAlphaValue = isValidShadowIndex ? (static_cast<float>(*(inputPixelBuffer + shadowIndex)) / 255.f) : 0.f;
else
{
// The input buffer is not an alpha mask. Retrieve the color.
- textColor[0u] = TO_FLOAT * static_cast<float>( *(inputPixelBuffer + index + 0u) );
- textColor[1u] = TO_FLOAT * static_cast<float>( *(inputPixelBuffer + index + 1u) );
- textColor[2u] = TO_FLOAT * static_cast<float>( *(inputPixelBuffer + index + 2u) );
- textColor[3u] = TO_FLOAT * static_cast<float>( *(inputPixelBuffer + index + 3u) );
- inputAlphaValue = textColor[3u];
- inputShadowOffsetAlphaValue = isValidShadowIndex ? TO_FLOAT * static_cast<float>( *(inputPixelBuffer + shadowIndex + 3u) ) : 0.f;
+ textColor[0u] = TO_FLOAT * static_cast<float>(*(inputPixelBuffer + index + 0u));
+ textColor[1u] = TO_FLOAT * static_cast<float>(*(inputPixelBuffer + index + 1u));
+ textColor[2u] = TO_FLOAT * static_cast<float>(*(inputPixelBuffer + index + 2u));
+ textColor[3u] = TO_FLOAT * static_cast<float>(*(inputPixelBuffer + index + 3u));
+ inputAlphaValue = textColor[3u];
+ inputShadowOffsetAlphaValue = isValidShadowIndex ? TO_FLOAT * static_cast<float>(*(inputPixelBuffer + shadowIndex + 3u)) : 0.f;
}
// Build the output color.
float outputColor[4u];
- if( shadowParameters.blendShadow )
+ if(shadowParameters.blendShadow)
{
// Blend the shadow's color with the text's color on top
- const float textAlpha = textColor[3u] * inputAlphaValue;
+ const float textAlpha = textColor[3u] * inputAlphaValue;
const float shadowAlpha = shadowColor[3u] * inputShadowOffsetAlphaValue;
// Blends the alpha.
- outputColor[3u] = 1.f - ((1.f - textAlpha) * (1.f - shadowAlpha));
+ outputColor[3u] = 1.f - ((1.f - textAlpha) * (1.f - shadowAlpha));
const bool isOutputAlphaZero = outputColor[3u] < Dali::Math::MACHINE_EPSILON_1000;
- if( isOutputAlphaZero )
+ if(isOutputAlphaZero)
{
- std::fill( outputColor, outputColor + 4u, 0.f );
+ std::fill(outputColor, outputColor + 4u, 0.f);
}
else
{
// Blends the RGB components.
float shadowComponent = 0.f;
- float textComponent = 0.f;
+ float textComponent = 0.f;
shadowComponent = shadowColor[0u] * inputShadowOffsetAlphaValue;
- textComponent = textColor[0u] * inputAlphaValue;
- outputColor[0u] = (textComponent * textAlpha / outputColor[3u]) + (shadowComponent * shadowAlpha * (1.f - textAlpha) / outputColor[3u]);
+ textComponent = textColor[0u] * inputAlphaValue;
+ outputColor[0u] = (textComponent * textAlpha / outputColor[3u]) + (shadowComponent * shadowAlpha * (1.f - textAlpha) / outputColor[3u]);
shadowComponent = shadowColor[1u] * inputShadowOffsetAlphaValue;
- textComponent = textColor[1u] * inputAlphaValue;
- outputColor[1u] = (textComponent * textAlpha / outputColor[3u]) + (shadowComponent * shadowAlpha * (1.f - textAlpha) / outputColor[3u]);
+ textComponent = textColor[1u] * inputAlphaValue;
+ outputColor[1u] = (textComponent * textAlpha / outputColor[3u]) + (shadowComponent * shadowAlpha * (1.f - textAlpha) / outputColor[3u]);
shadowComponent = shadowColor[2u] * inputShadowOffsetAlphaValue;
- textComponent = textColor[2u] * inputAlphaValue;
- outputColor[2u] = (textComponent * textAlpha / outputColor[3u]) + (shadowComponent * shadowAlpha * (1.f - textAlpha) / outputColor[3u]);
+ textComponent = textColor[2u] * inputAlphaValue;
+ outputColor[2u] = (textComponent * textAlpha / outputColor[3u]) + (shadowComponent * shadowAlpha * (1.f - textAlpha) / outputColor[3u]);
}
}
else
{
// No blending!!!
- std::fill( outputColor, outputColor + 4u, 0.f );
+ std::fill(outputColor, outputColor + 4u, 0.f);
- const float textAlpha = textColor[3u];
+ const float textAlpha = textColor[3u];
const float shadowAlpha = shadowColor[3u] * inputShadowOffsetAlphaValue;
// Write shadow first.
- if( shadowAlpha > Dali::Math::MACHINE_EPSILON_1000 )
+ if(shadowAlpha > Dali::Math::MACHINE_EPSILON_1000)
{
outputColor[0u] = shadowColor[0u] * inputShadowOffsetAlphaValue;
outputColor[1u] = shadowColor[1u] * inputShadowOffsetAlphaValue;
}
// Write character on top.
- if( textAlpha > Dali::Math::MACHINE_EPSILON_1000 )
+ if(textAlpha > Dali::Math::MACHINE_EPSILON_1000)
{
outputColor[0u] = textColor[0u];
outputColor[1u] = textColor[1u];
}
// Write the color into the output pixel buffer.
- const unsigned int outputIndex = 4u * (rows + columnIndex);
- *(outputPixelBufferPtr + outputIndex + 0u) = static_cast<unsigned char>( TO_UCHAR * outputColor[0u] );
- *(outputPixelBufferPtr + outputIndex + 1u) = static_cast<unsigned char>( TO_UCHAR * outputColor[1u] );
- *(outputPixelBufferPtr + outputIndex + 2u) = static_cast<unsigned char>( TO_UCHAR * outputColor[2u] );
- *(outputPixelBufferPtr + outputIndex + 3u) = static_cast<unsigned char>( TO_UCHAR * outputColor[3u] );
+ const unsigned int outputIndex = 4u * (rows + columnIndex);
+ *(outputPixelBufferPtr + outputIndex + 0u) = static_cast<unsigned char>(TO_UCHAR * outputColor[0u]);
+ *(outputPixelBufferPtr + outputIndex + 1u) = static_cast<unsigned char>(TO_UCHAR * outputColor[1u]);
+ *(outputPixelBufferPtr + outputIndex + 2u) = static_cast<unsigned char>(TO_UCHAR * outputColor[2u]);
+ *(outputPixelBufferPtr + outputIndex + 3u) = static_cast<unsigned char>(TO_UCHAR * outputColor[3u]);
}
}
Devel::PixelBuffer ConvertToRgba8888(Devel::PixelBuffer pixelBuffer, const Vector4& color, bool multiplyByAlpha)
{
- if (Dali::Pixel::A8 != pixelBuffer.GetPixelFormat())
+ if(Dali::Pixel::A8 != pixelBuffer.GetPixelFormat())
{
// Does nothing.
return pixelBuffer;
}
- const unsigned int width = pixelBuffer.GetWidth();
- const unsigned int height = pixelBuffer.GetHeight();
- Devel::PixelBuffer newPixelBuffer = Devel::PixelBuffer::New( width, height, Dali::Pixel::RGBA8888 );
+ const unsigned int width = pixelBuffer.GetWidth();
+ const unsigned int height = pixelBuffer.GetHeight();
+ Devel::PixelBuffer newPixelBuffer = Devel::PixelBuffer::New(width, height, Dali::Pixel::RGBA8888);
- unsigned char* dstBuffer = newPixelBuffer.GetBuffer();
+ unsigned char* dstBuffer = newPixelBuffer.GetBuffer();
const unsigned char* const srcBuffer = pixelBuffer.GetBuffer();
- const unsigned char r = static_cast<unsigned char>( TO_UCHAR * color.r );
- const unsigned char g = static_cast<unsigned char>( TO_UCHAR * color.g );
- const unsigned char b = static_cast<unsigned char>( TO_UCHAR * color.b );
+ const unsigned char r = static_cast<unsigned char>(TO_UCHAR * color.r);
+ const unsigned char g = static_cast<unsigned char>(TO_UCHAR * color.g);
+ const unsigned char b = static_cast<unsigned char>(TO_UCHAR * color.b);
unsigned char dstColor[4];
- for( unsigned int j = 0u; j < height; ++j )
+ for(unsigned int j = 0u; j < height; ++j)
{
const unsigned int lineIndex = j * width;
- for( unsigned int i=0u; i < width; ++i )
+ for(unsigned int i = 0u; i < width; ++i)
{
const unsigned int srcIndex = lineIndex + i;
- const float srcAlpha = static_cast<float>( *( srcBuffer + srcIndex ) );
+ const float srcAlpha = static_cast<float>(*(srcBuffer + srcIndex));
- if( multiplyByAlpha )
+ if(multiplyByAlpha)
{
- dstColor[0u] = static_cast<unsigned char>( srcAlpha * color.r );
- dstColor[1u] = static_cast<unsigned char>( srcAlpha * color.g );
- dstColor[2u] = static_cast<unsigned char>( srcAlpha * color.b );
- dstColor[3u] = static_cast<unsigned char>( srcAlpha * color.a );
+ dstColor[0u] = static_cast<unsigned char>(srcAlpha * color.r);
+ dstColor[1u] = static_cast<unsigned char>(srcAlpha * color.g);
+ dstColor[2u] = static_cast<unsigned char>(srcAlpha * color.b);
+ dstColor[3u] = static_cast<unsigned char>(srcAlpha * color.a);
}
else
{
dstColor[0u] = r;
dstColor[1u] = g;
dstColor[2u] = b;
- dstColor[3u] = static_cast<unsigned char>( srcAlpha );
+ dstColor[3u] = static_cast<unsigned char>(srcAlpha);
}
const unsigned int dstIndex = srcIndex * 4u;
- memcpy( dstBuffer + dstIndex, dstColor, 4u );
+ memcpy(dstBuffer + dstIndex, dstColor, 4u);
}
}
void UpdateBuffer(Devel::PixelBuffer src, Devel::PixelBuffer dst, unsigned int x, unsigned int y, bool blend)
{
const Dali::Pixel::Format pixelFormat = dst.GetPixelFormat();
- if( src.GetPixelFormat() != pixelFormat )
+ if(src.GetPixelFormat() != pixelFormat)
{
DALI_LOG_ERROR("PixelBuffer::SetBuffer. The pixel format of the new data must be the same of the current pixel buffer.");
return;
}
- const unsigned int srcWidth = src.GetWidth();
+ const unsigned int srcWidth = src.GetWidth();
const unsigned int srcHeight = src.GetHeight();
- const unsigned int dstWidth = dst.GetWidth();
+ const unsigned int dstWidth = dst.GetWidth();
const unsigned int dstHeight = dst.GetHeight();
- if( ( x > dstWidth ) ||
- ( y > dstHeight ) ||
- ( x + srcWidth > dstWidth ) ||
- ( y + srcHeight > dstHeight ) )
+ if((x > dstWidth) ||
+ (y > dstHeight) ||
+ (x + srcWidth > dstWidth) ||
+ (y + srcHeight > dstHeight))
{
DALI_LOG_ERROR("PixelBuffer::SetBuffer. The source pixel buffer is out of the boundaries of the destination pixel buffer.");
return;
}
const unsigned int bytesPerPixel = Dali::Pixel::GetBytesPerPixel(pixelFormat);
- if( bytesPerPixel == 0u || bytesPerPixel == 12u || bytesPerPixel == 24u )
+ if(bytesPerPixel == 0u || bytesPerPixel == 12u || bytesPerPixel == 24u)
{
return;
}
const unsigned int alphaIndex = bytesPerPixel - 1u;
const unsigned char* const srcBuffer = src.GetBuffer();
- unsigned char* dstBuffer = dst.GetBuffer();
+ unsigned char* dstBuffer = dst.GetBuffer();
- if( !blend )
+ if(!blend)
{
const unsigned int currentLineSize = dstWidth * bytesPerPixel;
- const unsigned int newLineSize = srcWidth * bytesPerPixel;
- unsigned char* currentBuffer = dstBuffer + (y * dstWidth + x) * bytesPerPixel;
- for (unsigned int j = 0u; j < srcHeight; ++j)
+ const unsigned int newLineSize = srcWidth * bytesPerPixel;
+ unsigned char* currentBuffer = dstBuffer + (y * dstWidth + x) * bytesPerPixel;
+ for(unsigned int j = 0u; j < srcHeight; ++j)
{
memcpy(currentBuffer + j * currentLineSize, srcBuffer + j * newLineSize, newLineSize);
}
// Jump till the 'x,y' position
const unsigned int dstWidthBytes = dstWidth * bytesPerPixel;
- dstBuffer += ( y * dstWidthBytes + x * bytesPerPixel );
+ dstBuffer += (y * dstWidthBytes + x * bytesPerPixel);
- for (unsigned int j = 0u; j < srcHeight; ++j)
+ for(unsigned int j = 0u; j < srcHeight; ++j)
{
const unsigned int srcLineIndex = j * srcWidth;
- for (unsigned int i = 0u; i < srcWidth; ++i)
+ for(unsigned int i = 0u; i < srcWidth; ++i)
{
- const float srcAlpha = TO_FLOAT * static_cast<float>( *( srcBuffer + bytesPerPixel * ( srcLineIndex + i ) + alphaIndex ) );
- const float dstAlpha = TO_FLOAT * static_cast<float>( *(dstBuffer + i*bytesPerPixel + alphaIndex) );
+ const float srcAlpha = TO_FLOAT * static_cast<float>(*(srcBuffer + bytesPerPixel * (srcLineIndex + i) + alphaIndex));
+ const float dstAlpha = TO_FLOAT * static_cast<float>(*(dstBuffer + i * bytesPerPixel + alphaIndex));
// Blends the alpha channel.
const float oneMinusSrcAlpha = 1.f - srcAlpha;
- outputColor[alphaIndex] = 1.f - (oneMinusSrcAlpha * (1.f - dstAlpha));
+ outputColor[alphaIndex] = 1.f - (oneMinusSrcAlpha * (1.f - dstAlpha));
// Blends the RGB channels.
const bool isOutputAlphaZero = outputColor[alphaIndex] < Dali::Math::MACHINE_EPSILON_1000;
- if( isOutputAlphaZero )
+ if(isOutputAlphaZero)
{
- std::fill( outputColor, outputColor + bytesPerPixel, 0.f );
+ std::fill(outputColor, outputColor + bytesPerPixel, 0.f);
}
else
{
- const float srcAlphaOverOutputAlpha = srcAlpha / outputColor[alphaIndex]; // fgAlpha / alpha
+ const float srcAlphaOverOutputAlpha = srcAlpha / outputColor[alphaIndex]; // fgAlpha / alpha
const float dstAlphaOneMinusSrcAlphaOverOutputAlpha = dstAlpha * oneMinusSrcAlpha / outputColor[alphaIndex]; // bgAlpha * ( 1 - fgAlpha ) / alpha
- for (unsigned int index = 0u; index < alphaIndex; ++index)
+ for(unsigned int index = 0u; index < alphaIndex; ++index)
{
- const float dstComponent = TO_FLOAT * static_cast<float>( *( dstBuffer + i * bytesPerPixel + index ) ) * dstAlpha;
- const float srcComponent = TO_FLOAT * static_cast<float>(*(srcBuffer + bytesPerPixel * (srcLineIndex + i) + index) ) * srcAlpha;
- outputColor[index] = ( srcComponent * srcAlphaOverOutputAlpha ) + ( dstComponent * dstAlphaOneMinusSrcAlphaOverOutputAlpha );
+ const float dstComponent = TO_FLOAT * static_cast<float>(*(dstBuffer + i * bytesPerPixel + index)) * dstAlpha;
+ const float srcComponent = TO_FLOAT * static_cast<float>(*(srcBuffer + bytesPerPixel * (srcLineIndex + i) + index)) * srcAlpha;
+ outputColor[index] = (srcComponent * srcAlphaOverOutputAlpha) + (dstComponent * dstAlphaOneMinusSrcAlphaOverOutputAlpha);
}
}
- for (unsigned int index = 0u; index < bytesPerPixel; ++index)
+ for(unsigned int index = 0u; index < bytesPerPixel; ++index)
{
- *(dstBuffer + i * bytesPerPixel + index) = static_cast<unsigned char>( TO_UCHAR * outputColor[index] );
+ *(dstBuffer + i * bytesPerPixel + index) = static_cast<unsigned char>(TO_UCHAR * outputColor[index]);
}
}
}
}
-
-Dali::Property::Array RenderForLastIndex( RendererParameters& textParameters )
+Dali::Property::Array RenderForLastIndex(RendererParameters& textParameters)
{
Property::Array offsetValues;
- if( textParameters.text.empty() )
+ if(textParameters.text.empty())
{
return offsetValues;
}
FontClient fontClient = FontClient::Get();
MetricsPtr metrics;
- metrics = Metrics::New( fontClient );
-
- Text::ModelPtr textModel = Text::Model::New();
- InternalDataModel internalData( fontClient, metrics, textModel );
+ metrics = Metrics::New(fontClient);
- TextAbstraction::TextRenderer::Parameters rendererParameters( textModel->mVisualModel->mGlyphs,
- textModel->mVisualModel->mGlyphPositions,
- textModel->mVisualModel->mColors,
- textModel->mVisualModel->mColorIndices,
- internalData.blendingMode,
- internalData.isEmoji );
+ Text::ModelPtr textModel = Text::Model::New();
+ InternalDataModel internalData(fontClient, metrics, textModel);
+ TextAbstraction::TextRenderer::Parameters rendererParameters(textModel->mVisualModel->mGlyphs,
+ textModel->mVisualModel->mGlyphPositions,
+ textModel->mVisualModel->mColors,
+ textModel->mVisualModel->mColorIndices,
+ internalData.blendingMode,
+ internalData.isEmoji);
- rendererParameters.width = textParameters.textWidth;
+ rendererParameters.width = textParameters.textWidth;
rendererParameters.height = textParameters.textHeight;
////////////////////////////////////////////////////////////////////////////////
// Process the markup string if the mark-up processor is enabled.
////////////////////////////////////////////////////////////////////////////////
- ShapeTextPreprocess( textParameters, rendererParameters, internalData );
+ ShapeTextPreprocess(textParameters, rendererParameters, internalData);
////////////////////////////////////////////////////////////////////////////////
// Retrieve the glyphs. Text shaping
////////////////////////////////////////////////////////////////////////////////
Dali::Vector<Dali::Toolkit::DevelText::EmbeddedItemInfo> embeddedItemLayout;
- ShapeText( rendererParameters, embeddedItemLayout, internalData );
-
+ ShapeText(rendererParameters, embeddedItemLayout, internalData);
////////////////////////////////////////////////////////////////////////////////
// Retrieve the glyph's metrics.
////////////////////////////////////////////////////////////////////////////////
- metrics->GetGlyphMetrics( rendererParameters.glyphs.Begin(), internalData.numberOfGlyphs );
-
+ metrics->GetGlyphMetrics(rendererParameters.glyphs.Begin(), internalData.numberOfGlyphs);
////////////////////////////////////////////////////////////////////////////////
// Layout the text
////////////////////////////////////////////////////////////////////////////////
- int boundingBox = textParameters.textHeight;
+ int boundingBox = textParameters.textHeight;
textParameters.textHeight = MAX_INT; // layout for the entire area.
- LayoutText( textParameters, rendererParameters, embeddedItemLayout, internalData );
+ LayoutText(textParameters, rendererParameters, embeddedItemLayout, internalData);
////////////////////////////////////////////////////////////////////////////////
// Calculation last character index
////////////////////////////////////////////////////////////////////////////////
- Vector<LineRun>& lines = internalData.textModel->mVisualModel->mLines;
- unsigned int numberOfLines = lines.Count();
- int numberOfCharacters = 0;
- float penY = 0.f;
- float lineSize = internalData.layoutEngine.GetDefaultLineSize();
- float lineOffset = 0.f;
- for( unsigned int index = 0u; index < numberOfLines; ++index )
+ Vector<LineRun>& lines = internalData.textModel->mVisualModel->mLines;
+ unsigned int numberOfLines = lines.Count();
+ int numberOfCharacters = 0;
+ float penY = 0.f;
+ float lineSize = internalData.layoutEngine.GetDefaultLineSize();
+ float lineOffset = 0.f;
+ for(unsigned int index = 0u; index < numberOfLines; ++index)
{
- const LineRun& line = *( lines.Begin() + index );
+ const LineRun& line = *(lines.Begin() + index);
numberOfCharacters += line.characterRun.numberOfCharacters;
- lineOffset = lineSize > 0.f ? lineSize : ( line.ascender + -line.descender );
+ lineOffset = lineSize > 0.f ? lineSize : (line.ascender + -line.descender);
penY += lineOffset;
- if( ( penY + lineOffset ) > boundingBox )
+ if((penY + lineOffset) > boundingBox)
{
- offsetValues.PushBack( numberOfCharacters );
+ offsetValues.PushBack(numberOfCharacters);
penY = 0.f;
}
}
- if( penY > 0.f)
+ if(penY > 0.f)
{
// add remain character index
- offsetValues.PushBack( numberOfCharacters );
+ offsetValues.PushBack(numberOfCharacters);
}
return offsetValues;
}
-
-Dali::Property::Array GetLastCharacterIndex( RendererParameters& textParameters )
+Dali::Property::Array GetLastCharacterIndex(RendererParameters& textParameters)
{
- Dali::Property::Array offsetValues = Toolkit::DevelText::RenderForLastIndex( textParameters );
+ Dali::Property::Array offsetValues = Toolkit::DevelText::RenderForLastIndex(textParameters);
return offsetValues;
}
-
} // namespace DevelText
} // namespace Toolkit
#define DALI_TOOLKIT_TEXT_UTILS_DEVEL_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/object/property-array.h>
#include <dali-toolkit/public-api/dali-toolkit-common.h>
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
#include <dali/devel-api/text-abstraction/text-abstraction-definitions.h>
+#include <dali/public-api/object/property-array.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelText
{
-
/**
* @brief Struct with the text and style parameters to be rendered into a pixel buffer.
*/
{
RendererParameters()
: text{},
- horizontalAlignment{ "begin" },
- verticalAlignment{ "top" },
+ horizontalAlignment{"begin"},
+ verticalAlignment{"top"},
fontFamily{},
fontWeight{},
fontWidth{},
fontSlant{},
- layout{ "singleLine" },
- circularAlignment{ "begin" },
- textColor{ Color::WHITE },
- fontSize{ 0.f },
- textWidth{ 0u },
- textHeight{ 0u },
- radius{ 0u },
- beginAngle{ 0.f },
- incrementAngle{ 0.f },
- ellipsisEnabled{ true },
- markupEnabled{ false },
- isTextColorSet{ false },
- minLineSize{ 0.f }
- {}
+ layout{"singleLine"},
+ circularAlignment{"begin"},
+ textColor{Color::WHITE},
+ fontSize{0.f},
+ textWidth{0u},
+ textHeight{0u},
+ radius{0u},
+ beginAngle{0.f},
+ incrementAngle{0.f},
+ ellipsisEnabled{true},
+ markupEnabled{false},
+ isTextColorSet{false},
+ minLineSize{0.f}
+ {
+ }
std::string text; ///< The text to be rendered encoded in utf8.
-
+ //
std::string horizontalAlignment; ///< The horizontal alignment: one of {"begin", "center", "end"}.
std::string verticalAlignment; ///< The vertical alignment: one of {"top", "center", "bottom"}.
-
+ //
std::string fontFamily; ///< The font's family.
std::string fontWeight; ///< The font's weight: one of {"thin", "ultraLight", "extraLight", "light", "demiLight", "semiLight", "book", "normal", "regular", "medium", "demiBold", "semiBold", "bold", "ultraBold", "extraBold", "black", "heavy", "extraBlack"}.
std::string fontWidth; ///< The font's width: one of {"ultraCondensed", "extraCondensed", "condensed", "semiCondensed", "normal", "semiExpanded", "expanded", "extraExpanded", "ultraExpanded"}.
std::string fontSlant; ///< The font's slant. one of {"normal", "roman", "italic", "oblique"}
std::string layout; ///< The type of layout: one of {"singleLine", "multiLine", "circular"}
std::string circularAlignment; ///< The text alignment within the arc: one of {"begin", "center", "end"}. The @p horizontalAlignment and @p verticalAlignment can be used to align the text within the text area.
-
+ //
Vector4 textColor; ///< The default text's color. Default is white.
-
- float fontSize; ///< The font's size (in points).
-
+ //
+ float fontSize; ///< The font's size (in points).
+ //
unsigned int textWidth; ///< The width in pixels of the boundaries where the text is going to be laid-out.
unsigned int textHeight; ///< The height in pixels of the boundaries where the text is going to be laid-out.
-
+ //
unsigned int radius; ///< The radius in pixels of the circular text.
- float beginAngle; ///< The begin angle in degrees of the text area on the circle. The top of the circle is 0°, the right side 90°, the bottom 180° and the left 270°.
- float incrementAngle; ///< The increment angle in degrees of the text area on the circle. The @p incrementAngle defines a direction. If positive, the text will be laid out clockwise.
-
- bool ellipsisEnabled:1; ///< Whether the ellipsis layout option is enabled.
- bool markupEnabled:1; ///< Whether the mark-up processor is enabled.
- bool isTextColorSet:1; ///< Whether a default color has been set.
-
+ float beginAngle; ///< The begin angle in degrees of the text area on the circle. The top of the circle is 0°, the right side 90°, the bottom 180° and the left 270°.
+ float incrementAngle; ///< The increment angle in degrees of the text area on the circle. The @p incrementAngle defines a direction. If positive, the text will be laid out clockwise.
+ //
+ bool ellipsisEnabled : 1; ///< Whether the ellipsis layout option is enabled.
+ bool markupEnabled : 1; ///< Whether the mark-up processor is enabled.
+ bool isTextColorSet : 1; ///< Whether a default color has been set.
+ //
float minLineSize; ///< The line's minimum size (in points).
};
*/
struct DALI_TOOLKIT_API EmbeddedItemInfo
{
- TextAbstraction::CharacterIndex characterIndex; ///< Index to the character within the string.
- TextAbstraction::GlyphIndex glyphIndex; ///< Index to the glyph
- Vector2 position; ///< The layout position within the buffer (top, left corner).
- Size size; ///< The size within the buffer of the embedded item.
- Size rotatedSize; ///< The rotated size within the buffer of the embedded item.
- Degree angle; ///< Rotation angle of the pixel buffer in degrees.
+ TextAbstraction::CharacterIndex characterIndex; ///< Index to the character within the string.
+ TextAbstraction::GlyphIndex glyphIndex; ///< Index to the glyph
+ Vector2 position; ///< The layout position within the buffer (top, left corner).
+ Size size; ///< The size within the buffer of the embedded item.
+ Size rotatedSize; ///< The rotated size within the buffer of the embedded item.
+ Degree angle; ///< Rotation angle of the pixel buffer in degrees.
TextAbstraction::ColorBlendingMode colorBlendingMode; ///< Whether the color of the image is multiplied by the color of the text.
};
*/
struct DALI_TOOLKIT_API ShadowParameters
{
- Devel::PixelBuffer input; ///< The input pixel buffer used to create the shadow.
- Vector4 textColor; ///< The color of the text.
- Vector4 color; ///< The color of the shadow.
- Vector2 offset; ///< The offset of the shadow.
- bool blendShadow; ///< Whether to blend the shadow.
+ Devel::PixelBuffer input; ///< The input pixel buffer used to create the shadow.
+ Vector4 textColor; ///< The color of the text.
+ Vector4 color; ///< The color of the shadow.
+ Vector2 offset; ///< The offset of the shadow.
+ bool blendShadow; ///< Whether to blend the shadow.
};
/**
*
* @return A pixel buffer with the text rendered on it.
*/
-DALI_TOOLKIT_API Devel::PixelBuffer Render( const RendererParameters& textParameters, Vector<EmbeddedItemInfo>& embeddedItemLayout );
+DALI_TOOLKIT_API Devel::PixelBuffer Render(const RendererParameters& textParameters, Vector<EmbeddedItemInfo>& embeddedItemLayout);
/**
* @brief Creates a shadow for the text given in the input pixel buffer.
*
* @return The pixel buffer converted to RGBA8888.
*/
-DALI_TOOLKIT_API Devel::PixelBuffer ConvertToRgba8888( Devel::PixelBuffer pixelBuffer, const Vector4& color, bool multiplyByAlpha );
+DALI_TOOLKIT_API Devel::PixelBuffer ConvertToRgba8888(Devel::PixelBuffer pixelBuffer, const Vector4& color, bool multiplyByAlpha);
/**
* @brief Updates the @p dst pixel buffer with the data from @p src pixel buffer.
* @param[in] y The top left corner's y within the destination pixel buffer.
* @param[in] blend Whether to blend the source pixel buffer with the destination pixel buffer as background.
*/
-DALI_TOOLKIT_API void UpdateBuffer( Devel::PixelBuffer src, Devel::PixelBuffer dst, unsigned int x, unsigned int y, bool blend);
+DALI_TOOLKIT_API void UpdateBuffer(Devel::PixelBuffer src, Devel::PixelBuffer dst, unsigned int x, unsigned int y, bool blend);
/**
* @brief Splits the text in pages of the size given in @p textParameters
* @note The returned indices are indices to utf32 characters. The input text is encoded in utf8.
* @return An array with the indices of the last character of each page
*/
-DALI_TOOLKIT_API Dali::Property::Array GetLastCharacterIndex( RendererParameters& textParameters );
+DALI_TOOLKIT_API Dali::Property::Array GetLastCharacterIndex(RendererParameters& textParameters);
} // namespace DevelText
#define DALI_DEVEL_TOOLKIT_PROPERTY_INDEX_RANGES_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @brief Enumeration for the start and end property ranges.
*/
enum DevelPropertyRanges
{
- LAYOUT_GROUP_CHILD_PROPERTY_START_INDEX = CHILD_PROPERTY_REGISTRATION_START_INDEX + 1000, ///< Layout Group Property Start Index.
- LAYOUT_GROUP_CHILD_PROPERTY_END_INDEX = LAYOUT_GROUP_CHILD_PROPERTY_START_INDEX + 999, ///< Layout Group Property End Index.
- LINEAR_LAYOUT_CHILD_PROPERTY_START_INDEX = LAYOUT_GROUP_CHILD_PROPERTY_END_INDEX + 1, ///< Linear Layout Property Start Index.
- LINEAR_LAYOUT_CHILD_PROPERTY_END_INDEX = LINEAR_LAYOUT_CHILD_PROPERTY_START_INDEX + 999, ///< Linear Layout Property End Index.
- GRID_LAYOUT_CHILD_PROPERTY_START_INDEX = LINEAR_LAYOUT_CHILD_PROPERTY_END_INDEX + 1, ///< Grid Layout Property Start Index.
- GRID_LAYOUT_CHILD_PROPERTY_END_INDEX = GRID_LAYOUT_CHILD_PROPERTY_START_INDEX + 999, ///< Grid Layout Property End Index.
- FLEX_LAYOUT_CHILD_PROPERTY_START_INDEX = GRID_LAYOUT_CHILD_PROPERTY_END_INDEX + 1, ///< Flex Layout Property Start Index.
- FLEX_LAYOUT_CHILD_PROPERTY_END_INDEX = FLEX_LAYOUT_CHILD_PROPERTY_START_INDEX + 999, ///< Flex Layout Property End Index.
- ABSOLUTE_LAYOUT_CHILD_PROPERTY_START_INDEX = FLEX_LAYOUT_CHILD_PROPERTY_END_INDEX +1, ///< Absolute Layout Property Start Index.
- ABSOLUTE_LAYOUT_CHILD_PROPERTY_END_INDEX = ABSOLUTE_LAYOUT_CHILD_PROPERTY_START_INDEX + 999, ///< Absolute Layout Property End Index.
+ LAYOUT_GROUP_CHILD_PROPERTY_START_INDEX = CHILD_PROPERTY_REGISTRATION_START_INDEX + 1000, ///< Layout Group Property Start Index.
+ LAYOUT_GROUP_CHILD_PROPERTY_END_INDEX = LAYOUT_GROUP_CHILD_PROPERTY_START_INDEX + 999, ///< Layout Group Property End Index.
+ LINEAR_LAYOUT_CHILD_PROPERTY_START_INDEX = LAYOUT_GROUP_CHILD_PROPERTY_END_INDEX + 1, ///< Linear Layout Property Start Index.
+ LINEAR_LAYOUT_CHILD_PROPERTY_END_INDEX = LINEAR_LAYOUT_CHILD_PROPERTY_START_INDEX + 999, ///< Linear Layout Property End Index.
+ GRID_LAYOUT_CHILD_PROPERTY_START_INDEX = LINEAR_LAYOUT_CHILD_PROPERTY_END_INDEX + 1, ///< Grid Layout Property Start Index.
+ GRID_LAYOUT_CHILD_PROPERTY_END_INDEX = GRID_LAYOUT_CHILD_PROPERTY_START_INDEX + 999, ///< Grid Layout Property End Index.
+ FLEX_LAYOUT_CHILD_PROPERTY_START_INDEX = GRID_LAYOUT_CHILD_PROPERTY_END_INDEX + 1, ///< Flex Layout Property Start Index.
+ FLEX_LAYOUT_CHILD_PROPERTY_END_INDEX = FLEX_LAYOUT_CHILD_PROPERTY_START_INDEX + 999, ///< Flex Layout Property End Index.
+ ABSOLUTE_LAYOUT_CHILD_PROPERTY_START_INDEX = FLEX_LAYOUT_CHILD_PROPERTY_END_INDEX + 1, ///< Absolute Layout Property Start Index.
+ ABSOLUTE_LAYOUT_CHILD_PROPERTY_END_INDEX = ABSOLUTE_LAYOUT_CHILD_PROPERTY_START_INDEX + 999, ///< Absolute Layout Property End Index.
};
} // namespace Toolkit
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
-CubeTransitionCrossEffect::CubeTransitionCrossEffect( Internal::CubeTransitionCrossEffect& implementation )
-: CubeTransitionEffect( implementation )
+CubeTransitionCrossEffect::CubeTransitionCrossEffect(Internal::CubeTransitionCrossEffect& implementation)
+: CubeTransitionEffect(implementation)
{
}
-CubeTransitionCrossEffect::CubeTransitionCrossEffect( Dali::Internal::CustomActor* internal )
-: CubeTransitionEffect( internal )
+CubeTransitionCrossEffect::CubeTransitionCrossEffect(Dali::Internal::CustomActor* internal)
+: CubeTransitionEffect(internal)
{
- VerifyCustomActorPointer< Internal::CubeTransitionCrossEffect >( internal );
+ VerifyCustomActorPointer<Internal::CubeTransitionCrossEffect>(internal);
}
-CubeTransitionCrossEffect CubeTransitionCrossEffect::New( unsigned int numRows, unsigned int numColumns )
+CubeTransitionCrossEffect CubeTransitionCrossEffect::New(unsigned int numRows, unsigned int numColumns)
{
- return Internal::CubeTransitionCrossEffect::New( numRows, numColumns );
+ return Internal::CubeTransitionCrossEffect::New(numRows, numColumns);
}
} // namespace Toolkit
#define DALI_TOOLKIT_CUBE_TRANSITION_CROSS_EFFECT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
- /**
+/**
* CubeTransitionCrossEffect implementation class
*/
- class CubeTransitionCrossEffect;
+class CubeTransitionCrossEffect;
-} // namespace Internal
+} // namespace DALI_INTERNAL
/**
* SubClass of CubeTransitionEffect
*/
class DALI_TOOLKIT_API CubeTransitionCrossEffect : public CubeTransitionEffect
{
-
public:
-
/**
* Create an initialized CubeTransitionCrossEffect
* @param[in] numRows How many rows of cubes
* @param[in] numColumns How many columns of cubes
* @return The initialized CubeTransitionCrossEffect object
*/
- static CubeTransitionCrossEffect New( unsigned int numRows, unsigned int numColumns );
-
+ static CubeTransitionCrossEffect New(unsigned int numRows, unsigned int numColumns);
public: // Not intended for developer use
-
/**
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL CubeTransitionCrossEffect( Internal::CubeTransitionCrossEffect& implementation );
+ DALI_INTERNAL CubeTransitionCrossEffect(Internal::CubeTransitionCrossEffect& implementation);
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- DALI_INTERNAL CubeTransitionCrossEffect( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL CubeTransitionCrossEffect(Dali::Internal::CustomActor* internal);
}; // class CubeTransitionCrossEffect
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
CubeTransitionEffect::CubeTransitionEffect()
{
}
{
}
-CubeTransitionEffect::CubeTransitionEffect( Internal::CubeTransitionEffect& implementation )
-: Control( implementation )
+CubeTransitionEffect::CubeTransitionEffect(Internal::CubeTransitionEffect& implementation)
+: Control(implementation)
{
}
-CubeTransitionEffect::CubeTransitionEffect( Dali::Internal::CustomActor* internal )
-: Control( internal )
+CubeTransitionEffect::CubeTransitionEffect(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::CubeTransitionEffect>(internal);
}
-CubeTransitionEffect CubeTransitionEffect::DownCast( BaseHandle handle )
+CubeTransitionEffect CubeTransitionEffect::DownCast(BaseHandle handle)
{
- return Control::DownCast<CubeTransitionEffect, Internal::CubeTransitionEffect>( handle );
+ return Control::DownCast<CubeTransitionEffect, Internal::CubeTransitionEffect>(handle);
}
-void CubeTransitionEffect::SetTransitionDuration( float duration )
+void CubeTransitionEffect::SetTransitionDuration(float duration)
{
- GetImpl(*this).SetTransitionDuration( duration );
+ GetImpl(*this).SetTransitionDuration(duration);
}
float CubeTransitionEffect::GetTransitionDuration() const
return GetImpl(*this).GetTransitionDuration();
}
-void CubeTransitionEffect::SetCubeDisplacement( float displacement )
+void CubeTransitionEffect::SetCubeDisplacement(float displacement)
{
- GetImpl(*this).SetCubeDisplacement( displacement );
+ GetImpl(*this).SetCubeDisplacement(displacement);
}
float CubeTransitionEffect::GetCubeDisplacement() const
return GetImpl(*this).IsTransitioning();
}
-void CubeTransitionEffect::SetCurrentTexture( Texture texture )
+void CubeTransitionEffect::SetCurrentTexture(Texture texture)
{
- GetImpl(*this).SetCurrentTexture( texture );
+ GetImpl(*this).SetCurrentTexture(texture);
}
-void CubeTransitionEffect::SetTargetTexture( Texture texture )
+void CubeTransitionEffect::SetTargetTexture(Texture texture)
{
- GetImpl(*this).SetTargetTexture( texture );
+ GetImpl(*this).SetTargetTexture(texture);
}
-void CubeTransitionEffect::StartTransition( bool toNextImage )
+void CubeTransitionEffect::StartTransition(bool toNextImage)
{
- GetImpl(*this).StartTransition( toNextImage );
+ GetImpl(*this).StartTransition(toNextImage);
}
-void CubeTransitionEffect::StartTransition( Vector2 panPosition, Vector2 panDisplacement )
+void CubeTransitionEffect::StartTransition(Vector2 panPosition, Vector2 panDisplacement)
{
- GetImpl(*this).StartTransition( panPosition, panDisplacement );
+ GetImpl(*this).StartTransition(panPosition, panDisplacement);
}
void CubeTransitionEffect::PauseTransition()
CubeTransitionEffect::TransitionCompletedSignalType& CubeTransitionEffect::TransitionCompletedSignal()
{
- return GetImpl( *this ).TransitionCompletedSignal();
+ return GetImpl(*this).TransitionCompletedSignal();
}
} // namespace Toolkit
#define DALI_TOOLKIT_CUBE_TRANSITION_EFFECT_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
-
/**
* CubeTransitionEffect implementation class
*/
class CubeTransitionEffect;
-} // namespace Internal
+} // namespace DALI_INTERNAL
/**
* CubeTransitionEffect is a base class of custom transition effect on Images
class DALI_TOOLKIT_API CubeTransitionEffect : public Control
{
public:
-
/**
* Create an uninitialized CubeTransitionEffect;
* this can be initialized by New function of its subclass
* @param[in] handle A handle to an object
* @return A handle to a CubeTransitionEffect object or an uninitialized handle
*/
- static CubeTransitionEffect DownCast( BaseHandle handle );
+ static CubeTransitionEffect DownCast(BaseHandle handle);
/**
* Set the duration of transition animation
* @param[in] duration The duration of transition animation
*/
- void SetTransitionDuration( float duration );
+ void SetTransitionDuration(float duration);
/**
* Get the duration of transition animation
* Set the displacement of bouncing animation during cube's rotation
* @param[in] displacement The displacement of bouncing animation
*/
- void SetCubeDisplacement( float displacement );
+ void SetCubeDisplacement(float displacement);
/**
* Get the displacement of bouncing animation during cube's rotation
* if using this same effect continually, only need to set once
* @param[in] texture The current texture
*/
- void SetCurrentTexture( Texture texture );
+ void SetCurrentTexture(Texture texture);
/**
* Set the target texture to transit to
* @param[in] texture The new Texture showing on stage
*/
- void SetTargetTexture( Texture texture );
+ void SetTargetTexture(Texture texture);
/**
* Activate the transition animation with horizontally left/right panGesture
* @pre target image is set
* @param[in] toNextImage Horizontally left panGesture if true, horizontally right if false
*/
- void StartTransition( bool toNextImage = true );
+ void StartTransition(bool toNextImage = true);
/**
* Activate the transition animation with specified panGesture
* @param[in] panPosition The press down position of panGesture
* @param[in] panDisplacement The displacement vector of panGesture
*/
- void StartTransition( Vector2 panPosition, Vector2 panDisplacement );
+ void StartTransition(Vector2 panPosition, Vector2 panDisplacement);
/**
* Pause the transition animation.
void StopTransition();
public: //Signal
-
//Transition animation completed signal
- typedef Signal< void ( CubeTransitionEffect, Texture ) > TransitionCompletedSignalType;
+ typedef Signal<void(CubeTransitionEffect, Texture)> TransitionCompletedSignalType;
/**
* Signal emitted when the transition has completed animation
TransitionCompletedSignalType& TransitionCompletedSignal();
public: // Not intended for developer use
-
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
*
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL CubeTransitionEffect( Internal::CubeTransitionEffect& implementation );
+ DALI_INTERNAL CubeTransitionEffect(Internal::CubeTransitionEffect& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- DALI_INTERNAL CubeTransitionEffect( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL CubeTransitionEffect(Dali::Internal::CustomActor* internal);
}; //class CubeTransitionEffect
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
-CubeTransitionFoldEffect::CubeTransitionFoldEffect( Internal::CubeTransitionFoldEffect& implementation )
-: CubeTransitionEffect( implementation )
+CubeTransitionFoldEffect::CubeTransitionFoldEffect(Internal::CubeTransitionFoldEffect& implementation)
+: CubeTransitionEffect(implementation)
{
}
-CubeTransitionFoldEffect::CubeTransitionFoldEffect( Dali::Internal::CustomActor* internal )
-: CubeTransitionEffect( internal )
+CubeTransitionFoldEffect::CubeTransitionFoldEffect(Dali::Internal::CustomActor* internal)
+: CubeTransitionEffect(internal)
{
- VerifyCustomActorPointer< Internal::CubeTransitionFoldEffect >( internal );
+ VerifyCustomActorPointer<Internal::CubeTransitionFoldEffect>(internal);
}
-CubeTransitionFoldEffect CubeTransitionFoldEffect::New(unsigned int numRows, unsigned int numColumns )
+CubeTransitionFoldEffect CubeTransitionFoldEffect::New(unsigned int numRows, unsigned int numColumns)
{
- return Internal::CubeTransitionFoldEffect::New( numRows, numColumns );
+ return Internal::CubeTransitionFoldEffect::New(numRows, numColumns);
}
} // namespace Toolkit
#define DALI_TOOLKIT_CUBE_TRANSITION_FOLD_EFFECT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
- /**
+/**
* CubeTransitionFoldEffectimplementation class
*/
- class CubeTransitionFoldEffect;
+class CubeTransitionFoldEffect;
-} // namespace Internal
+} // namespace DALI_INTERNAL
/**
* SubClass of CubeTransitionEffect
*/
class DALI_TOOLKIT_API CubeTransitionFoldEffect : public CubeTransitionEffect
{
-
public:
-
/**
* Create an initialized CubeTransitionFoldEffect
* @param[in] numRows How many rows of cubes
* @param[in] numColumns How many columns of cubes
* @return The initialized CubeTransitionFoldEffect object
*/
- static CubeTransitionFoldEffect New( unsigned int numRows, unsigned int numColumns );
-
+ static CubeTransitionFoldEffect New(unsigned int numRows, unsigned int numColumns);
public: // Not intended for developer use
-
/**
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL CubeTransitionFoldEffect( Internal::CubeTransitionFoldEffect& implementation );
+ DALI_INTERNAL CubeTransitionFoldEffect(Internal::CubeTransitionFoldEffect& implementation);
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- DALI_INTERNAL CubeTransitionFoldEffect( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL CubeTransitionFoldEffect(Dali::Internal::CustomActor* internal);
}; // class CubeTransitionFoldEffect
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
-CubeTransitionWaveEffect::CubeTransitionWaveEffect( Internal::CubeTransitionWaveEffect& implementation )
-: CubeTransitionEffect( implementation )
+CubeTransitionWaveEffect::CubeTransitionWaveEffect(Internal::CubeTransitionWaveEffect& implementation)
+: CubeTransitionEffect(implementation)
{
}
-CubeTransitionWaveEffect::CubeTransitionWaveEffect( Dali::Internal::CustomActor* internal )
-: CubeTransitionEffect( internal )
+CubeTransitionWaveEffect::CubeTransitionWaveEffect(Dali::Internal::CustomActor* internal)
+: CubeTransitionEffect(internal)
{
- VerifyCustomActorPointer< Internal::CubeTransitionWaveEffect >( internal );
+ VerifyCustomActorPointer<Internal::CubeTransitionWaveEffect>(internal);
}
-CubeTransitionWaveEffect CubeTransitionWaveEffect::New(unsigned int numRows, unsigned int numColumns )
+CubeTransitionWaveEffect CubeTransitionWaveEffect::New(unsigned int numRows, unsigned int numColumns)
{
- return Internal::CubeTransitionWaveEffect::New( numRows, numColumns );
+ return Internal::CubeTransitionWaveEffect::New(numRows, numColumns);
}
} // namespace Toolkit
#define DALI_TOOLKIT_CUBE_TRANSITION_WAVE_EFFECT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
- /**
+/**
* CubeTransitionWaveEffect implementation class
*/
- class CubeTransitionWaveEffect;
+class CubeTransitionWaveEffect;
-} // namespace Internal
+} // namespace DALI_INTERNAL
/**
* SubClass of CubeTransitionEffect
*/
class DALI_TOOLKIT_API CubeTransitionWaveEffect : public CubeTransitionEffect
{
-
public:
-
/**
* Create an initialized CubeTransitionWaveEffect
* @param[in] numRows How many rows of cubes
* @param[in] numColumns How many columns of cubes
* @return The initialized CubeTransitionWaveEffect object
*/
- static CubeTransitionWaveEffect New( unsigned int numRows, unsigned int numColumns );
-
+ static CubeTransitionWaveEffect New(unsigned int numRows, unsigned int numColumns);
public: // Not intended for developer use
-
/**
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- DALI_INTERNAL CubeTransitionWaveEffect( Internal::CubeTransitionWaveEffect& implementation );
+ DALI_INTERNAL CubeTransitionWaveEffect(Internal::CubeTransitionWaveEffect& implementation);
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- DALI_INTERNAL CubeTransitionWaveEffect( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL CubeTransitionWaveEffect(Dali::Internal::CustomActor* internal);
}; // class CubeTransitionWaveEffect
namespace Dali
{
-
namespace Toolkit
{
-
namespace NPatchUtility
{
-
namespace
{
-
-Uint16Pair ParseRange( uint32_t& index, uint32_t width, uint8_t*& pixel, uint32_t pixelStride, int32_t testByte, int32_t testBits, int32_t testValue )
+Uint16Pair ParseRange(uint32_t& index, uint32_t width, uint8_t*& pixel, uint32_t pixelStride, int32_t testByte, int32_t testBits, int32_t testValue)
{
- unsigned int start = 0xFFFF;
- for( ; index < width; ++index, pixel += pixelStride )
- {
- if( ( pixel[ testByte ] & testBits ) == testValue )
- {
- start = index;
- ++index;
- pixel += pixelStride;
- break;
- }
- }
+ unsigned int start = 0xFFFF;
+ for(; index < width; ++index, pixel += pixelStride)
+ {
+ if((pixel[testByte] & testBits) == testValue)
+ {
+ start = index;
+ ++index;
+ pixel += pixelStride;
+ break;
+ }
+ }
- unsigned int end = width;
- for( ; index < width; ++index, pixel += pixelStride )
- {
- if( ( pixel[ testByte ] & testBits ) != testValue )
- {
- end = index;
- ++index;
- pixel += pixelStride;
- break;
- }
- }
+ unsigned int end = width;
+ for(; index < width; ++index, pixel += pixelStride)
+ {
+ if((pixel[testByte] & testBits) != testValue)
+ {
+ end = index;
+ ++index;
+ pixel += pixelStride;
+ break;
+ }
+ }
- return Uint16Pair( start, end );
+ return Uint16Pair(start, end);
}
} // unnamed namespace
-void GetRedOffsetAndMask( Dali::Pixel::Format pixelFormat, int32_t& byteOffset, int32_t& bitMask )
+void GetRedOffsetAndMask(Dali::Pixel::Format pixelFormat, int32_t& byteOffset, int32_t& bitMask)
{
- switch( pixelFormat )
- {
- case Dali::Pixel::A8:
- case Dali::Pixel::L8:
- case Dali::Pixel::LA88:
- {
- byteOffset = 0;
- bitMask = 0;
- break;
- }
- case Dali::Pixel::RGB888:
- case Dali::Pixel::RGB8888:
- case Dali::Pixel::RGBA8888:
- {
- byteOffset = 0;
- bitMask = 0xFF;
- break;
- }
- case Dali::Pixel::BGR8888:
- case Dali::Pixel::BGRA8888:
- {
- byteOffset = 2;
- bitMask = 0xff;
- break;
- }
- case Dali::Pixel::RGB565:
- {
- byteOffset = 0;
- bitMask = 0xf8;
- break;
- }
- case Dali::Pixel::BGR565:
- {
- byteOffset = 1;
- bitMask = 0x1f;
- break;
- }
- case Dali::Pixel::RGBA4444:
- {
- byteOffset = 0;
- bitMask = 0xf0;
- break;
- }
- case Dali::Pixel::BGRA4444:
- {
- byteOffset = 1;
- bitMask = 0xf0;
- break;
- }
- case Dali::Pixel::RGBA5551:
- {
- byteOffset = 0;
- bitMask = 0xf8;
- break;
- }
- case Dali::Pixel::BGRA5551:
- {
- byteOffset = 1;
- bitMask = 0x1e;
- break;
- }
- case Dali::Pixel::INVALID:
- case Dali::Pixel::COMPRESSED_R11_EAC:
- case Dali::Pixel::COMPRESSED_SIGNED_R11_EAC:
- case Dali::Pixel::COMPRESSED_RG11_EAC:
- case Dali::Pixel::COMPRESSED_SIGNED_RG11_EAC:
- case Dali::Pixel::COMPRESSED_RGB8_ETC2:
- case Dali::Pixel::COMPRESSED_SRGB8_ETC2:
- case Dali::Pixel::COMPRESSED_RGB8_ETC1:
- case Dali::Pixel::COMPRESSED_RGB_PVRTC_4BPPV1:
- case Dali::Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
- case Dali::Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
- case Dali::Pixel::COMPRESSED_RGBA8_ETC2_EAC:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR:
- case Dali::Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
- case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
- {
- DALI_LOG_ERROR("Pixel formats for compressed images are not compatible with simple masking-out of per-pixel alpha.\n");
- byteOffset=0;
- bitMask=0;
- break;
- }
- case Dali::Pixel::RGB16F:
- case Dali::Pixel::RGB32F:
- case Dali::Pixel::DEPTH_UNSIGNED_INT:
- case Dali::Pixel::DEPTH_FLOAT:
- case Dali::Pixel::DEPTH_STENCIL:
- {
- DALI_LOG_ERROR("Pixel format not compatible.\n");
- byteOffset=0;
- bitMask=0;
- break;
- }
- }
+ switch(pixelFormat)
+ {
+ case Dali::Pixel::A8:
+ case Dali::Pixel::L8:
+ case Dali::Pixel::LA88:
+ {
+ byteOffset = 0;
+ bitMask = 0;
+ break;
+ }
+ case Dali::Pixel::RGB888:
+ case Dali::Pixel::RGB8888:
+ case Dali::Pixel::RGBA8888:
+ {
+ byteOffset = 0;
+ bitMask = 0xFF;
+ break;
+ }
+ case Dali::Pixel::BGR8888:
+ case Dali::Pixel::BGRA8888:
+ {
+ byteOffset = 2;
+ bitMask = 0xff;
+ break;
+ }
+ case Dali::Pixel::RGB565:
+ {
+ byteOffset = 0;
+ bitMask = 0xf8;
+ break;
+ }
+ case Dali::Pixel::BGR565:
+ {
+ byteOffset = 1;
+ bitMask = 0x1f;
+ break;
+ }
+ case Dali::Pixel::RGBA4444:
+ {
+ byteOffset = 0;
+ bitMask = 0xf0;
+ break;
+ }
+ case Dali::Pixel::BGRA4444:
+ {
+ byteOffset = 1;
+ bitMask = 0xf0;
+ break;
+ }
+ case Dali::Pixel::RGBA5551:
+ {
+ byteOffset = 0;
+ bitMask = 0xf8;
+ break;
+ }
+ case Dali::Pixel::BGRA5551:
+ {
+ byteOffset = 1;
+ bitMask = 0x1e;
+ break;
+ }
+ case Dali::Pixel::INVALID:
+ case Dali::Pixel::COMPRESSED_R11_EAC:
+ case Dali::Pixel::COMPRESSED_SIGNED_R11_EAC:
+ case Dali::Pixel::COMPRESSED_RG11_EAC:
+ case Dali::Pixel::COMPRESSED_SIGNED_RG11_EAC:
+ case Dali::Pixel::COMPRESSED_RGB8_ETC2:
+ case Dali::Pixel::COMPRESSED_SRGB8_ETC2:
+ case Dali::Pixel::COMPRESSED_RGB8_ETC1:
+ case Dali::Pixel::COMPRESSED_RGB_PVRTC_4BPPV1:
+ case Dali::Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+ case Dali::Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+ case Dali::Pixel::COMPRESSED_RGBA8_ETC2_EAC:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR:
+ case Dali::Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
+ case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
+ {
+ DALI_LOG_ERROR("Pixel formats for compressed images are not compatible with simple masking-out of per-pixel alpha.\n");
+ byteOffset = 0;
+ bitMask = 0;
+ break;
+ }
+ case Dali::Pixel::RGB16F:
+ case Dali::Pixel::RGB32F:
+ case Dali::Pixel::DEPTH_UNSIGNED_INT:
+ case Dali::Pixel::DEPTH_FLOAT:
+ case Dali::Pixel::DEPTH_STENCIL:
+ {
+ DALI_LOG_ERROR("Pixel format not compatible.\n");
+ byteOffset = 0;
+ bitMask = 0;
+ break;
+ }
+ }
}
-void ParseBorders( Devel::PixelBuffer& pixelBuffer, StretchRanges& stretchPixelsX, StretchRanges& stretchPixelsY )
+void ParseBorders(Devel::PixelBuffer& pixelBuffer, StretchRanges& stretchPixelsX, StretchRanges& stretchPixelsY)
{
- stretchPixelsX.Clear();
- stretchPixelsY.Clear();
+ stretchPixelsX.Clear();
+ stretchPixelsY.Clear();
- Pixel::Format pixelFormat = pixelBuffer.GetPixelFormat();
+ Pixel::Format pixelFormat = pixelBuffer.GetPixelFormat();
- int32_t alphaByte = 0;
- int32_t alphaBits = 0;
- Pixel::GetAlphaOffsetAndMask( pixelFormat, alphaByte, alphaBits );
+ int32_t alphaByte = 0;
+ int32_t alphaBits = 0;
+ Pixel::GetAlphaOffsetAndMask(pixelFormat, alphaByte, alphaBits);
- int32_t testByte = alphaByte;
- int32_t testBits = alphaBits;
- int32_t testValue = alphaBits; // Opaque == stretch
- if( !alphaBits )
- {
- GetRedOffsetAndMask( pixelFormat, testByte, testBits );
- testValue = 0; // Black == stretch
- }
+ int32_t testByte = alphaByte;
+ int32_t testBits = alphaBits;
+ int32_t testValue = alphaBits; // Opaque == stretch
+ if(!alphaBits)
+ {
+ GetRedOffsetAndMask(pixelFormat, testByte, testBits);
+ testValue = 0; // Black == stretch
+ }
- uint32_t bytesPerPixel = Pixel::GetBytesPerPixel( pixelFormat );
- uint32_t width = pixelBuffer.GetWidth();
- uint32_t height = pixelBuffer.GetHeight();
- uint8_t* srcPixels = pixelBuffer.GetBuffer();
- uint32_t srcStride = width * bytesPerPixel;
+ uint32_t bytesPerPixel = Pixel::GetBytesPerPixel(pixelFormat);
+ uint32_t width = pixelBuffer.GetWidth();
+ uint32_t height = pixelBuffer.GetHeight();
+ uint8_t* srcPixels = pixelBuffer.GetBuffer();
+ uint32_t srcStride = width * bytesPerPixel;
- // TOP
- uint8_t* top = srcPixels + bytesPerPixel;
- uint32_t index = 0;
+ // TOP
+ uint8_t* top = srcPixels + bytesPerPixel;
+ uint32_t index = 0;
- for( ; index < width - 2; )
- {
- Uint16Pair range = ParseRange( index, width - 2, top, bytesPerPixel, testByte, testBits, testValue );
- if( range.GetX() != 0xFFFF )
- {
- stretchPixelsX.PushBack( range );
- }
- }
+ for(; index < width - 2;)
+ {
+ Uint16Pair range = ParseRange(index, width - 2, top, bytesPerPixel, testByte, testBits, testValue);
+ if(range.GetX() != 0xFFFF)
+ {
+ stretchPixelsX.PushBack(range);
+ }
+ }
- // LEFT
- uint8_t* left = srcPixels + srcStride;
- index = 0;
- for( ; index < height - 2; )
- {
- Uint16Pair range = ParseRange( index, height - 2, left, srcStride, testByte, testBits, testValue );
- if( range.GetX() != 0xFFFF )
- {
- stretchPixelsY.PushBack( range );
- }
- }
+ // LEFT
+ uint8_t* left = srcPixels + srcStride;
+ index = 0;
+ for(; index < height - 2;)
+ {
+ Uint16Pair range = ParseRange(index, height - 2, left, srcStride, testByte, testBits, testValue);
+ if(range.GetX() != 0xFFFF)
+ {
+ stretchPixelsY.PushBack(range);
+ }
+ }
- // If there are no stretch pixels then make the entire image stretchable
- if( stretchPixelsX.Size() == 0 )
- {
- stretchPixelsX.PushBack( Uint16Pair( 0, width - 2 ) );
- }
- if( stretchPixelsY.Size() == 0 )
- {
- stretchPixelsY.PushBack( Uint16Pair( 0, height - 2 ) );
- }
+ // If there are no stretch pixels then make the entire image stretchable
+ if(stretchPixelsX.Size() == 0)
+ {
+ stretchPixelsX.PushBack(Uint16Pair(0, width - 2));
+ }
+ if(stretchPixelsY.Size() == 0)
+ {
+ stretchPixelsY.PushBack(Uint16Pair(0, height - 2));
+ }
}
-bool IsNinePatchUrl( const std::string& url )
+bool IsNinePatchUrl(const std::string& url)
{
bool match = false;
std::string::const_reverse_iterator iter = url.rbegin();
- enum { SUFFIX, HASH, HASH_DOT, DONE } state = SUFFIX;
+ enum
+ {
+ SUFFIX,
+ HASH,
+ HASH_DOT,
+ DONE
+ } state = SUFFIX;
while(iter < url.rend())
{
switch(state)
break;
case HASH:
{
- if( *iter == '#' || *iter == '9' )
+ if(*iter == '#' || *iter == '9')
{
state = HASH_DOT;
}
}
// Satisfy prevent
- if( state == DONE )
+ if(state == DONE)
{
break;
}
return match;
}
-} // namespace NPatchBuffer
+} // namespace NPatchUtility
} // namespace Toolkit
*/
// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/math/uint-16-pair.h>
-#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/dali-toolkit-common.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace NPatchUtility
{
-
/**
* The list that includes stretch pixel ranges
*/
-using StretchRanges = Dali::Vector< Uint16Pair >;
+using StretchRanges = Dali::Vector<Uint16Pair>;
/**
* @brief Get the offset of the red channel for the format.
* @param[out] byteOffset The byte offset of the red channel.
* @param[out] bitMask The bit mask of the red channel.
*/
-DALI_TOOLKIT_API void GetRedOffsetAndMask( Dali::Pixel::Format pixelFormat, int& byteOffset, int& bitMask );
+DALI_TOOLKIT_API void GetRedOffsetAndMask(Dali::Pixel::Format pixelFormat, int& byteOffset, int& bitMask);
/**
* @brief Read the borders of the buffer and determine the child area and stretch borders.
* @param[out] stretchPixelsX The horizontal stretchable pixels in the cropped image space.
* @param[out] stretchPixelsY The vertical stretchable pixels in the cropped image space.
*/
-DALI_TOOLKIT_API void ParseBorders( Devel::PixelBuffer& pixelBuffer, StretchRanges& stretchPixelsX, StretchRanges& stretchPixelsY );
+DALI_TOOLKIT_API void ParseBorders(Devel::PixelBuffer& pixelBuffer, StretchRanges& stretchPixelsX, StretchRanges& stretchPixelsY);
/**
* @brief Helper method to determine if the filename indicates that the image has a 9 patch or n patch border.
* @param [in] url The URL of the image file.
* @return true if it is a 9 patch or n patch image
*/
-DALI_TOOLKIT_API bool IsNinePatchUrl( const std::string& url );
+DALI_TOOLKIT_API bool IsNinePatchUrl(const std::string& url);
} // namespace NPatchUtility
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
{
namespace Toolkit
{
-
TransitionData::TransitionData()
{
}
{
}
-TransitionData TransitionData::New( const Property::Array& transition )
+TransitionData TransitionData::New(const Property::Array& transition)
{
- Internal::TransitionDataPtr transitionData = Internal::TransitionData::New( transition );
- return TransitionData( transitionData.Get() );
+ Internal::TransitionDataPtr transitionData = Internal::TransitionData::New(transition);
+ return TransitionData(transitionData.Get());
}
-TransitionData TransitionData::New( const Property::Map& transition )
+TransitionData TransitionData::New(const Property::Map& transition)
{
- Internal::TransitionDataPtr transitionData = Internal::TransitionData::New( transition );
- return TransitionData( transitionData.Get() );
+ Internal::TransitionDataPtr transitionData = Internal::TransitionData::New(transition);
+ return TransitionData(transitionData.Get());
}
-TransitionData TransitionData::DownCast( BaseHandle handle )
+TransitionData TransitionData::DownCast(BaseHandle handle)
{
- return TransitionData( dynamic_cast<Dali::Toolkit::Internal::TransitionData*>(handle.GetObjectPtr()));
+ return TransitionData(dynamic_cast<Dali::Toolkit::Internal::TransitionData*>(handle.GetObjectPtr()));
}
-TransitionData::TransitionData( const TransitionData& handle )
-: BaseHandle( handle )
+TransitionData::TransitionData(const TransitionData& handle)
+: BaseHandle(handle)
{
}
-TransitionData& TransitionData::operator=( const TransitionData& handle )
+TransitionData& TransitionData::operator=(const TransitionData& handle)
{
- BaseHandle::operator=( handle );
+ BaseHandle::operator=(handle);
return *this;
}
size_t TransitionData::Count() const
{
- return GetImplementation( *this ).Count();
+ return GetImplementation(*this).Count();
}
-Property::Map TransitionData::GetAnimatorAt( size_t index )
+Property::Map TransitionData::GetAnimatorAt(size_t index)
{
- return GetImplementation( *this ).GetAnimatorAt( index );
+ return GetImplementation(*this).GetAnimatorAt(index);
}
-TransitionData::TransitionData( Internal::TransitionData* pointer )
-: BaseHandle( pointer )
+TransitionData::TransitionData(Internal::TransitionData* pointer)
+: BaseHandle(pointer)
{
}
#define DALI_TOOLKIT_TRANSITION_DATA_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/animation/alpha-function.h>
+#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/object/property-array.h>
#include <dali/public-api/object/property-map.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal
{
class TransitionData;
* @param[in] transition The transition data to store (a single animator)
* @return A handle to an initialized data.
*/
- static TransitionData New( const Property::Map& transition );
+ static TransitionData New(const Property::Map& transition);
/**
* @brief Creates a TransitionData object
* @param[in] transition The transition data to store (an array of maps of animators)
* @return A handle to an initialized data.
*/
- static TransitionData New( const Property::Array& transition );
+ static TransitionData New(const Property::Array& transition);
/**
* @brief Downcast to a TransitionData handle
* @param[in] handle Handle to an object
* @return TransitionData handle or an uninitialized handle.
*/
- static TransitionData DownCast( BaseHandle handle );
+ static TransitionData DownCast(BaseHandle handle);
/**
* @brief Copy constructor
* @SINCE_1_2.12
* @param[in] handle Handle to an object
*/
- TransitionData( const TransitionData& handle );
+ TransitionData(const TransitionData& handle);
/**
* @brief Assignment Operator
* @param[in] handle Handle to an object
* @return A reference to this object.
*/
- TransitionData& operator=( const TransitionData& handle );
+ TransitionData& operator=(const TransitionData& handle);
/**
* @brief returns the count of the individual property transitions
* @param[in] index The index of the animator ( Must be less than Count() )
* @return A property map representing the animator
*/
- Property::Map GetAnimatorAt( size_t index );
+ Property::Map GetAnimatorAt(size_t index);
public: // Not intended for application developers
-
- explicit DALI_INTERNAL TransitionData( Internal::TransitionData *impl );
+ explicit DALI_INTERNAL TransitionData(Internal::TransitionData* impl);
};
} // namespace Toolkit
- /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+/*
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
Visual::Base::Base()
{
}
{
}
-Visual::Base::Base( const Visual::Base& handle )
-: BaseHandle( handle )
+Visual::Base::Base(const Visual::Base& handle)
+: BaseHandle(handle)
{
}
-Visual::Base& Visual::Base::operator=( const Visual::Base& handle )
+Visual::Base& Visual::Base::operator=(const Visual::Base& handle)
{
- BaseHandle::operator=( handle );
+ BaseHandle::operator=(handle);
return *this;
}
-Visual::Base::Base(Internal::Visual::Base *impl)
-: BaseHandle( impl )
+Visual::Base::Base(Internal::Visual::Base* impl)
+: BaseHandle(impl)
{
}
-void Visual::Base::SetName( const std::string& name )
+void Visual::Base::SetName(const std::string& name)
{
- GetImplementation( *this ).SetName( name );
+ GetImplementation(*this).SetName(name);
}
const std::string& Visual::Base::GetName() const
{
- return GetImplementation( *this ).GetName();
+ return GetImplementation(*this).GetName();
}
-void Visual::Base::SetTransformAndSize( const Dali::Property::Map& transform, Size controlSize )
+void Visual::Base::SetTransformAndSize(const Dali::Property::Map& transform, Size controlSize)
{
- GetImplementation( *this ).SetTransformAndSize( transform, controlSize );
+ GetImplementation(*this).SetTransformAndSize(transform, controlSize);
}
-float Visual::Base::GetHeightForWidth( float width )
+float Visual::Base::GetHeightForWidth(float width)
{
- return GetImplementation( *this ).GetHeightForWidth( width );
+ return GetImplementation(*this).GetHeightForWidth(width);
}
-float Visual::Base::GetWidthForHeight( float height )
+float Visual::Base::GetWidthForHeight(float height)
{
- return GetImplementation( *this ).GetWidthForHeight( height );
+ return GetImplementation(*this).GetWidthForHeight(height);
}
-void Visual::Base::GetNaturalSize(Vector2& naturalSize )
+void Visual::Base::GetNaturalSize(Vector2& naturalSize)
{
- GetImplementation( *this ).GetNaturalSize( naturalSize );
+ GetImplementation(*this).GetNaturalSize(naturalSize);
}
-void Visual::Base::SetDepthIndex( int index )
+void Visual::Base::SetDepthIndex(int index)
{
- GetImplementation( *this ).SetDepthIndex( index );
+ GetImplementation(*this).SetDepthIndex(index);
}
int Visual::Base::GetDepthIndex() const
{
- return GetImplementation( *this ).GetDepthIndex();
+ return GetImplementation(*this).GetDepthIndex();
}
-void Visual::Base::CreatePropertyMap( Dali::Property::Map& map ) const
+void Visual::Base::CreatePropertyMap(Dali::Property::Map& map) const
{
- GetImplementation( *this ).CreatePropertyMap( map );
+ GetImplementation(*this).CreatePropertyMap(map);
}
Visual::Type Visual::Base::GetType() const
{
- return GetImplementation( *this ).GetType();
+ return GetImplementation(*this).GetType();
}
-
-
-
} // namespace Toolkit
} // namespace Dali
#ifndef DALI_TOOLKIT_VISUAL_BASE_H
#define DALI_TOOLKIT_VISUAL_BASE_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/object/base-handle.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/dali-toolkit-common.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
namespace Visual
{
class Base;
}
-}
+} // namespace DALI_INTERNAL
namespace Visual
{
-
/**
* @brief A Visual provides a renderer for drawing a control component. A control may have multiple visuals.
*
class DALI_TOOLKIT_API Base : public BaseHandle
{
public:
-
/**
* @brief Create an empty Visual Handle
*/
*
* @param[in] handle A reference to the copied handle.
*/
- Base( const Base& handle );
+ Base(const Base& handle);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param [in] handle A reference to the copied handle.
* @return A reference to this.
*/
- Base& operator=( const Base& handle );
+ Base& operator=(const Base& handle);
/**
* @brief Set the name of the visual
* Used by the styling system to animate properties
* @param[in] name The name to give the visual
*/
- void SetName( const std::string& name );
+ void SetName(const std::string& name);
/**
* @brief Get the name of the visual
* @param[in] transform A property map describing the transform
* @param[in] controlSize The size of the parent control for visuals that need to scale internally.
*/
- void SetTransformAndSize( const Dali::Property::Map& transform, Size controlSize );
+ void SetTransformAndSize(const Dali::Property::Map& transform, Size controlSize);
/**
* @brief Returns the height for a given width.
*
* @return The height based on the width.
*/
- float GetHeightForWidth( float width );
+ float GetHeightForWidth(float width);
/**
* @brief Returns the width for a given height.
*
* @return The width based on the height.
*/
- float GetWidthForHeight( float height );
+ float GetWidthForHeight(float height);
/**
* @brief Return the natural size of the visual.
*
* @param[out] naturalSize The visual's natural size
*/
- void GetNaturalSize( Vector2& naturalSize );
+ void GetNaturalSize(Vector2& naturalSize);
/**
* @brief Set the depth index of this visual.
*
* @param[in] index The depth index of this visual.
*/
- void SetDepthIndex( int index );
+ void SetDepthIndex(int index);
/**
* @brief Get the depth index of this visual
*
* @param[out] map The visual property map.
*/
- void CreatePropertyMap( Dali::Property::Map& map ) const;
+ void CreatePropertyMap(Dali::Property::Map& map) const;
/**
* @brief Get the type of this visual.
Visual::Type GetType() const;
public: // Not intended for application developers
-
- explicit DALI_INTERNAL Base(Internal::Visual::Base *impl);
-
+ explicit DALI_INTERNAL Base(Internal::Visual::Base* impl);
};
} // namespace Visual
- /*
+/*
* Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
#include "visual-factory.h"
// EXTERNAL INCLUDES
-#include <dali/devel-api/common/singleton-service.h>
#include <dali/devel-api/adaptor-framework/environment-variable.h>
+#include <dali/devel-api/common/singleton-service.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace
{
- const char * const DALI_DEBUG_RENDERING("DALI_DEBUG_RENDERING");
+const char* const DALI_DEBUG_RENDERING("DALI_DEBUG_RENDERING");
}
VisualFactory VisualFactory::Get()
VisualFactory factory;
// Check whether the VisualFactory is already created
- SingletonService singletonService( SingletonService::Get() );
- if( singletonService )
+ SingletonService singletonService(SingletonService::Get());
+ if(singletonService)
{
- BaseHandle handle = singletonService.GetSingleton( typeid(VisualFactory) );
- if( handle )
+ BaseHandle handle = singletonService.GetSingleton(typeid(VisualFactory));
+ if(handle)
{
//If so, downcast the handle of singleton to VisualFactory
- factory = VisualFactory( dynamic_cast<Internal::VisualFactory*>(handle.GetObjectPtr()) );
+ factory = VisualFactory(dynamic_cast<Internal::VisualFactory*>(handle.GetObjectPtr()));
}
- if( !factory )// If not, create the VisualFactory and register it as a singleton
+ if(!factory) // If not, create the VisualFactory and register it as a singleton
{
// Check whether debug rendering is required
- if( EnvironmentVariable::GetEnvironmentVariable( DALI_DEBUG_RENDERING ) )
+ if(EnvironmentVariable::GetEnvironmentVariable(DALI_DEBUG_RENDERING))
{
- factory = VisualFactory( new Internal::VisualFactory(true) );
+ factory = VisualFactory(new Internal::VisualFactory(true));
}
else
{
- factory = VisualFactory( new Internal::VisualFactory(false) );
+ factory = VisualFactory(new Internal::VisualFactory(false));
}
- singletonService.Register( typeid(VisualFactory), factory );
-
+ singletonService.Register(typeid(VisualFactory), factory);
}
}
{
}
-VisualFactory::VisualFactory( const VisualFactory& handle )
-: BaseHandle( handle )
+VisualFactory::VisualFactory(const VisualFactory& handle)
+: BaseHandle(handle)
{
}
-VisualFactory& VisualFactory::operator=( const VisualFactory& handle )
+VisualFactory& VisualFactory::operator=(const VisualFactory& handle)
{
- BaseHandle::operator=( handle );
+ BaseHandle::operator=(handle);
return *this;
}
-VisualFactory::VisualFactory(Internal::VisualFactory *impl)
+VisualFactory::VisualFactory(Internal::VisualFactory* impl)
: BaseHandle(impl)
{
}
-Visual::Base VisualFactory::CreateVisual( const Property::Map& propertyMap )
+Visual::Base VisualFactory::CreateVisual(const Property::Map& propertyMap)
{
- return GetImplementation( *this ).CreateVisual( propertyMap );
+ return GetImplementation(*this).CreateVisual(propertyMap);
}
-Visual::Base VisualFactory::CreateVisual( const std::string& url, ImageDimensions size )
+Visual::Base VisualFactory::CreateVisual(const std::string& url, ImageDimensions size)
{
- return GetImplementation( *this ).CreateVisual( url, size );
+ return GetImplementation(*this).CreateVisual(url, size);
}
-void VisualFactory::SetPreMultiplyOnLoad( bool preMultiply )
+void VisualFactory::SetPreMultiplyOnLoad(bool preMultiply)
{
- GetImplementation( *this ).SetPreMultiplyOnLoad( preMultiply );
+ GetImplementation(*this).SetPreMultiplyOnLoad(preMultiply);
}
bool VisualFactory::GetPreMultiplyOnLoad() const
{
- return GetImplementation( *this ).GetPreMultiplyOnLoad();
+ return GetImplementation(*this).GetPreMultiplyOnLoad();
}
} // namespace Toolkit
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/images/image-operations.h>
+#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/object/property-map.h>
// INTERNAL INCLUDES
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class VisualFactory;
class DALI_TOOLKIT_API VisualFactory : public BaseHandle
{
public:
-
/**
* @brief Create or retrieve VisualFactory singleton.
*
*
* @param[in] handle A reference to the copied handle.
*/
- VisualFactory( const VisualFactory& handle );
+ VisualFactory(const VisualFactory& handle);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param [in] handle A reference to the copied handle.
* @return A reference to this.
*/
- VisualFactory& operator=( const VisualFactory& handle );
+ VisualFactory& operator=(const VisualFactory& handle);
/**
* @brief Request the visual
* The content of the map determines the type of visual that will be returned.
* @return The handle to the created visual
*/
- Visual::Base CreateVisual( const Property::Map& propertyMap );
+ Visual::Base CreateVisual(const Property::Map& propertyMap);
/**
* @brief Request the visual to render the given resource at the url.
* @param[in] size The width and height to fit the loaded image to.
* @return The pointer pointing to the visual
*/
- Visual::Base CreateVisual( const std::string& url, ImageDimensions size );
+ Visual::Base CreateVisual(const std::string& url, ImageDimensions size);
/**
* @brief Enable or disable premultiplying alpha in images and image visuals.
* @param[in] preMultiply True if loaded images for image visuals should have alpha multiplied into the color
* channels.
*/
- void SetPreMultiplyOnLoad( bool preMultiply );
+ void SetPreMultiplyOnLoad(bool preMultiply);
/**
* @brief Get the setting for automatically pre-multiplying image visual images on load.
bool GetPreMultiplyOnLoad() const;
private:
-
- explicit DALI_INTERNAL VisualFactory(Internal::VisualFactory *impl);
-
+ explicit DALI_INTERNAL VisualFactory(Internal::VisualFactory* impl);
};
} // namespace Toolkit
#define DALI_TOOLKIT_DEVEL_ANIMATED_GRADIENT_VISUAL_PROPERTIES_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
*
*/
*/
namespace DevelAnimatedGradientVisual
{
-
/**
* @brief AnimatedGradientVisual Property
*/
namespace Property
{
-
/**
* @brief AnimatedGradientVisual Property
*/
*/
namespace GradientType
{
-
/**
* @brief The type of gradient form. It decide the method of calculate gradient coordinate.
* - If GradientType::Type is LINEAR, gradient coordinate is dot product with the line which contain START_POSITION and END_POSITION.
enum Type
{
LINEAR, ///< Draw gradient linear form.
- RADIAL ///< Draw gradient radial form.
+ RADIAL ///< Draw gradient radial form.
};
} // namespace GradientType
*/
namespace UnitType
{
-
/**
* @brief The type of coordinate system for certain attributes of the points in a gradients.
* This applies to the START_POSITION, END_POSITION, and ROTATE_CENTER.
enum Type
{
OBJECT_BOUNDING_BOX, ///< Use positions coordinate in bottom-left(-0.5,-0.5) ~ top-right(0.5,0.5).
- USER_SPACE, ///< Use positions coordinate in bottom-left(-ActorSize.xy * 0.5) ~ top-right(ActorSize.xy * 0.5).
+ USER_SPACE, ///< Use positions coordinate in bottom-left(-ActorSize.xy * 0.5) ~ top-right(ActorSize.xy * 0.5).
};
} // namespace UnitType
*/
namespace SpreadType
{
-
/**
* @brief The policies that define what happens if the gradient coordinate is not between 0 and 1.
*/
enum Type
{
REFLECT, ///< Reflect the gradient pattern start-to-end, end-to-start, start-to-end etc.
- REPEAT, ///< Repeat the gradient pattern start-to-end, start-to-end, start-to-end etc.
- CLAMP, ///< Use the terminal colors of gradient.
+ REPEAT, ///< Repeat the gradient pattern start-to-end, start-to-end, start-to-end etc.
+ CLAMP, ///< Use the terminal colors of gradient.
};
} // namespace SpreadType
*/
namespace AnimationParameter
{
-
/**
* @brief AnimatedGradientVisual::AnimationParameter Property
*/
*/
namespace DirectionType
{
-
/**
* @brief The type of animation direction
*/
enum Type
{
- FORWARD, ///< Animate value from START to TARGET
+ FORWARD, ///< Animate value from START to TARGET
BACKWARD, ///< Animate value frome TARGET to START
};
*/
namespace MotionType
{
-
/**
* @brief The type of animation motion
*/
enum Type
{
- LOOP, ///< Animate loopingmode restart
+ LOOP, ///< Animate loopingmode restart
MIRROR, ///< Animate loopingmode auto_reverse
};
*/
namespace EasingType
{
-
/**
* @brief The type of animation easing
*/
enum Type
{
LINEAR, ///< Easing animation linear
- IN, ///< Ease-in animation (slow start -> fast finish)
- OUT, ///< Ease-out animation (fast start -> slow finish)
+ IN, ///< Ease-in animation (slow start -> fast finish)
+ OUT, ///< Ease-out animation (fast start -> slow finish)
IN_OUT, ///< Ease-in and Ease-out animation (slow start -> slow finish)
};
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelAnimatedImageVisual
{
-
/**
* @brief Actions that the animated image visual can perform. These actions are called through the Visual::Base::DoAction API.
*/
*/
enum Type
{
- PLAY, ///< Play the animated GIF. This is also Default playback mode.
- PAUSE, ///< Pause the animated GIF.
- STOP, ///< Stop the animated GIF.
- JUMP_TO ///< Jump to the specified frame. Property::INTEGER value should be passed.
+ PLAY, ///< Play the animated GIF. This is also Default playback mode.
+ PAUSE, ///< Pause the animated GIF.
+ STOP, ///< Stop the animated GIF.
+ JUMP_TO ///< Jump to the specified frame. Property::INTEGER value should be passed.
};
} // namespace Action
#define DALI_TOOLKIT_DEVEL_API_VISUALS_ANIMATED_VECTOR_IMAGE_VISUAL_ACTIONS_DEVEL_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelAnimatedVectorImageVisual
{
-
/**
* @brief Actions that the animated vector image visual can perform. These actions are called through the Visual::Base::DoAction API.
*/
*/
enum Type
{
- PLAY, ///< Play the animated vector image.
- PAUSE, ///< Pause the animated vector image.
- STOP, ///< Stop the animated vector image. This is also Default playback mode.
- JUMP_TO, ///< Jump to the specified frame. Property::INTEGER value should be passed.
- UPDATE_PROPERTY ///< Update the properties of the animated vector image.
+ PLAY, ///< Play the animated vector image.
+ PAUSE, ///< Pause the animated vector image.
+ STOP, ///< Stop the animated vector image. This is also Default playback mode.
+ JUMP_TO, ///< Jump to the specified frame. Property::INTEGER value should be passed.
+ UPDATE_PROPERTY ///< Update the properties of the animated vector image.
};
} // namespace Action
#define DALI_TOOLKIT_DEVEL_API_VISUALS_ANIMATED_VECTOR_IMAGE_VISUAL_SIGNALS_DEVEL_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelAnimatedVectorImageVisual
{
-
/**
* @brief Signal that the animated vector image visual can emit.
*/
*/
enum Type
{
- ANIMATION_FINISHED ///< Animation has finished.
+ ANIMATION_FINISHED ///< Animation has finished.
};
} // namespace Signal
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelArcVisual
{
-
/**
* @brief Actions that the arc visual can perform. These actions are called through the Visual::Base::DoAction API.
*/
UPDATE_PROPERTY = 0
};
-} // namespace Actions
+} // namespace Action
} // namespace DevelArcVisual
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelArcVisual
{
-
/**
* @brief ArcVisual Properties.
*/
namespace Property
{
-
/**
* @brief Enumeration for the instance of properties belonging to the ArcVisual.
*/
*/
namespace Cap
{
-
enum Type
{
- BUTT, ///< The arc does not extend beyond its two endpoints.
- ROUND ///< The arc will be extended by a half circle with the center at the end.
+ BUTT, ///< The arc does not extend beyond its two endpoints.
+ ROUND ///< The arc will be extended by a half circle with the center at the end.
};
} // namespace Cap
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelColorVisual
{
-
/**
* @brief Actions that the color visual can perform. These actions are called through the Visual::Base::DoAction API.
*/
UPDATE_PROPERTY = 0
};
-} // namespace Actions
+} // namespace Action
-} // namespace DevelVisual
+} // namespace DevelColorVisual
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
-
namespace DevelColorVisual
{
-
/**
* @brief Additional ColorVisual Properties.
*/
namespace Property
{
-
/**
* @brief Enumeration for the instance of additional properties belonging to the ColorVisual.
*/
} // namespace Property
-} // namespace ColorVisual
+} // namespace DevelColorVisual
/**
* @}
#define DALI_TOOLKIT_DEVEL_API_VISUALS_IMAGE_VISUAL_ACTIONS_DEVEL_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelImageVisual
{
-
/**
* @brief Actions that the image visual can perform. These actions are called through the Visual::Base::DoAction API.
*/
*/
enum Type
{
- RELOAD = 0 ///< Force reloading of the image, all visuals using this image will get the latest one.
+ RELOAD = 0 ///< Force reloading of the image, all visuals using this image will get the latest one.
};
-} // namespace Actions
+} // namespace Action
} // namespace DevelImageVisual
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelImageVisual
{
-
namespace Property
{
-
enum Type
{
- URL = Dali::Toolkit::ImageVisual::Property::URL,
- FITTING_MODE = Dali::Toolkit::ImageVisual::Property::FITTING_MODE,
- SAMPLING_MODE = Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE,
- DESIRED_WIDTH = Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH,
- DESIRED_HEIGHT = Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT,
- SYNCHRONOUS_LOADING = Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING,
- BORDER_ONLY = Dali::Toolkit::ImageVisual::Property::BORDER_ONLY,
- PIXEL_AREA = Dali::Toolkit::ImageVisual::Property::PIXEL_AREA,
- WRAP_MODE_U = Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U,
- WRAP_MODE_V = Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V,
- BORDER = Dali::Toolkit::ImageVisual::Property::BORDER,
- ATLASING = Dali::Toolkit::ImageVisual::Property::ATLASING,
- ALPHA_MASK_URL = Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL,
- BATCH_SIZE = Dali::Toolkit::ImageVisual::Property::BATCH_SIZE,
- CACHE_SIZE = Dali::Toolkit::ImageVisual::Property::CACHE_SIZE,
- FRAME_DELAY = Dali::Toolkit::ImageVisual::Property::FRAME_DELAY,
- MASK_CONTENT_SCALE = Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE,
- CROP_TO_MASK = Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK,
- LOAD_POLICY = Dali::Toolkit::ImageVisual::Property::LOAD_POLICY,
- RELEASE_POLICY = Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY,
+ URL = Dali::Toolkit::ImageVisual::Property::URL,
+ FITTING_MODE = Dali::Toolkit::ImageVisual::Property::FITTING_MODE,
+ SAMPLING_MODE = Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE,
+ DESIRED_WIDTH = Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH,
+ DESIRED_HEIGHT = Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT,
+ SYNCHRONOUS_LOADING = Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING,
+ BORDER_ONLY = Dali::Toolkit::ImageVisual::Property::BORDER_ONLY,
+ PIXEL_AREA = Dali::Toolkit::ImageVisual::Property::PIXEL_AREA,
+ WRAP_MODE_U = Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U,
+ WRAP_MODE_V = Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V,
+ BORDER = Dali::Toolkit::ImageVisual::Property::BORDER,
+ ATLASING = Dali::Toolkit::ImageVisual::Property::ATLASING,
+ ALPHA_MASK_URL = Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL,
+ BATCH_SIZE = Dali::Toolkit::ImageVisual::Property::BATCH_SIZE,
+ CACHE_SIZE = Dali::Toolkit::ImageVisual::Property::CACHE_SIZE,
+ FRAME_DELAY = Dali::Toolkit::ImageVisual::Property::FRAME_DELAY,
+ MASK_CONTENT_SCALE = Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE,
+ CROP_TO_MASK = Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK,
+ LOAD_POLICY = Dali::Toolkit::ImageVisual::Property::LOAD_POLICY,
+ RELEASE_POLICY = Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY,
ORIENTATION_CORRECTION = Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION,
/**
*/
namespace PlayState
{
-
enum Type
{
- STOPPED, ///< Animation has stopped
- PLAYING, ///< The animation is playing
- PAUSED ///< The animation is paused
+ STOPPED, ///< Animation has stopped
+ PLAYING, ///< The animation is playing
+ PAUSED ///< The animation is paused
};
} // namespace PlayState
*/
namespace StopBehavior
{
-
enum Type
{
- CURRENT_FRAME, ///< When the animation is stopped, the current frame is shown.
- FIRST_FRAME, ///< When the animation is stopped, the first frame is shown.
- LAST_FRAME ///< When the animation is stopped, the last frame is shown.
+ CURRENT_FRAME, ///< When the animation is stopped, the current frame is shown.
+ FIRST_FRAME, ///< When the animation is stopped, the first frame is shown.
+ LAST_FRAME ///< When the animation is stopped, the last frame is shown.
};
-} // namespace StopBehavoir
+} // namespace StopBehavior
/**
* @brief Enumeration for what looping mode is in.
*/
namespace LoopingMode
{
-
enum Type
{
- RESTART, ///< When the animation arrives at the end in looping mode, the animation restarts from the beginning.
- AUTO_REVERSE ///< When the animation arrives at the end in looping mode, the animation reverses direction and runs backwards again.
+ RESTART, ///< When the animation arrives at the end in looping mode, the animation restarts from the beginning.
+ AUTO_REVERSE ///< When the animation arrives at the end in looping mode, the animation reverses direction and runs backwards again.
};
} // namespace LoopingMode
#define DALI_TOOLKIT_DEVEL_API_VISUALS_TEXT_VISUAL_PROPERTIES_DEVEL_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelTextVisual
{
-
namespace Property
{
-
/**
* @brief All the visual types.
*/
enum
{
- TEXT = Dali::Toolkit::TextVisual::Property::TEXT,
- FONT_FAMILY = Dali::Toolkit::TextVisual::Property::FONT_FAMILY,
- FONT_STYLE = Dali::Toolkit::TextVisual::Property::FONT_STYLE,
- POINT_SIZE = Dali::Toolkit::TextVisual::Property::POINT_SIZE,
- MULTI_LINE = Dali::Toolkit::TextVisual::Property::MULTI_LINE,
- HORIZONTAL_ALIGNMENT = Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT,
- VERTICAL_ALIGNMENT = Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT,
- TEXT_COLOR = Dali::Toolkit::TextVisual::Property::TEXT_COLOR,
- ENABLE_MARKUP = Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP,
- SHADOW = Dali::Toolkit::TextVisual::Property::SHADOW,
- UNDERLINE = Dali::Toolkit::TextVisual::Property::UNDERLINE,
+ TEXT = Dali::Toolkit::TextVisual::Property::TEXT,
+ FONT_FAMILY = Dali::Toolkit::TextVisual::Property::FONT_FAMILY,
+ FONT_STYLE = Dali::Toolkit::TextVisual::Property::FONT_STYLE,
+ POINT_SIZE = Dali::Toolkit::TextVisual::Property::POINT_SIZE,
+ MULTI_LINE = Dali::Toolkit::TextVisual::Property::MULTI_LINE,
+ HORIZONTAL_ALIGNMENT = Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT,
+ VERTICAL_ALIGNMENT = Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT,
+ TEXT_COLOR = Dali::Toolkit::TextVisual::Property::TEXT_COLOR,
+ ENABLE_MARKUP = Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP,
+ SHADOW = Dali::Toolkit::TextVisual::Property::SHADOW,
+ UNDERLINE = Dali::Toolkit::TextVisual::Property::UNDERLINE,
/**
* @brief The default outline parameters.
* @details name "outline", type Property::MAP.
*/
- OUTLINE = UNDERLINE + 1,
+ OUTLINE = UNDERLINE + 1,
/**
* @copydoc Dali::Toolkit::DevelTextLabel::Property::BACKGROUND
*/
- BACKGROUND = UNDERLINE + 2,
+ BACKGROUND = UNDERLINE + 2,
};
-
} // namespace Property
} // namespace DevelTextVisual
namespace Dali
{
-
namespace Toolkit
{
-
namespace DevelVisual
{
-
/**
* @brief All the visual types.
*/
SVG = Dali::Toolkit::Visual::SVG,
ANIMATED_IMAGE = Dali::Toolkit::Visual::ANIMATED_IMAGE,
- ANIMATED_GRADIENT = ANIMATED_IMAGE + 1, ///< Renders an animated gradient.
- ANIMATED_VECTOR_IMAGE = ANIMATED_IMAGE + 2, ///< Renders an animated vector image.
- ARC = ANIMATED_IMAGE + 3, ///< Renders an arc.
+ ANIMATED_GRADIENT = ANIMATED_IMAGE + 1, ///< Renders an animated gradient.
+ ANIMATED_VECTOR_IMAGE = ANIMATED_IMAGE + 2, ///< Renders an animated vector image.
+ ARC = ANIMATED_IMAGE + 3, ///< Renders an arc.
};
/**
} // namespace Property
-
/**
* @brief The values of this enum determine how the visual should be fit to the view
*/
enum FittingMode
{
- FIT_KEEP_ASPECT_RATIO, ///< The visual should be scaled to fit, preserving aspect ratio
- FILL, ///< The visual should be stretched to fill, not preserving aspect ratio
- OVER_FIT_KEEP_ASPECT_RATIO,///< The visual should be scaled to fit, preserving aspect ratio. The visual will be filled without empty area, and outside is cropped away.
- CENTER, ///< The visual should keep original size of image. It is not scaled and not strecthed.
- FIT_HEIGHT, ///< The visual should be scaled to fit, preserving aspect ratio. Height is scaled proportionately to maintain aspect ratio. It will be deprecated.
- FIT_WIDTH ///< The visual should be scaled to fit, preserving aspect ratio. Width is scaled proportionately to maintain aspect ratio. It will be deprecated.
+ FIT_KEEP_ASPECT_RATIO, ///< The visual should be scaled to fit, preserving aspect ratio
+ FILL, ///< The visual should be stretched to fill, not preserving aspect ratio
+ OVER_FIT_KEEP_ASPECT_RATIO, ///< The visual should be scaled to fit, preserving aspect ratio. The visual will be filled without empty area, and outside is cropped away.
+ CENTER, ///< The visual should keep original size of image. It is not scaled and not strecthed.
+ FIT_HEIGHT, ///< The visual should be scaled to fit, preserving aspect ratio. Height is scaled proportionately to maintain aspect ratio. It will be deprecated.
+ FIT_WIDTH ///< The visual should be scaled to fit, preserving aspect ratio. Width is scaled proportionately to maintain aspect ratio. It will be deprecated.
};
/**
*/
namespace Transform
{
-
/**
* @brief Visual Transform Property.
*/
namespace Property
{
-
/**
* @brief Enumeration for the type of Transform Property.
*/
#define DALI_TOOLKIT_DEVEL_API_ALIGN_ENUMERATIONS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*
*/
-
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_controls
* @{
*/
namespace Align
{
-
/**
* @brief Describes anchor point and parent origin of visuals
* @SINCE_1_2.60
BOTTOM_CENTER, ///< @SINCE_1_2.60
BOTTOM_END ///< @SINCE_1_2.60
};
-}
+} // namespace Align
/**
* @}
namespace Dali
{
-
namespace Toolkit
{
-
Button::Button()
-{}
+{
+}
-Button::Button( const Button& button ) = default;
+Button::Button(const Button& button) = default;
-Button::Button( Button&& rhs ) = default;
+Button::Button(Button&& rhs) = default;
-Button& Button::operator=( const Button& button ) = default;
+Button& Button::operator=(const Button& button) = default;
-Button& Button::operator=( Button&& rhs ) = default;
+Button& Button::operator=(Button&& rhs) = default;
Button::~Button()
{
}
-Button Button::DownCast( BaseHandle handle )
+Button Button::DownCast(BaseHandle handle)
{
return Control::DownCast<Button, Internal::Button>(handle);
}
Button::ButtonSignalType& Button::PressedSignal()
{
- return Dali::Toolkit::GetImplementation( *this ).PressedSignal();
+ return Dali::Toolkit::GetImplementation(*this).PressedSignal();
}
Button::ButtonSignalType& Button::ReleasedSignal()
{
- return Dali::Toolkit::GetImplementation( *this ).ReleasedSignal();
+ return Dali::Toolkit::GetImplementation(*this).ReleasedSignal();
}
Button::ButtonSignalType& Button::ClickedSignal()
{
- return Dali::Toolkit::GetImplementation( *this ).ClickedSignal();
+ return Dali::Toolkit::GetImplementation(*this).ClickedSignal();
}
Button::ButtonSignalType& Button::StateChangedSignal()
{
- return Dali::Toolkit::GetImplementation( *this ).StateChangedSignal();
+ return Dali::Toolkit::GetImplementation(*this).StateChangedSignal();
}
-Button::Button( Internal::Button& implementation )
-: Control( implementation )
+Button::Button(Internal::Button& implementation)
+: Control(implementation)
{
}
-Button::Button( Dali::Internal::CustomActor* internal )
-: Control( internal )
+Button::Button(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::Button>(internal);
}
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class Button;
class DALI_TOOLKIT_API Button : public Control
{
public:
-
/**
* @brief Enumeration for the start and end property ranges for this control.
* @SINCE_1_0.0
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices @SINCE_1_0.0
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices @SINCE_1_0.0
};
/**
};
public:
-
/**
* @brief Creates an uninitialized Button.
*
* @SINCE_1_0.0
* @param[in] button Handle to an object
*/
- Button( const Button& button );
+ Button(const Button& button);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- Button( Button&& rhs );
+ Button(Button&& rhs);
/**
* @brief Assignment operator.
* @param[in] button Handle to an object
* @return A reference to this
*/
- Button& operator=( const Button& button );
+ Button& operator=(const Button& button);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- Button& operator=( Button&& rhs );
+ Button& operator=(Button&& rhs);
/**
* @brief Downcasts a handle to Button handle.
* @param[in] handle Handle to an object
* @return A handle to a Button or an uninitialized handle
*/
- static Button DownCast( BaseHandle handle );
+ static Button DownCast(BaseHandle handle);
/**
* @brief Destructor.
~Button();
public: //Signals
-
/**
* @brief Button signal type.
* @SINCE_1_0.0
*/
- typedef Signal< bool ( Button ) > ButtonSignalType;
+ typedef Signal<bool(Button)> ButtonSignalType;
/**
* @brief This signal is emitted when the button is touched.
ButtonSignalType& StateChangedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] implementation The Control implementation
*/
- DALI_INTERNAL Button( Internal::Button& implementation );
+ DALI_INTERNAL Button(Internal::Button& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor
*/
- DALI_INTERNAL Button( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL Button(Dali::Internal::CustomActor* internal);
/// @endcond
};
namespace Dali
{
-
namespace Toolkit
{
-
CheckBoxButton::CheckBoxButton()
: Button()
{
}
-CheckBoxButton::CheckBoxButton( const CheckBoxButton& checkBox ) = default;
+CheckBoxButton::CheckBoxButton(const CheckBoxButton& checkBox) = default;
-CheckBoxButton::CheckBoxButton( CheckBoxButton&& rhs ) = default;
+CheckBoxButton::CheckBoxButton(CheckBoxButton&& rhs) = default;
-CheckBoxButton& CheckBoxButton::operator=( const CheckBoxButton& checkBox ) = default;
+CheckBoxButton& CheckBoxButton::operator=(const CheckBoxButton& checkBox) = default;
-CheckBoxButton& CheckBoxButton::operator=( CheckBoxButton&& rhs ) = default;
+CheckBoxButton& CheckBoxButton::operator=(CheckBoxButton&& rhs) = default;
CheckBoxButton::~CheckBoxButton()
{
return Internal::CheckBoxButton::New();
}
-CheckBoxButton CheckBoxButton::DownCast( BaseHandle handle )
+CheckBoxButton CheckBoxButton::DownCast(BaseHandle handle)
{
return Control::DownCast<CheckBoxButton, Internal::CheckBoxButton>(handle);
}
-CheckBoxButton::CheckBoxButton( Internal::CheckBoxButton& implementation )
-: Button( implementation )
+CheckBoxButton::CheckBoxButton(Internal::CheckBoxButton& implementation)
+: Button(implementation)
{
}
-CheckBoxButton::CheckBoxButton( Dali::Internal::CustomActor* internal )
-: Button( internal )
+CheckBoxButton::CheckBoxButton(Dali::Internal::CustomActor* internal)
+: Button(internal)
{
VerifyCustomActorPointer<Internal::CheckBoxButton>(internal);
}
namespace Dali
{
-
namespace Toolkit
{
-
// Forward declarations
namespace Internal DALI_INTERNAL
class DALI_TOOLKIT_API CheckBoxButton : public Button
{
public:
-
/**
* @brief Creates an uninitialized CheckBoxButton; this can be initialized with CheckBoxButton::New().
* Calling member functions with an uninitialized Dali::Object is not allowed.
* @SINCE_1_0.0
* @param[in] checkBox Handle to an object
*/
- CheckBoxButton( const CheckBoxButton& checkBox );
+ CheckBoxButton(const CheckBoxButton& checkBox);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- CheckBoxButton( CheckBoxButton&& rhs );
+ CheckBoxButton(CheckBoxButton&& rhs);
/**
* @brief Assignment operator.
* @param[in] checkBox Handle to an object
* @return A reference to this
*/
- CheckBoxButton& operator=( const CheckBoxButton& checkBox );
+ CheckBoxButton& operator=(const CheckBoxButton& checkBox);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- CheckBoxButton& operator=( CheckBoxButton&& rhs );
+ CheckBoxButton& operator=(CheckBoxButton&& rhs);
/**
* @brief Destructor.
* @param[in] handle Handle to an object
* @return Handle to a CheckBoxButton or an uninitialized handle
*/
- static CheckBoxButton DownCast( BaseHandle handle );
+ static CheckBoxButton DownCast(BaseHandle handle);
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] implementation The Control implementation
*/
- DALI_INTERNAL CheckBoxButton( Internal::CheckBoxButton& implementation );
+ DALI_INTERNAL CheckBoxButton(Internal::CheckBoxButton& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor
*/
- DALI_INTERNAL CheckBoxButton( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL CheckBoxButton(Dali::Internal::CustomActor* internal);
/// @endcond
};
// EXTERNAL INCLUDES
#include <dali/integration-api/debug.h>
-
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/buttons/push-button-impl.h>
namespace Dali
{
-
namespace Toolkit
{
-
PushButton::PushButton()
: Button()
{
}
-PushButton::PushButton( Internal::PushButton& implementation )
-: Button( implementation )
+PushButton::PushButton(Internal::PushButton& implementation)
+: Button(implementation)
{
}
-PushButton::PushButton( const PushButton& pushButton ) = default;
+PushButton::PushButton(const PushButton& pushButton) = default;
-PushButton::PushButton( PushButton&& rhs ) = default;
+PushButton::PushButton(PushButton&& rhs) = default;
-PushButton& PushButton::operator=( const PushButton& pushButton ) = default;
+PushButton& PushButton::operator=(const PushButton& pushButton) = default;
-PushButton& PushButton::operator=( PushButton&& rhs ) = default;
+PushButton& PushButton::operator=(PushButton&& rhs) = default;
-PushButton::PushButton( Dali::Internal::CustomActor* internal )
-: Button( internal )
+PushButton::PushButton(Dali::Internal::CustomActor* internal)
+: Button(internal)
{
VerifyCustomActorPointer<Internal::PushButton>(internal);
}
return Internal::PushButton::New();
}
-PushButton PushButton::DownCast( BaseHandle handle )
+PushButton PushButton::DownCast(BaseHandle handle)
{
return Control::DownCast<PushButton, Internal::PushButton>(handle);
}
namespace Dali
{
-
namespace Toolkit
{
-
// Forward declarations
namespace Internal DALI_INTERNAL
// Forward declarations
class PushButton;
-}
+} // namespace DALI_INTERNAL
/**
* @addtogroup dali_toolkit_controls_buttons
* @{
class DALI_TOOLKIT_API PushButton : public Button
{
public:
-
/**
* @brief Enumeration for the start and end property ranges for this control.
* @SINCE_1_0.0
*/
enum PropertyRange
{
- PROPERTY_START_INDEX = Button::PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserving 1000 property indices @SINCE_1_0.0
+ PROPERTY_START_INDEX = Button::PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserving 1000 property indices @SINCE_1_0.0
};
/**
*/
enum
{
- LABEL_PADDING = PROPERTY_START_INDEX, ///< Property, name "labelPadding", type Vector4 @SINCE_1_0.0
- ICON_PADDING, ///< Property, name "iconPadding", type Vector4 @SINCE_1_0.0
+ LABEL_PADDING = PROPERTY_START_INDEX, ///< Property, name "labelPadding", type Vector4 @SINCE_1_0.0
+ ICON_PADDING, ///< Property, name "iconPadding", type Vector4 @SINCE_1_0.0
};
};
public:
-
/**
* @brief Creates an uninitialized PushButton; this can be initialized with PushButton::New().
*
* @SINCE_1_0.0
* @param[in] pushButton Handle to an object
*/
- PushButton( const PushButton& pushButton );
+ PushButton(const PushButton& pushButton);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- PushButton( PushButton&& rhs );
+ PushButton(PushButton&& rhs);
/**
* @brief Assignment operator.
* @param[in] pushButton Handle to an object
* @return A reference to this
*/
- PushButton& operator=( const PushButton& pushButton );
+ PushButton& operator=(const PushButton& pushButton);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- PushButton& operator=( PushButton&& rhs );
+ PushButton& operator=(PushButton&& rhs);
/**
* @brief Destructor.
* @param[in] handle Handle to an object
* @return handle to a PushButton or an uninitialized handle
*/
- static PushButton DownCast( BaseHandle handle );
+ static PushButton DownCast(BaseHandle handle);
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] implementation The Control implementation
*/
- DALI_INTERNAL PushButton( Internal::PushButton& implementation );
+ DALI_INTERNAL PushButton(Internal::PushButton& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor
*/
- DALI_INTERNAL PushButton( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL PushButton(Dali::Internal::CustomActor* internal);
/// @endcond
};
namespace Dali
{
-
namespace Toolkit
{
-
RadioButton::RadioButton()
- : Button()
+: Button()
{
}
-RadioButton::RadioButton( Internal::RadioButton& implementation )
- : Button( implementation )
+RadioButton::RadioButton(Internal::RadioButton& implementation)
+: Button(implementation)
{
}
-RadioButton::RadioButton( const RadioButton& radioButton ) = default;
+RadioButton::RadioButton(const RadioButton& radioButton) = default;
-RadioButton::RadioButton( RadioButton&& rhs ) = default;
+RadioButton::RadioButton(RadioButton&& rhs) = default;
-RadioButton& RadioButton::operator=( const RadioButton& radioButton ) = default;
+RadioButton& RadioButton::operator=(const RadioButton& radioButton) = default;
-RadioButton& RadioButton::operator=( RadioButton&& rhs ) = default;
+RadioButton& RadioButton::operator=(RadioButton&& rhs) = default;
-RadioButton::RadioButton( Dali::Internal::CustomActor* internal )
- : Button( internal )
+RadioButton::RadioButton(Dali::Internal::CustomActor* internal)
+: Button(internal)
{
- VerifyCustomActorPointer<Internal::RadioButton>( internal );
+ VerifyCustomActorPointer<Internal::RadioButton>(internal);
}
RadioButton::~RadioButton()
return Internal::RadioButton::New();
}
-RadioButton RadioButton::New( const std::string& label )
+RadioButton RadioButton::New(const std::string& label)
{
RadioButton radioButton = Internal::RadioButton::New();
- radioButton.SetProperty( Toolkit::Button::Property::LABEL, label );
+ radioButton.SetProperty(Toolkit::Button::Property::LABEL, label);
return radioButton;
}
-RadioButton RadioButton::DownCast( BaseHandle handle )
+RadioButton RadioButton::DownCast(BaseHandle handle)
{
- return Control::DownCast<RadioButton, Internal::RadioButton>( handle );
+ return Control::DownCast<RadioButton, Internal::RadioButton>(handle);
}
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
// Forward declarations
namespace Internal DALI_INTERNAL
// Forward declarations
class RadioButton;
-}
+} // namespace DALI_INTERNAL
/**
* @addtogroup dali_toolkit_controls_buttons
* @{
* @endcode
* @SINCE_1_0.0
*/
-class DALI_TOOLKIT_API RadioButton: public Button
+class DALI_TOOLKIT_API RadioButton : public Button
{
- public:
+public:
/**
* @brief Creates an uninitialized RadioButton; this can be initialized with RadioButton::New().
*
* @SINCE_1_0.0
* @param[in] radioButton Handle to an object
*/
- RadioButton( const RadioButton& radioButton );
+ RadioButton(const RadioButton& radioButton);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- RadioButton( RadioButton&& rhs );
+ RadioButton(RadioButton&& rhs);
/**
* @brief Assignment operator.
* @param[in] radioButton Handle to an object
* @return A reference to this
*/
- RadioButton& operator=( const RadioButton& radioButton );
+ RadioButton& operator=(const RadioButton& radioButton);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- RadioButton& operator=( RadioButton&& rhs );
+ RadioButton& operator=(RadioButton&& rhs);
/**
* @brief Destructor.
* @param[in] label The button label
* @return A handle to a newly allocated Dali resource
*/
- static RadioButton New( const std::string& label );
+ static RadioButton New(const std::string& label);
/**
* @brief Downcasts a handle to RadioButton handle.
* @param[in] handle Handle to an object
* @return A handle to a RadioButton or an uninitialized handle
*/
- static RadioButton DownCast( BaseHandle handle );
-
- public: // Not intended for application developers
+ static RadioButton DownCast(BaseHandle handle);
+public: // Not intended for application developers
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] implementation The Control implementation
*/
- DALI_INTERNAL RadioButton( Internal::RadioButton& implementation );
+ DALI_INTERNAL RadioButton(Internal::RadioButton& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor
*/
- DALI_INTERNAL RadioButton( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL RadioButton(Dali::Internal::CustomActor* internal);
/// @endcond
};
#include <dali-toolkit/public-api/controls/control-impl.h>
// EXTERNAL INCLUDES
+#include <dali/devel-api/scripting/scripting.h>
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/animation/constraint.h>
+#include <dali/public-api/object/type-registry-helper.h>
+#include <dali/public-api/size-negotiation/relayout-container.h>
#include <cstring> // for strcmp
#include <limits>
#include <stack>
#include <typeinfo>
-#include <dali/public-api/animation/constraint.h>
-#include <dali/public-api/object/type-registry-helper.h>
-#include <dali/public-api/size-negotiation/relayout-container.h>
-#include <dali/devel-api/scripting/scripting.h>
-#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/align-enumerations.h>
-#include <dali-toolkit/public-api/controls/control.h>
-#include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
-#include <dali-toolkit/public-api/styling/style-manager.h>
-#include <dali-toolkit/public-api/visuals/color-visual-properties.h>
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
#include <dali-toolkit/devel-api/controls/control-devel.h>
#include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
-#include <dali-toolkit/devel-api/visuals/color-visual-properties-devel.h>
#include <dali-toolkit/devel-api/visuals/color-visual-actions-devel.h>
+#include <dali-toolkit/devel-api/visuals/color-visual-properties-devel.h>
+#include <dali-toolkit/internal/controls/control/control-data-impl.h>
#include <dali-toolkit/internal/styling/style-manager-impl.h>
#include <dali-toolkit/internal/visuals/color/color-visual.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
-#include <dali-toolkit/internal/controls/control/control-data-impl.h>
+#include <dali-toolkit/public-api/align-enumerations.h>
+#include <dali-toolkit/public-api/controls/control.h>
+#include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
+#include <dali-toolkit/public-api/styling/style-manager.h>
+#include <dali-toolkit/public-api/visuals/color-visual-properties.h>
+#include <dali-toolkit/public-api/visuals/visual-properties.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal
{
-
namespace
{
-
#if defined(DEBUG_ENABLED)
-Debug::Filter* gLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_CONTROL_VISUALS");
+Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_CONTROL_VISUALS");
#endif
/**
* @param[in] controlImpl The control implementation
* @param[in] renderIfTransaparent Whether we should render if the color is transparent
*/
-void ChangeBackgroundColorVisual( Control& controlImpl, bool renderIfTransparent )
+void ChangeBackgroundColorVisual(Control& controlImpl, bool renderIfTransparent)
{
- Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( controlImpl );
+ Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(controlImpl);
- Toolkit::Visual::Base backgroundVisual = controlDataImpl.GetVisual( Toolkit::Control::Property::BACKGROUND );
- if( backgroundVisual && backgroundVisual.GetType() == Toolkit::Visual::COLOR )
+ Toolkit::Visual::Base backgroundVisual = controlDataImpl.GetVisual(Toolkit::Control::Property::BACKGROUND);
+ if(backgroundVisual && backgroundVisual.GetType() == Toolkit::Visual::COLOR)
{
Property::Map map;
- backgroundVisual.CreatePropertyMap( map );
+ backgroundVisual.CreatePropertyMap(map);
// Only change it if it's a color visual
- map[ Toolkit::DevelColorVisual::Property::RENDER_IF_TRANSPARENT ] = renderIfTransparent;
- controlImpl.SetBackground( map );
+ map[Toolkit::DevelColorVisual::Property::RENDER_IF_TRANSPARENT] = renderIfTransparent;
+ controlImpl.SetBackground(map);
}
}
* (EG. If no renders exist and clipping is enabled).
* @param[in] controlImpl The control implementation.
*/
-void CreateClippingRenderer( Control& controlImpl )
+void CreateClippingRenderer(Control& controlImpl)
{
// We want to add a transparent background if we do not have one for clipping.
- Actor self( controlImpl.Self() );
- int clippingMode = ClippingMode::DISABLED;
- if( self.GetProperty( Actor::Property::CLIPPING_MODE ).Get( clippingMode ) )
+ Actor self(controlImpl.Self());
+ int clippingMode = ClippingMode::DISABLED;
+ if(self.GetProperty(Actor::Property::CLIPPING_MODE).Get(clippingMode))
{
- switch( clippingMode )
+ switch(clippingMode)
{
case ClippingMode::CLIP_CHILDREN:
{
- if( self.GetRendererCount() == 0u )
+ if(self.GetRendererCount() == 0u)
{
- Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( controlImpl );
- if( controlDataImpl.mVisuals.Empty() )
+ Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(controlImpl);
+ if(controlDataImpl.mVisuals.Empty())
{
- controlImpl.SetBackgroundColor( Color::TRANSPARENT );
+ controlImpl.SetBackgroundColor(Color::TRANSPARENT);
}
else
{
// We have visuals, check if we've set the background and re-create it to
// render even if transparent (only if it's a color visual)
- ChangeBackgroundColorVisual( controlImpl, true );
+ ChangeBackgroundColorVisual(controlImpl, true);
}
}
break;
case ClippingMode::CLIP_TO_BOUNDING_BOX:
{
// If we have a background visual, check if it's a color visual and remove the render if transparent flag
- ChangeBackgroundColorVisual( controlImpl, false );
+ ChangeBackgroundColorVisual(controlImpl, false);
break;
}
}
} // unnamed namespace
-
Toolkit::Control Control::New()
{
// Create the implementation, temporarily owned on stack
- IntrusivePtr<Control> controlImpl = new Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) );
+ IntrusivePtr<Control> controlImpl = new Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT));
// Pass ownership to handle
- Toolkit::Control handle( *controlImpl );
+ Toolkit::Control handle(*controlImpl);
// Second-phase init of the implementation
// This can only be done after the CustomActor connection has been made...
return handle;
}
-void Control::SetStyleName( const std::string& styleName )
+void Control::SetStyleName(const std::string& styleName)
{
- if( styleName != mImpl->mStyleName )
+ if(styleName != mImpl->mStyleName)
{
mImpl->mStyleName = styleName;
// Apply new style, if stylemanager is available
Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
- if( styleManager )
+ if(styleManager)
{
- GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
+ GetImpl(styleManager).ApplyThemeStyle(Toolkit::Control(GetOwner()));
}
}
}
return mImpl->mStyleName;
}
-void Control::SetBackgroundColor( const Vector4& color )
+void Control::SetBackgroundColor(const Vector4& color)
{
mImpl->mBackgroundColor = color;
Property::Map map;
- map[ Toolkit::Visual::Property::TYPE ] = Toolkit::Visual::COLOR;
- map[ Toolkit::ColorVisual::Property::MIX_COLOR ] = color;
+ map[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::COLOR;
+ map[Toolkit::ColorVisual::Property::MIX_COLOR] = color;
bool renderIfTransparent = false;
- int clippingMode = ClippingMode::DISABLED;
- if( ( Self().GetProperty( Actor::Property::CLIPPING_MODE ).Get( clippingMode ) ) &&
- ( clippingMode == ClippingMode::CLIP_CHILDREN ) )
+ int clippingMode = ClippingMode::DISABLED;
+ if((Self().GetProperty(Actor::Property::CLIPPING_MODE).Get(clippingMode)) &&
+ (clippingMode == ClippingMode::CLIP_CHILDREN))
{
// If clipping-mode is set to CLIP_CHILDREN, then force visual to add the render even if transparent
- map[ Toolkit::DevelColorVisual::Property::RENDER_IF_TRANSPARENT ] = true;
- renderIfTransparent = true;
+ map[Toolkit::DevelColorVisual::Property::RENDER_IF_TRANSPARENT] = true;
+ renderIfTransparent = true;
}
- Toolkit::Visual::Base visual = mImpl->GetVisual( Toolkit::Control::Property::BACKGROUND );
- if( visual && visual.GetType() == Toolkit::Visual::COLOR )
+ Toolkit::Visual::Base visual = mImpl->GetVisual(Toolkit::Control::Property::BACKGROUND);
+ if(visual && visual.GetType() == Toolkit::Visual::COLOR)
{
Property::Map visualMap;
- visual.CreatePropertyMap( visualMap );
+ visual.CreatePropertyMap(visualMap);
- Property::Value* renderValue = visualMap.Find( Toolkit::DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
- Property::Value* colorValue = visualMap.Find( Toolkit::ColorVisual::Property::MIX_COLOR );
- if( renderValue && colorValue )
+ Property::Value* renderValue = visualMap.Find(Toolkit::DevelColorVisual::Property::RENDER_IF_TRANSPARENT);
+ Property::Value* colorValue = visualMap.Find(Toolkit::ColorVisual::Property::MIX_COLOR);
+ if(renderValue && colorValue)
{
- if( ( renderValue->Get< bool >() == true || colorValue->Get< Vector4 >().a > 0.0f )
- && ( renderIfTransparent || color.a > 0.0f ) )
+ if((renderValue->Get<bool>() == true || colorValue->Get<Vector4>().a > 0.0f) && (renderIfTransparent || color.a > 0.0f))
{
// Update background color only
- mImpl->DoAction( Toolkit::Control::Property::BACKGROUND, DevelColorVisual::Action::UPDATE_PROPERTY, map );
+ mImpl->DoAction(Toolkit::Control::Property::BACKGROUND, DevelColorVisual::Action::UPDATE_PROPERTY, map);
return;
}
}
}
- SetBackground( map );
+ SetBackground(map);
}
-void Control::SetBackground( const Property::Map& map )
+void Control::SetBackground(const Property::Map& map)
{
- Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual( map );
+ Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual(map);
visual.SetName("background");
- if( visual )
+ if(visual)
{
- mImpl->RegisterVisual( Toolkit::Control::Property::BACKGROUND, visual, DepthIndex::BACKGROUND );
+ mImpl->RegisterVisual(Toolkit::Control::Property::BACKGROUND, visual, DepthIndex::BACKGROUND);
// Trigger a size negotiation request that may be needed by the new visual to relayout its contents.
RelayoutRequest();
void Control::ClearBackground()
{
- mImpl->UnregisterVisual( Toolkit::Control::Property::BACKGROUND );
- mImpl->mBackgroundColor = Color::TRANSPARENT;
+ mImpl->UnregisterVisual(Toolkit::Control::Property::BACKGROUND);
+ mImpl->mBackgroundColor = Color::TRANSPARENT;
- // Trigger a size negotiation request that may be needed when unregistering a visual.
- RelayoutRequest();
+ // Trigger a size negotiation request that may be needed when unregistering a visual.
+ RelayoutRequest();
}
void Control::EnableGestureDetection(GestureType::Value type)
{
- if ( (type & GestureType::PINCH) && !mImpl->mPinchGestureDetector )
+ if((type & GestureType::PINCH) && !mImpl->mPinchGestureDetector)
{
mImpl->mPinchGestureDetector = PinchGestureDetector::New();
mImpl->mPinchGestureDetector.DetectedSignal().Connect(mImpl, &Impl::PinchDetected);
mImpl->mPinchGestureDetector.Attach(Self());
}
- if ( (type & GestureType::PAN) && !mImpl->mPanGestureDetector )
+ if((type & GestureType::PAN) && !mImpl->mPanGestureDetector)
{
mImpl->mPanGestureDetector = PanGestureDetector::New();
mImpl->mPanGestureDetector.DetectedSignal().Connect(mImpl, &Impl::PanDetected);
mImpl->mPanGestureDetector.Attach(Self());
}
- if ( (type & GestureType::TAP) && !mImpl->mTapGestureDetector )
+ if((type & GestureType::TAP) && !mImpl->mTapGestureDetector)
{
mImpl->mTapGestureDetector = TapGestureDetector::New();
mImpl->mTapGestureDetector.DetectedSignal().Connect(mImpl, &Impl::TapDetected);
mImpl->mTapGestureDetector.Attach(Self());
}
- if ( (type & GestureType::LONG_PRESS) && !mImpl->mLongPressGestureDetector )
+ if((type & GestureType::LONG_PRESS) && !mImpl->mLongPressGestureDetector)
{
mImpl->mLongPressGestureDetector = LongPressGestureDetector::New();
mImpl->mLongPressGestureDetector.DetectedSignal().Connect(mImpl, &Impl::LongPressDetected);
void Control::DisableGestureDetection(GestureType::Value type)
{
- if ( (type & GestureType::PINCH) && mImpl->mPinchGestureDetector )
+ if((type & GestureType::PINCH) && mImpl->mPinchGestureDetector)
{
mImpl->mPinchGestureDetector.Detach(Self());
mImpl->mPinchGestureDetector.Reset();
}
- if ( (type & GestureType::PAN) && mImpl->mPanGestureDetector )
+ if((type & GestureType::PAN) && mImpl->mPanGestureDetector)
{
mImpl->mPanGestureDetector.Detach(Self());
mImpl->mPanGestureDetector.Reset();
}
- if ( (type & GestureType::TAP) && mImpl->mTapGestureDetector )
+ if((type & GestureType::TAP) && mImpl->mTapGestureDetector)
{
mImpl->mTapGestureDetector.Detach(Self());
mImpl->mTapGestureDetector.Reset();
}
- if ( (type & GestureType::LONG_PRESS) && mImpl->mLongPressGestureDetector)
+ if((type & GestureType::LONG_PRESS) && mImpl->mLongPressGestureDetector)
{
mImpl->mLongPressGestureDetector.Detach(Self());
mImpl->mLongPressGestureDetector.Reset();
void Control::SetKeyInputFocus()
{
- if( Self().GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) )
+ if(Self().GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE))
{
Toolkit::KeyInputFocusManager::Get().SetFocus(Toolkit::Control::DownCast(Self()));
}
bool Control::HasKeyInputFocus()
{
bool result = false;
- if( Self().GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) )
+ if(Self().GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE))
{
Toolkit::Control control = Toolkit::KeyInputFocusManager::Get().GetCurrentFocusControl();
- if( Self() == control )
+ if(Self() == control)
{
result = true;
}
void Control::ClearKeyInputFocus()
{
- if( Self().GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) )
+ if(Self().GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE))
{
Toolkit::KeyInputFocusManager::Get().RemoveFocus(Toolkit::Control::DownCast(Self()));
}
return mImpl->mKeyInputFocusLostSignal;
}
-bool Control::EmitKeyEventSignal( const KeyEvent& event )
+bool Control::EmitKeyEventSignal(const KeyEvent& event)
{
// Guard against destruction during signal emission
- Dali::Toolkit::Control handle( GetOwner() );
+ Dali::Toolkit::Control handle(GetOwner());
bool consumed = false;
- consumed = mImpl->FilterKeyEvent( event );
+ consumed = mImpl->FilterKeyEvent(event);
// signals are allocated dynamically when someone connects
- if ( !consumed && !mImpl->mKeyEventSignal.Empty() )
+ if(!consumed && !mImpl->mKeyEventSignal.Empty())
{
- consumed = mImpl->mKeyEventSignal.Emit( handle, event );
+ consumed = mImpl->mKeyEventSignal.Emit(handle, event);
}
- if ( !consumed )
+ if(!consumed)
{
// Notification for derived classes
consumed = OnKeyEvent(event);
return consumed;
}
-Control::Control( ControlBehaviour behaviourFlags )
-: CustomActorImpl( static_cast< ActorFlags >( behaviourFlags ) ),
+Control::Control(ControlBehaviour behaviourFlags)
+: CustomActorImpl(static_cast<ActorFlags>(behaviourFlags)),
mImpl(new Impl(*this))
{
mImpl->mFlags = behaviourFlags;
// Call deriving classes so initialised before styling is applied to them.
OnInitialize();
- if( !(mImpl->mFlags & DISABLE_STYLE_CHANGE_SIGNALS) )
+ if(!(mImpl->mFlags & DISABLE_STYLE_CHANGE_SIGNALS))
{
Toolkit::StyleManager styleManager = StyleManager::Get();
// if stylemanager is available
- if( styleManager )
+ if(styleManager)
{
- StyleManager& styleManagerImpl = GetImpl( styleManager );
+ StyleManager& styleManagerImpl = GetImpl(styleManager);
// Register for style changes
- styleManagerImpl.ControlStyleChangeSignal().Connect( this, &Control::OnStyleChange );
+ styleManagerImpl.ControlStyleChangeSignal().Connect(this, &Control::OnStyleChange);
// Apply the current style
- styleManagerImpl.ApplyThemeStyleAtInit( Toolkit::Control( GetOwner() ) );
+ styleManagerImpl.ApplyThemeStyleAtInit(Toolkit::Control(GetOwner()));
}
}
- if( mImpl->mFlags & REQUIRES_KEYBOARD_NAVIGATION_SUPPORT )
+ if(mImpl->mFlags & REQUIRES_KEYBOARD_NAVIGATION_SUPPORT)
{
- SetKeyboardNavigationSupport( true );
+ SetKeyboardNavigationSupport(true);
}
}
{
}
-void Control::OnStyleChange( Toolkit::StyleManager styleManager, StyleChange::Type change )
+void Control::OnStyleChange(Toolkit::StyleManager styleManager, StyleChange::Type change)
{
// By default the control is only interested in theme (not font) changes
- if( styleManager && change == StyleChange::THEME_CHANGE )
+ if(styleManager && change == StyleChange::THEME_CHANGE)
{
- GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
+ GetImpl(styleManager).ApplyThemeStyle(Toolkit::Control(GetOwner()));
RelayoutRequest();
}
}
void Control::OnPinch(const PinchGesture& pinch)
{
- if( !( mImpl->mStartingPinchScale ) )
+ if(!(mImpl->mStartingPinchScale))
{
// lazy allocate
mImpl->mStartingPinchScale = new Vector3;
}
- if( pinch.GetState() == GestureState::STARTED )
+ if(pinch.GetState() == GestureState::STARTED)
{
- *( mImpl->mStartingPinchScale ) = Self().GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
+ *(mImpl->mStartingPinchScale) = Self().GetCurrentProperty<Vector3>(Actor::Property::SCALE);
}
- Self().SetProperty( Actor::Property::SCALE, *( mImpl->mStartingPinchScale ) * pinch.GetScale() );
+ Self().SetProperty(Actor::Property::SCALE, *(mImpl->mStartingPinchScale) * pinch.GetScale());
}
-void Control::OnPan( const PanGesture& pan )
+void Control::OnPan(const PanGesture& pan)
{
}
{
}
-void Control::OnLongPress( const LongPressGesture& longPress )
+void Control::OnLongPress(const LongPressGesture& longPress)
{
}
-void Control::EmitKeyInputFocusSignal( bool focusGained )
+void Control::EmitKeyInputFocusSignal(bool focusGained)
{
- Dali::Toolkit::Control handle( GetOwner() );
+ Dali::Toolkit::Control handle(GetOwner());
- if ( focusGained )
+ if(focusGained)
{
// signals are allocated dynamically when someone connects
- if ( !mImpl->mKeyInputFocusGainedSignal.Empty() )
+ if(!mImpl->mKeyInputFocusGainedSignal.Empty())
{
- mImpl->mKeyInputFocusGainedSignal.Emit( handle );
+ mImpl->mKeyInputFocusGainedSignal.Emit(handle);
}
}
else
{
// signals are allocated dynamically when someone connects
- if ( !mImpl->mKeyInputFocusLostSignal.Empty() )
+ if(!mImpl->mKeyInputFocusLostSignal.Empty())
{
- mImpl->mKeyInputFocusLostSignal.Emit( handle );
+ mImpl->mKeyInputFocusLostSignal.Emit(handle);
}
}
}
-void Control::OnSceneConnection( int depth )
+void Control::OnSceneConnection(int depth)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::OnSceneConnection number of registered visuals(%d)\n", mImpl->mVisuals.Size() );
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Control::OnSceneConnection number of registered visuals(%d)\n", mImpl->mVisuals.Size());
- Actor self( Self() );
+ Actor self(Self());
- for(RegisteredVisualContainer::Iterator iter = mImpl->mVisuals.Begin(); iter!= mImpl->mVisuals.End(); iter++)
+ for(RegisteredVisualContainer::Iterator iter = mImpl->mVisuals.Begin(); iter != mImpl->mVisuals.End(); iter++)
{
// Check whether the visual is empty and enabled
- if( (*iter)->visual && (*iter)->enabled )
+ if((*iter)->visual && (*iter)->enabled)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::OnSceneConnection Setting visual(%d) on scene\n", (*iter)->index );
- Toolkit::GetImplementation((*iter)->visual).SetOnScene( self );
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Control::OnSceneConnection Setting visual(%d) on scene\n", (*iter)->index);
+ Toolkit::GetImplementation((*iter)->visual).SetOnScene(self);
}
}
// The clipping renderer is only created if required.
- CreateClippingRenderer( *this );
+ CreateClippingRenderer(*this);
// Request to be laid out when the control is connected to the Scene.
// Signal that a Relayout may be needed
}
-
void Control::OnSceneDisconnection()
{
mImpl->OnSceneDisconnection();
void Control::OnKeyInputFocusGained()
{
- EmitKeyInputFocusSignal( true );
+ EmitKeyInputFocusSignal(true);
}
void Control::OnKeyInputFocusLost()
{
- EmitKeyInputFocusSignal( false );
+ EmitKeyInputFocusSignal(false);
}
void Control::OnChildAdd(Actor& child)
{
}
-void Control::OnPropertySet( Property::Index index, const Property::Value& propertyValue )
+void Control::OnPropertySet(Property::Index index, const Property::Value& propertyValue)
{
// If the clipping mode has been set, we may need to create a renderer.
// Only do this if we are already on-stage as the OnSceneConnection will handle the off-stage clipping controls.
- if( ( index == Actor::Property::CLIPPING_MODE ) && Self().GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) )
+ if((index == Actor::Property::CLIPPING_MODE) && Self().GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE))
{
// Note: This method will handle whether creation of the renderer is required.
- CreateClippingRenderer( *this );
+ CreateClippingRenderer(*this);
}
}
void Control::OnSizeSet(const Vector3& targetSize)
{
- Toolkit::Visual::Base visual = mImpl->GetVisual( Toolkit::Control::Property::BACKGROUND );
- if( visual )
+ Toolkit::Visual::Base visual = mImpl->GetVisual(Toolkit::Control::Property::BACKGROUND);
+ if(visual)
{
- Vector2 size( targetSize );
- visual.SetTransformAndSize( Property::Map(), size ); // Send an empty map as we do not want to modify the visual's set transform
+ Vector2 size(targetSize);
+ visual.SetTransformAndSize(Property::Map(), size); // Send an empty map as we do not want to modify the visual's set transform
}
}
return false; // Do not consume
}
-void Control::OnRelayout( const Vector2& size, RelayoutContainer& container )
+void Control::OnRelayout(const Vector2& size, RelayoutContainer& container)
{
- for( unsigned int i = 0, numChildren = Self().GetChildCount(); i < numChildren; ++i )
+ for(unsigned int i = 0, numChildren = Self().GetChildCount(); i < numChildren; ++i)
{
- Actor child = Self().GetChildAt( i );
- Vector2 newChildSize( size );
+ Actor child = Self().GetChildAt(i);
+ Vector2 newChildSize(size);
// When set the padding or margin on the control, child should be resized and repositioned.
- if( ( mImpl->mPadding.start != 0 ) || ( mImpl->mPadding.end != 0 ) || ( mImpl->mPadding.top != 0 ) || ( mImpl->mPadding.bottom != 0 ) ||
- ( mImpl->mMargin.start != 0 ) || ( mImpl->mMargin.end != 0 ) || ( mImpl->mMargin.top != 0 ) || ( mImpl->mMargin.bottom != 0 ) )
+ if((mImpl->mPadding.start != 0) || (mImpl->mPadding.end != 0) || (mImpl->mPadding.top != 0) || (mImpl->mPadding.bottom != 0) ||
+ (mImpl->mMargin.start != 0) || (mImpl->mMargin.end != 0) || (mImpl->mMargin.top != 0) || (mImpl->mMargin.bottom != 0))
{
Extents padding = mImpl->mPadding;
- Dali::CustomActor ownerActor(GetOwner());
- Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>( ownerActor.GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get<int>() );
+ Dali::CustomActor ownerActor(GetOwner());
+ Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>(ownerActor.GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
- if( Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection )
+ if(Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection)
{
- std::swap( padding.start, padding.end );
+ std::swap(padding.start, padding.end);
}
- newChildSize.width = size.width - ( padding.start + padding.end );
- newChildSize.height = size.height - ( padding.top + padding.bottom );
+ newChildSize.width = size.width - (padding.start + padding.end);
+ newChildSize.height = size.height - (padding.top + padding.bottom);
// Cannot use childs Position property as it can already have padding and margin applied on it,
// so we end up cumulatively applying them over and over again.
- Vector2 childOffset( 0.f, 0.f );
- childOffset.x += ( mImpl->mMargin.start + padding.start );
- childOffset.y += ( mImpl->mMargin.top + padding.top );
+ Vector2 childOffset(0.f, 0.f);
+ childOffset.x += (mImpl->mMargin.start + padding.start);
+ childOffset.y += (mImpl->mMargin.top + padding.top);
- child.SetProperty( Actor::Property::POSITION, Vector2( childOffset.x, childOffset.y ) );
+ child.SetProperty(Actor::Property::POSITION, Vector2(childOffset.x, childOffset.y));
}
- container.Add( child, newChildSize );
+ container.Add(child, newChildSize);
}
- Toolkit::Visual::Base visual = mImpl->GetVisual( Toolkit::Control::Property::BACKGROUND );
- if( visual )
+ Toolkit::Visual::Base visual = mImpl->GetVisual(Toolkit::Control::Property::BACKGROUND);
+ if(visual)
{
- visual.SetTransformAndSize( Property::Map(), size ); // Send an empty map as we do not want to modify the visual's set transform
+ visual.SetTransformAndSize(Property::Map(), size); // Send an empty map as we do not want to modify the visual's set transform
}
}
-void Control::OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
+void Control::OnSetResizePolicy(ResizePolicy::Type policy, Dimension::Type dimension)
{
}
Vector3 Control::GetNaturalSize()
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::GetNaturalSize for %s\n", Self().GetProperty< std::string >( Dali::Actor::Property::NAME ).c_str() );
- Toolkit::Visual::Base visual = mImpl->GetVisual( Toolkit::Control::Property::BACKGROUND );
- if( visual )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Control::GetNaturalSize for %s\n", Self().GetProperty<std::string>(Dali::Actor::Property::NAME).c_str());
+ Toolkit::Visual::Base visual = mImpl->GetVisual(Toolkit::Control::Property::BACKGROUND);
+ if(visual)
{
Vector2 naturalSize;
- visual.GetNaturalSize( naturalSize );
- naturalSize.width += ( mImpl->mPadding.start + mImpl->mPadding.end );
- naturalSize.height += ( mImpl->mPadding.top + mImpl->mPadding.bottom );
- return Vector3( naturalSize );
+ visual.GetNaturalSize(naturalSize);
+ naturalSize.width += (mImpl->mPadding.start + mImpl->mPadding.end);
+ naturalSize.height += (mImpl->mPadding.top + mImpl->mPadding.bottom);
+ return Vector3(naturalSize);
}
return Vector3::ZERO;
}
-float Control::CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
+float Control::CalculateChildSize(const Dali::Actor& child, Dimension::Type dimension)
{
- return CalculateChildSizeBase( child, dimension );
+ return CalculateChildSizeBase(child, dimension);
}
-float Control::GetHeightForWidth( float width )
+float Control::GetHeightForWidth(float width)
{
- return GetHeightForWidthBase( width );
+ return GetHeightForWidthBase(width);
}
-float Control::GetWidthForHeight( float height )
+float Control::GetWidthForHeight(float height)
{
- return GetWidthForHeightBase( height );
+ return GetWidthForHeightBase(height);
}
-bool Control::RelayoutDependentOnChildren( Dimension::Type dimension )
+bool Control::RelayoutDependentOnChildren(Dimension::Type dimension)
{
- return RelayoutDependentOnChildrenBase( dimension );
+ return RelayoutDependentOnChildrenBase(dimension);
}
-void Control::OnCalculateRelayoutSize( Dimension::Type dimension )
+void Control::OnCalculateRelayoutSize(Dimension::Type dimension)
{
}
-void Control::OnLayoutNegotiated( float size, Dimension::Type dimension )
+void Control::OnLayoutNegotiated(float size, Dimension::Type dimension)
{
}
-void Control::SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
+void Control::SignalConnected(SlotObserver* slotObserver, CallbackBase* callback)
{
- mImpl->SignalConnected( slotObserver, callback );
+ mImpl->SignalConnected(slotObserver, callback);
}
-void Control::SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback )
+void Control::SignalDisconnected(SlotObserver* slotObserver, CallbackBase* callback)
{
- mImpl->SignalDisconnected( slotObserver, callback );
+ mImpl->SignalDisconnected(slotObserver, callback);
}
-Control& GetImplementation( Dali::Toolkit::Control& handle )
+Control& GetImplementation(Dali::Toolkit::Control& handle)
{
CustomActorImpl& customInterface = handle.GetImplementation();
// downcast to control
- Control& impl = dynamic_cast< Internal::Control& >( customInterface );
+ Control& impl = dynamic_cast<Internal::Control&>(customInterface);
return impl;
}
-const Control& GetImplementation( const Dali::Toolkit::Control& handle )
+const Control& GetImplementation(const Dali::Toolkit::Control& handle)
{
const CustomActorImpl& customInterface = handle.GetImplementation();
// downcast to control
- const Control& impl = dynamic_cast< const Internal::Control& >( customInterface );
+ const Control& impl = dynamic_cast<const Internal::Control&>(customInterface);
return impl;
}
{
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_controls
* @{
namespace Internal
{
-
/**
* @brief This is the internal base class for all controls.
*
class DALI_TOOLKIT_API Control : public CustomActorImpl, public ConnectionTrackerInterface
{
public:
-
class Extension; ///< Forward declare future extension interface
// Creation & Destruction
/**
* @copydoc Dali::Toolkit::Control::SetStyleName
*/
- void SetStyleName( const std::string& styleName );
+ void SetStyleName(const std::string& styleName);
/**
* @copydoc Dali::Toolkit::Control::GetStyleName
/**
* @copydoc Dali::Toolkit::Control::SetBackgroundColor
*/
- void SetBackgroundColor( const Vector4& color );
+ void SetBackgroundColor(const Vector4& color);
/**
* @brief Sets the background with a property map.
* @SINCE_1_0.0
* @param[in] type The gesture type(s) to enable
*/
- void EnableGestureDetection( GestureType::Value type );
+ void EnableGestureDetection(GestureType::Value type);
/**
* @brief Allows deriving classes to disable any of the gesture detectors.
* @param[in] type The gesture type(s) to disable
* @see EnableGetureDetection
*/
- void DisableGestureDetection( GestureType::Value type );
+ void DisableGestureDetection(GestureType::Value type);
/**
* @brief If deriving classes wish to fine tune pinch gesture
* @SINCE_1_0.0
* @param[in] isSupported Whether this control supports two dimensional keyboard navigation
*/
- void SetKeyboardNavigationSupport( bool isSupported );
+ void SetKeyboardNavigationSupport(bool isSupported);
/**
* @brief Gets whether this control supports two dimensional keyboard navigation.
* @SINCE_1_0.0
* @param[in] isFocusGroup Whether this control is set as a focus group for keyboard navigation
*/
- void SetAsKeyboardFocusGroup( bool isFocusGroup );
+ void SetAsKeyboardFocusGroup(bool isFocusGroup);
/**
* @brief Gets whether this control is a focus group for keyboard navigation.
* @param[in] event The key event
* @return True if the event was consumed
*/
- DALI_INTERNAL bool EmitKeyEventSignal( const KeyEvent& event );
+ DALI_INTERNAL bool EmitKeyEventSignal(const KeyEvent& event);
/// @endcond
protected: // For derived classes to call
-
/**
* @brief Emits KeyInputFocusGained signal if true else emits KeyInputFocusLost signal.
*
* @SINCE_1_0.0
* @param[in] focusGained True if gained, False if lost
*/
- void EmitKeyInputFocusSignal( bool focusGained );
+ void EmitKeyInputFocusSignal(bool focusGained);
protected: // From CustomActorImpl
-
/**
* @copydoc CustomActorImpl::OnSceneConnection()
* @note If overridden, then an up-call to Control::OnSceneConnection MUST be made at the end.
*/
- void OnSceneConnection( int depth ) override;
+ void OnSceneConnection(int depth) override;
/**
* @copydoc CustomActorImpl::OnSceneDisconnection()
* @copydoc CustomActorImpl::OnChildAdd()
* @note If overridden, then an up-call to Control::OnChildAdd MUST be made at the end.
*/
- void OnChildAdd( Actor& child ) override;
+ void OnChildAdd(Actor& child) override;
/**
* @copydoc CustomActorImpl::OnChildRemove()
* @note If overridden, then an up-call to Control::OnChildRemove MUST be made at the end.
*/
- void OnChildRemove( Actor& child ) override;
+ void OnChildRemove(Actor& child) override;
/**
* @copydoc CustomActorImpl::OnPropertySet()
* @note If overridden, then an up-call to Control::OnChildRemove MUST be made at the end.
*/
- void OnPropertySet( Property::Index index, const Property::Value& propertyValue ) override;
+ void OnPropertySet(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc CustomActorImpl::OnSizeSet()
* @note If overridden, then an up-call to Control::OnSizeSet MUST be made at the end.
*/
- void OnSizeSet( const Vector3& targetSize ) override;
+ void OnSizeSet(const Vector3& targetSize) override;
/**
* @copydoc CustomActorImpl::OnSizeAnimation()
* @note If overridden, then an up-call to Control::OnSizeAnimation MUST be made at the end.
*/
- void OnSizeAnimation( Animation& animation, const Vector3& targetSize ) override;
+ void OnSizeAnimation(Animation& animation, const Vector3& targetSize) override;
/**
* @copydoc CustomActorImpl::OnRelayout()
*/
- void OnRelayout( const Vector2& size, RelayoutContainer& container ) override;
+ void OnRelayout(const Vector2& size, RelayoutContainer& container) override;
/**
* @copydoc CustomActorImpl::OnSetResizePolicy()
*/
- void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension ) override;
+ void OnSetResizePolicy(ResizePolicy::Type policy, Dimension::Type dimension) override;
/**
* @copydoc CustomActorImpl::GetNaturalSize()
/**
* @copydoc CustomActorImpl::CalculateChildSize()
*/
- float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension ) override;
+ float CalculateChildSize(const Dali::Actor& child, Dimension::Type dimension) override;
/**
* @copydoc CustomActorImpl::GetHeightForWidth()
*/
- float GetHeightForWidth( float width ) override;
+ float GetHeightForWidth(float width) override;
/**
* @copydoc CustomActorImpl::GetWidthForHeight()
*/
- float GetWidthForHeight( float height ) override;
+ float GetWidthForHeight(float height) override;
/**
* @copydoc CustomActorImpl::RelayoutDependentOnChildren()
*/
- bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) override;
+ bool RelayoutDependentOnChildren(Dimension::Type dimension = Dimension::ALL_DIMENSIONS) override;
/**
* @copydoc CustomActorImpl::OnCalculateRelayoutSize()
*/
- void OnCalculateRelayoutSize( Dimension::Type dimension ) override;
+ void OnCalculateRelayoutSize(Dimension::Type dimension) override;
/**
* @copydoc CustomActorImpl::OnLayoutNegotiated()
*/
- void OnLayoutNegotiated( float size, Dimension::Type dimension ) override;
+ void OnLayoutNegotiated(float size, Dimension::Type dimension) override;
protected: // Helpers for deriving classes
-
// Construction
/**
*/
enum ControlBehaviour
{
- CONTROL_BEHAVIOUR_DEFAULT = 0, ///< Default behaviour: Size negotiation is enabled & listens to Style Change signal, but doesn't receive event callbacks. @SINCE_1_2_10
+ CONTROL_BEHAVIOUR_DEFAULT = 0, ///< Default behaviour: Size negotiation is enabled & listens to Style Change signal, but doesn't receive event callbacks. @SINCE_1_2_10
- REQUIRES_KEYBOARD_NAVIGATION_SUPPORT = 1 << ( CustomActorImpl::ACTOR_FLAG_COUNT + 0 ), ///< True if needs to support keyboard navigation @SINCE_1_0.0
+ REQUIRES_KEYBOARD_NAVIGATION_SUPPORT = 1 << (CustomActorImpl::ACTOR_FLAG_COUNT + 0), ///< True if needs to support keyboard navigation @SINCE_1_0.0
- DISABLE_STYLE_CHANGE_SIGNALS = 1 << ( CustomActorImpl::ACTOR_FLAG_COUNT + 1 ), ///< True if control should not monitor style change signals @SINCE_1_2_10
+ DISABLE_STYLE_CHANGE_SIGNALS = 1 << (CustomActorImpl::ACTOR_FLAG_COUNT + 1), ///< True if control should not monitor style change signals @SINCE_1_2_10
LAST_CONTROL_BEHAVIOUR_FLAG
};
- static const int CONTROL_BEHAVIOUR_FLAG_COUNT = Log< LAST_CONTROL_BEHAVIOUR_FLAG - 1 >::value + 1; ///< Total count of flags
+ static const int CONTROL_BEHAVIOUR_FLAG_COUNT = Log<LAST_CONTROL_BEHAVIOUR_FLAG - 1>::value + 1; ///< Total count of flags
/**
* @brief Control constructor.
* @SINCE_1_0.0
* @param[in] behaviourFlags Behavioural flags from ControlBehaviour enum
*/
- Control( ControlBehaviour behaviourFlags );
+ Control(ControlBehaviour behaviourFlags);
/**
* @brief Second phase initialization.
void Initialize();
public: // API for derived classes to override
-
// Lifecycle
/**
* @param[in] styleManager The StyleManager object
* @param[in] change Information denoting what has changed
*/
- virtual void OnStyleChange( Toolkit::StyleManager styleManager, StyleChange::Type change );
+ virtual void OnStyleChange(Toolkit::StyleManager styleManager, StyleChange::Type change);
// Accessibility
* @param[in] gesture The pan gesture
* @return true if the pan gesture has been consumed by this control
*/
- virtual bool OnAccessibilityPan( PanGesture gesture );
+ virtual bool OnAccessibilityPan(PanGesture gesture);
/**
* @brief This method should be overridden by deriving classes when they wish to respond
* @param[in] isIncrease Whether the value should be increased or decreased
* @return true if the value changed action has been consumed by this control
*/
- virtual bool OnAccessibilityValueChange( bool isIncrease );
+ virtual bool OnAccessibilityValueChange(bool isIncrease);
/**
* @brief This method should be overridden by deriving classes when they wish to respond
* @param[in] loopEnabled Whether the focus movement should be looped within the control
* @return The next keyboard focusable actor in this control or an empty handle if no actor can be focused
*/
- virtual Actor GetNextKeyboardFocusableActor( Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled );
+ virtual Actor GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled);
/**
* @brief Informs this control that its chosen focusable actor will be focused.
* @SINCE_1_0.0
* @param[in] commitedFocusableActor The commited focusable actor
*/
- virtual void OnKeyboardFocusChangeCommitted( Actor commitedFocusableActor );
+ virtual void OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor);
/**
* @brief This method is called when the control has enter pressed on it.
* @param[in] event The Key Event
* @return True if the event should be consumed
*/
- virtual bool OnKeyEvent( const KeyEvent& event );
+ virtual bool OnKeyEvent(const KeyEvent& event);
// Gestures
* @note Pinch detection should be enabled via EnableGestureDetection().
* @see EnableGestureDetection
*/
- virtual void OnPinch( const PinchGesture& pinch );
+ virtual void OnPinch(const PinchGesture& pinch);
/**
* @brief Called whenever a pan gesture is detected on this control.
* @note Pan detection should be enabled via EnableGestureDetection().
* @see EnableGestureDetection
*/
- virtual void OnPan( const PanGesture& pan );
+ virtual void OnPan(const PanGesture& pan);
/**
* @brief Called whenever a tap gesture is detected on this control.
* @note Tap detection should be enabled via EnableGestureDetection().
* @see EnableGestureDetection
*/
- virtual void OnTap( const TapGesture& tap );
+ virtual void OnTap(const TapGesture& tap);
/**
* @brief Called whenever a long press gesture is detected on this control.
* @note Long press detection should be enabled via EnableGestureDetection().
* @see EnableGestureDetection
*/
- virtual void OnLongPress( const LongPressGesture& longPress );
+ virtual void OnLongPress(const LongPressGesture& longPress);
// From ConnectionTrackerInterface
/**
* @copydoc ConnectionTrackerInterface::SignalConnected
*/
- void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback ) override;
+ void SignalConnected(SlotObserver* slotObserver, CallbackBase* callback) override;
/**
* @copydoc ConnectionTrackerInterface::SignalDisconnected
*/
- void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback ) override;
+ void SignalDisconnected(SlotObserver* slotObserver, CallbackBase* callback) override;
/**
* @brief Retrieves the extension for this control.
}
private:
-
/// @cond internal
// Not copyable or movable
- DALI_INTERNAL Control( const Control& ) = delete; ///< Deleted copy constructor.
- DALI_INTERNAL Control( Control&& ) = delete; ///< Deleted move constructor.
- DALI_INTERNAL Control& operator=( const Control& ) = delete; ///< Deleted copy assignment operator.
- DALI_INTERNAL Control& operator=( Control&& ) = delete; ///< Deleted move assignment operator.
+ DALI_INTERNAL Control(const Control&) = delete; ///< Deleted copy constructor.
+ DALI_INTERNAL Control(Control&&) = delete; ///< Deleted move constructor.
+ DALI_INTERNAL Control& operator=(const Control&) = delete; ///< Deleted copy assignment operator.
+ DALI_INTERNAL Control& operator=(Control&&) = delete; ///< Deleted move assignment operator.
public:
class DALI_INTERNAL Impl; // Class declaration is public so we can internally add devel API's to the Controls Impl
private:
Impl* mImpl;
/// @endcond
-
};
/**
* @return Implementation
* @pre handle is initialized and points to a control
*/
-DALI_TOOLKIT_API Internal::Control& GetImplementation( Dali::Toolkit::Control& handle );
+DALI_TOOLKIT_API Internal::Control& GetImplementation(Dali::Toolkit::Control& handle);
/**
* @brief Gets implementation from the handle.
* @return Implementation
* @pre Handle is initialized and points to a control.
*/
-DALI_TOOLKIT_API const Internal::Control& GetImplementation( const Dali::Toolkit::Control& handle );
+DALI_TOOLKIT_API const Internal::Control& GetImplementation(const Dali::Toolkit::Control& handle);
} // namespace Internal
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/internal/controls/control/control-data-impl.h>
+#include <dali-toolkit/public-api/controls/control-impl.h>
namespace Dali
{
-
namespace Toolkit
{
-
Control Control::New()
{
return Internal::Control::New();
{
}
-Control::Control( const Control& uiControl ) = default;
+Control::Control(const Control& uiControl) = default;
-Control::Control( Control&& rhs ) = default;
+Control::Control(Control&& rhs) = default;
Control::~Control()
{
}
-Control& Control::operator=( const Control& handle ) = default;
+Control& Control::operator=(const Control& handle) = default;
-Control& Control::operator=( Control&& rhs ) = default;
+Control& Control::operator=(Control&& rhs) = default;
-Control Control::DownCast( BaseHandle handle )
+Control Control::DownCast(BaseHandle handle)
{
- return DownCast< Control, Internal::Control >(handle);
+ return DownCast<Control, Internal::Control>(handle);
}
void Control::SetKeyInputFocus()
return Internal::GetImplementation(*this).GetLongPressGestureDetector();
}
-void Control::SetStyleName( const std::string& styleName )
+void Control::SetStyleName(const std::string& styleName)
{
- Internal::GetImplementation(*this).SetStyleName( styleName );
+ Internal::GetImplementation(*this).SetStyleName(styleName);
}
const std::string& Control::GetStyleName() const
return Internal::GetImplementation(*this).GetStyleName();
}
-void Control::SetBackgroundColor( const Vector4& color )
+void Control::SetBackgroundColor(const Vector4& color)
{
- Internal::GetImplementation(*this).SetBackgroundColor( color );
+ Internal::GetImplementation(*this).SetBackgroundColor(color);
}
void Control::ClearBackground()
bool Control::IsResourceReady() const
{
- const Internal::Control& internalControl = Toolkit::Internal::GetImplementation( *this );
- const Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( internalControl );
+ const Internal::Control& internalControl = Toolkit::Internal::GetImplementation(*this);
+ const Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(internalControl);
return controlDataImpl.IsResourceReady();
}
-Toolkit::Visual::ResourceStatus Control::GetVisualResourceStatus( Dali::Property::Index index )
+Toolkit::Visual::ResourceStatus Control::GetVisualResourceStatus(Dali::Property::Index index)
{
- const Internal::Control& internalControl = Toolkit::Internal::GetImplementation( *this );
- const Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( internalControl );
- return controlDataImpl.GetVisualResourceStatus( index );
+ const Internal::Control& internalControl = Toolkit::Internal::GetImplementation(*this);
+ const Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(internalControl);
+ return controlDataImpl.GetVisualResourceStatus(index);
}
Control::KeyEventSignalType& Control::KeyEventSignal()
return Internal::GetImplementation(*this).KeyInputFocusLostSignal();
}
-Control::ResourceReadySignalType& Control::ResourceReadySignal()
+Control::ResourceReadySignalType& Control::ResourceReadySignal()
{
- Internal::Control& internalControl = Toolkit::Internal::GetImplementation( *this );
- Internal::Control::Impl& controlImpl = Internal::Control::Impl::Get( internalControl );
+ Internal::Control& internalControl = Toolkit::Internal::GetImplementation(*this);
+ Internal::Control::Impl& controlImpl = Internal::Control::Impl::Get(internalControl);
return controlImpl.mResourceReadySignal;
}
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/actors/custom-actor.h>
#include <dali-toolkit/public-api/dali-toolkit-common.h>
+#include <dali/public-api/actors/custom-actor.h>
#include <dali/public-api/events/long-press-gesture-detector.h>
#include <dali/public-api/events/pan-gesture-detector.h>
#include <dali/public-api/events/pinch-gesture-detector.h>
#include <dali/public-api/events/tap-gesture-detector.h>
-#include <dali/public-api/events/tap-gesture-detector.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/visual-properties.h>
namespace Dali
{
-
namespace Toolkit
{
-
//Forward declarations.
namespace Internal
class DALI_TOOLKIT_API Control : public CustomActor
{
public:
-
/**
* @brief Enumeration for the start and end property ranges for control.
* @SINCE_1_0.0
*/
enum PropertyRange
{
- PROPERTY_START_INDEX = PROPERTY_REGISTRATION_START_INDEX, ///< Start index is used by the property registration macro. @SINCE_1_0.0
- CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX, ///< Start index of Control properties. @SINCE_1_0.0
- CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000 ///< Reserving 1000 property indices. @SINCE_1_0.0
+ PROPERTY_START_INDEX = PROPERTY_REGISTRATION_START_INDEX, ///< Start index is used by the property registration macro. @SINCE_1_0.0
+ CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX, ///< Start index of Control properties. @SINCE_1_0.0
+ CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000 ///< Reserving 1000 property indices. @SINCE_1_0.0
};
/**
*/
enum Direction
{
- LEFT, ///< Move keyboard focus towards the left direction @SINCE_1_0.0
- RIGHT, ///< Move keyboard focus towards the right direction @SINCE_1_0.0
- UP, ///< Move keyboard focus towards the up direction @SINCE_1_0.0
- DOWN, ///< Move keyboard focus towards the down direction @SINCE_1_0.0
- PAGE_UP, ///< Move keyboard focus towards the previous page direction @SINCE_1_2.14
- PAGE_DOWN ///< Move keyboard focus towards the next page direction @SINCE_1_2.14
+ LEFT, ///< Move keyboard focus towards the left direction @SINCE_1_0.0
+ RIGHT, ///< Move keyboard focus towards the right direction @SINCE_1_0.0
+ UP, ///< Move keyboard focus towards the up direction @SINCE_1_0.0
+ DOWN, ///< Move keyboard focus towards the down direction @SINCE_1_0.0
+ PAGE_UP, ///< Move keyboard focus towards the previous page direction @SINCE_1_2.14
+ PAGE_DOWN ///< Move keyboard focus towards the next page direction @SINCE_1_2.14
};
};
// Typedefs
/// @brief Key Event signal type. @SINCE_1_0.0
- typedef Signal<bool ( Control, const KeyEvent& ) > KeyEventSignalType;
+ typedef Signal<bool(Control, const KeyEvent&)> KeyEventSignalType;
/// @brief Key InputFocusType signal type. @SINCE_1_0.0
- typedef Signal<void ( Control ) > KeyInputFocusSignalType;
+ typedef Signal<void(Control)> KeyInputFocusSignalType;
/// @brief ResourceReady signal type. @SINCE_1_2.60
- typedef Signal<void ( Control ) > ResourceReadySignalType;
+ typedef Signal<void(Control)> ResourceReadySignalType;
public: // Creation & Destruction
-
/**
* @brief Creates a new instance of a Control.
*
* @SINCE_1_9.23
* @param[in] rhs Handle to move
*/
- Control( Control&& rhs );
+ Control(Control&& rhs);
/**
* @brief Dali::Control is intended as a base class.
~Control();
public: // operators
-
/**
* @brief Copy assignment operator.
*
* @param[in] handle Object to assign this to
* @return Reference to this
*/
- Control& operator=( const Control& handle );
+ Control& operator=(const Control& handle);
/**
* @brief Move assignment operator.
* @param[in] rhs Object to assign this to
* @return Reference to this
*/
- Control& operator=( Control&& rhs );
+ Control& operator=(Control&& rhs);
public:
-
/**
* @brief Downcasts a handle to Control handle.
*
* @param[in] handle Handle to an object
* @return A handle to a Control or an uninitialized handle
*/
- static Control DownCast( BaseHandle handle );
+ static Control DownCast(BaseHandle handle);
// Key Input
* @SINCE_1_0.0
* @param[in] styleName A string matching a style described in a stylesheet
*/
- void SetStyleName( const std::string& styleName );
+ void SetStyleName(const std::string& styleName);
/**
* @brief Retrieves the name of the style to be applied to the control (if any).
*
* @note The background color fully blends with the actor color.
*/
- void SetBackgroundColor( const Vector4& color );
+ void SetBackgroundColor(const Vector4& color);
/**
* @brief Clears the background.
* @param[in] index The Property index of the visual
* @return Return the loading status (PREPARING, READY and FAILED) of visual resource
*/
- Visual::ResourceStatus GetVisualResourceStatus( const Dali::Property::Index index );
+ Visual::ResourceStatus GetVisualResourceStatus(const Dali::Property::Index index);
// Signals
ResourceReadySignalType& ResourceReadySignal();
public: // Intended for control developers
-
/**
* @brief Creates an initialized Control.
*
explicit Control(Dali::Internal::CustomActor* internal);
public: // Templates for Deriving Classes
-
/**
* @brief Template to allow deriving controls to DownCast handles to deriving handle classes.
*
* @see DownCast(BaseHandle)
*/
template<typename T, typename I>
- DALI_INTERNAL static T DownCast( BaseHandle handle )
+ DALI_INTERNAL static T DownCast(BaseHandle handle)
{
T result;
- CustomActor custom = Dali::CustomActor::DownCast( handle );
- if ( custom )
+ CustomActor custom = Dali::CustomActor::DownCast(handle);
+ if(custom)
{
CustomActorImpl& customImpl = custom.GetImplementation();
I* impl = dynamic_cast<I*>(&customImpl);
- if (impl)
+ if(impl)
{
result = T(customImpl.GetOwner());
}
{
// Can have a NULL pointer so we only need to check if the internal implementation is our class
// when there is a value.
- if (internal)
+ if(internal)
{
DALI_ASSERT_DEBUG(dynamic_cast<I*>(&CustomActor(internal).GetImplementation()));
}
}
-
};
/**
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
FlexContainer FlexContainer::New()
{
return Internal::FlexContainer::New();
{
}
-FlexContainer::FlexContainer( const FlexContainer& handle ) = default;
+FlexContainer::FlexContainer(const FlexContainer& handle) = default;
-FlexContainer::FlexContainer( FlexContainer&& rhs ) = default;
+FlexContainer::FlexContainer(FlexContainer&& rhs) = default;
-FlexContainer& FlexContainer::operator=( const FlexContainer& handle ) = default;
+FlexContainer& FlexContainer::operator=(const FlexContainer& handle) = default;
-FlexContainer& FlexContainer::operator=( FlexContainer&& rhs ) = default;
+FlexContainer& FlexContainer::operator=(FlexContainer&& rhs) = default;
FlexContainer::~FlexContainer()
{
}
-FlexContainer FlexContainer::DownCast( BaseHandle handle )
+FlexContainer FlexContainer::DownCast(BaseHandle handle)
{
return Control::DownCast<FlexContainer, Internal::FlexContainer>(handle);
}
-FlexContainer::FlexContainer( Internal::FlexContainer& implementation )
+FlexContainer::FlexContainer(Internal::FlexContainer& implementation)
: Control(implementation)
{
}
-FlexContainer::FlexContainer( Dali::Internal::CustomActor* internal )
-: Control( internal )
+FlexContainer::FlexContainer(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
- VerifyCustomActorPointer<Internal::FlexContainer>( internal );
+ VerifyCustomActorPointer<Internal::FlexContainer>(internal);
}
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class FlexContainer;
class DALI_TOOLKIT_API FlexContainer : public Control
{
public:
-
/**
* @brief Enumeration for the direction of the main axis in the flex container. This determines
* the direction that flex items are laid out in the flex container.
*/
enum FlexDirection
{
- COLUMN, ///< The flexible items are displayed vertically as a column @SINCE_1_1.35
- COLUMN_REVERSE, ///< The flexible items are displayed vertically as a column, but in reverse order @SINCE_1_1.35
- ROW, ///< The flexible items are displayed horizontally as a row @SINCE_1_1.35
- ROW_REVERSE ///< The flexible items are displayed horizontally as a row, but in reverse order @SINCE_1_1.35
+ COLUMN, ///< The flexible items are displayed vertically as a column @SINCE_1_1.35
+ COLUMN_REVERSE, ///< The flexible items are displayed vertically as a column, but in reverse order @SINCE_1_1.35
+ ROW, ///< The flexible items are displayed horizontally as a row @SINCE_1_1.35
+ ROW_REVERSE ///< The flexible items are displayed horizontally as a row, but in reverse order @SINCE_1_1.35
};
/**
*/
enum ContentDirection
{
- INHERIT, ///< Inherits the same direction from the parent @SINCE_1_1.35
- LTR, ///< From left to right @SINCE_1_1.35
- RTL ///< From right to left @SINCE_1_1.35
+ INHERIT, ///< Inherits the same direction from the parent @SINCE_1_1.35
+ LTR, ///< From left to right @SINCE_1_1.35
+ RTL ///< From right to left @SINCE_1_1.35
};
/**
*/
enum Justification
{
- JUSTIFY_FLEX_START, ///< Items are positioned at the beginning of the container @SINCE_1_1.35
- JUSTIFY_CENTER, ///< Items are positioned at the center of the container @SINCE_1_1.35
- JUSTIFY_FLEX_END, ///< Items are positioned at the end of the container @SINCE_1_1.35
- JUSTIFY_SPACE_BETWEEN, ///< Items are positioned with equal space between the lines @SINCE_1_1.35
- JUSTIFY_SPACE_AROUND ///< Items are positioned with equal space before, between, and after the lines @SINCE_1_1.35
+ JUSTIFY_FLEX_START, ///< Items are positioned at the beginning of the container @SINCE_1_1.35
+ JUSTIFY_CENTER, ///< Items are positioned at the center of the container @SINCE_1_1.35
+ JUSTIFY_FLEX_END, ///< Items are positioned at the end of the container @SINCE_1_1.35
+ JUSTIFY_SPACE_BETWEEN, ///< Items are positioned with equal space between the lines @SINCE_1_1.35
+ JUSTIFY_SPACE_AROUND ///< Items are positioned with equal space before, between, and after the lines @SINCE_1_1.35
};
/**
*/
enum Alignment
{
- ALIGN_AUTO, ///< Inherits the same alignment from the parent (only valid for "alignSelf" property) @SINCE_1_1.35
- ALIGN_FLEX_START, ///< At the beginning of the container @SINCE_1_1.35
- ALIGN_CENTER, ///< At the center of the container @SINCE_1_1.35
- ALIGN_FLEX_END, ///< At the end of the container @SINCE_1_1.35
- ALIGN_STRETCH ///< Stretch to fit the container @SINCE_1_1.35
+ ALIGN_AUTO, ///< Inherits the same alignment from the parent (only valid for "alignSelf" property) @SINCE_1_1.35
+ ALIGN_FLEX_START, ///< At the beginning of the container @SINCE_1_1.35
+ ALIGN_CENTER, ///< At the center of the container @SINCE_1_1.35
+ ALIGN_FLEX_END, ///< At the end of the container @SINCE_1_1.35
+ ALIGN_STRETCH ///< Stretch to fit the container @SINCE_1_1.35
};
/**
*/
enum WrapType
{
- NO_WRAP, ///< Flex items laid out in single line (shrunk to fit the flex container along the main axis) @SINCE_1_1.35
- WRAP ///< Flex items laid out in multiple lines if needed @SINCE_1_1.35
+ NO_WRAP, ///< Flex items laid out in single line (shrunk to fit the flex container along the main axis) @SINCE_1_1.35
+ WRAP ///< Flex items laid out in multiple lines if needed @SINCE_1_1.35
};
public:
-
/**
* @brief Enumeration for the start and end property ranges for this control.
* @SINCE_1_1.35
*/
enum PropertyRange
{
- PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_1.35
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_1.35
+ PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_1.35
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_1.35
- CHILD_PROPERTY_START_INDEX = CHILD_PROPERTY_REGISTRATION_START_INDEX, ///< @SINCE_1_1.35
- CHILD_PROPERTY_END_INDEX = CHILD_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve child property indices @SINCE_1_1.35
+ CHILD_PROPERTY_START_INDEX = CHILD_PROPERTY_REGISTRATION_START_INDEX, ///< @SINCE_1_1.35
+ CHILD_PROPERTY_END_INDEX = CHILD_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve child property indices @SINCE_1_1.35
};
/**
enum
{
// Event side child properties
- FLEX = CHILD_PROPERTY_START_INDEX, ///< name "flex", The proportion of the free space in the container the flex item will receive. If all items in the container set this property, their sizes will be proportional to the specified flex factor, type FLOAT @SINCE_1_1.35
- ALIGN_SELF, ///< name "alignSelf", The alignment of the flex item along the cross axis, which, if set, overrides the default alignment for all items in the container, @see FlexContainer::Alignment, type INTEGER @SINCE_1_1.35
- FLEX_MARGIN ///< name "flexMargin", The space around the flex item, type VECTOR4 @SINCE_1_1.35
+ FLEX = CHILD_PROPERTY_START_INDEX, ///< name "flex", The proportion of the free space in the container the flex item will receive. If all items in the container set this property, their sizes will be proportional to the specified flex factor, type FLOAT @SINCE_1_1.35
+ ALIGN_SELF, ///< name "alignSelf", The alignment of the flex item along the cross axis, which, if set, overrides the default alignment for all items in the container, @see FlexContainer::Alignment, type INTEGER @SINCE_1_1.35
+ FLEX_MARGIN ///< name "flexMargin", The space around the flex item, type VECTOR4 @SINCE_1_1.35
};
};
*
* @param[in] handle The handle to copy from
*/
- FlexContainer( const FlexContainer& handle );
+ FlexContainer(const FlexContainer& handle);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- FlexContainer( FlexContainer&& rhs );
+ FlexContainer(FlexContainer&& rhs);
/**
* @brief Assignment operator. Changes this handle to point to another real object.
* @param[in] handle Handle to an object
* @return A reference to this
*/
- FlexContainer& operator=( const FlexContainer& handle );
+ FlexContainer& operator=(const FlexContainer& handle);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- FlexContainer& operator=( FlexContainer&& rhs );
+ FlexContainer& operator=(FlexContainer&& rhs);
/**
* @brief Destructor.
* @param[in] handle Handle to an object
* @return Handle to a FlexContainer or an uninitialized handle
*/
- static FlexContainer DownCast( BaseHandle handle );
-
+ static FlexContainer DownCast(BaseHandle handle);
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
*
* @param[in] implementation The Control implementation
*/
- DALI_INTERNAL FlexContainer( Internal::FlexContainer& implementation );
+ DALI_INTERNAL FlexContainer(Internal::FlexContainer& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor
*/
- explicit DALI_INTERNAL FlexContainer( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL FlexContainer(Dali::Internal::CustomActor* internal);
/// @endcond
};
namespace Dali
{
-
namespace Toolkit
{
-
ImageView::ImageView()
{
}
-ImageView::ImageView( const ImageView& imageView ) = default;
+ImageView::ImageView(const ImageView& imageView) = default;
-ImageView::ImageView( ImageView&& rhs ) = default;
+ImageView::ImageView(ImageView&& rhs) = default;
-ImageView& ImageView::operator=( const ImageView& imageView ) = default;
+ImageView& ImageView::operator=(const ImageView& imageView) = default;
-ImageView& ImageView::operator=( ImageView&& rhs ) = default;
+ImageView& ImageView::operator=(ImageView&& rhs) = default;
ImageView::~ImageView()
{
return Internal::ImageView::New();
}
-ImageView ImageView::New( const std::string& url )
+ImageView ImageView::New(const std::string& url)
{
ImageView imageView = Internal::ImageView::New();
- imageView.SetImage( url, ImageDimensions() );
+ imageView.SetImage(url, ImageDimensions());
return imageView;
}
-ImageView ImageView::New( const std::string& url, ImageDimensions size )
+ImageView ImageView::New(const std::string& url, ImageDimensions size)
{
ImageView imageView = Internal::ImageView::New();
- imageView.SetImage( url, size );
+ imageView.SetImage(url, size);
return imageView;
}
-ImageView ImageView::DownCast( BaseHandle handle )
+ImageView ImageView::DownCast(BaseHandle handle)
{
- return Control::DownCast<ImageView, Internal::ImageView>( handle );
+ return Control::DownCast<ImageView, Internal::ImageView>(handle);
}
-void ImageView::SetImage( const std::string& url )
+void ImageView::SetImage(const std::string& url)
{
- Dali::Toolkit::GetImpl( *this ).SetImage( url, ImageDimensions() );
+ Dali::Toolkit::GetImpl(*this).SetImage(url, ImageDimensions());
}
-void ImageView::SetImage( const std::string& url, ImageDimensions size )
+void ImageView::SetImage(const std::string& url, ImageDimensions size)
{
- Dali::Toolkit::GetImpl( *this ).SetImage( url, size );
+ Dali::Toolkit::GetImpl(*this).SetImage(url, size);
}
-ImageView::ImageView( Internal::ImageView& implementation )
- : Control( implementation )
+ImageView::ImageView(Internal::ImageView& implementation)
+: Control(implementation)
{
}
-ImageView::ImageView( Dali::Internal::CustomActor* internal )
- : Control( internal )
+ImageView::ImageView(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
- VerifyCustomActorPointer<Internal::ImageView>( internal );
+ VerifyCustomActorPointer<Internal::ImageView>(internal);
}
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class ImageView;
class DALI_TOOLKIT_API ImageView : public Control
{
public:
-
/**
* @brief Enumeration for the start and end property ranges for this control.
* @SINCE_1_0.0
*/
enum PropertyRange
{
- PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_0.0
+ PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_0.0
- ANIMATABLE_PROPERTY_START_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX, ///< @SINCE_1_1.18
- ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve animatable property indices, @SINCE_1_1.18
+ ANIMATABLE_PROPERTY_START_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX, ///< @SINCE_1_1.18
+ ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve animatable property indices, @SINCE_1_1.18
};
/**
*/
PRE_MULTIPLIED_ALPHA,
-
// Animatable properties
/**
};
public:
-
/**
* @brief Creates an uninitialized ImageView.
* @SINCE_1_0.0
* @param[in] url The url of the image resource to display
* @return A handle to a newly allocated ImageView
*/
- static ImageView New( const std::string& url );
+ static ImageView New(const std::string& url);
/**
* @brief Creates an initialized ImageView from a URL to an image resource.
* However, do not set a size that is bigger than the actual image size, as up-scaling is not available.
* The content of the area not covered by the actual image is undefined and will not be cleared.
*/
- static ImageView New( const std::string& url, ImageDimensions size );
+ static ImageView New(const std::string& url, ImageDimensions size);
/**
* @brief Destructor.
* @SINCE_1_0.0
* @param[in] imageView ImageView to copy. The copied ImageView will point at the same implementation
*/
- ImageView( const ImageView& imageView );
+ ImageView(const ImageView& imageView);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- ImageView( ImageView&& rhs );
+ ImageView(ImageView&& rhs);
/**
* @brief Assignment operator.
* @param[in] imageView The ImageView to assign from
* @return The updated ImageView
*/
- ImageView& operator=( const ImageView& imageView );
+ ImageView& operator=(const ImageView& imageView);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- ImageView& operator=( ImageView&& rhs );
+ ImageView& operator=(ImageView&& rhs);
/**
* @brief Downcasts a handle to ImageView handle.
* @param[in] handle Handle to an object
* @return Handle to a ImageView or an uninitialized handle
*/
- static ImageView DownCast( BaseHandle handle );
+ static ImageView DownCast(BaseHandle handle);
/**
* @brief Sets this ImageView from the given URL.
* @REMARK_STORAGE
* @param[in] url The URL to the image resource to display
*/
- void SetImage( const std::string& url );
+ void SetImage(const std::string& url);
/**
* @brief Sets this ImageView from the given URL.
* @param[in] url The URL to the image resource to display
* @param [in] size The width and height to fit the loaded image to
*/
- void SetImage( const std::string& url, ImageDimensions size );
+ void SetImage(const std::string& url, ImageDimensions size);
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] implementation The ImageView implementation
*/
- DALI_INTERNAL ImageView( Internal::ImageView& implementation );
+ DALI_INTERNAL ImageView(Internal::ImageView& implementation);
/**
* @brief Allows the creation of this ImageView from an Internal::CustomActor pointer.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor
*/
- DALI_INTERNAL ImageView( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL ImageView(Dali::Internal::CustomActor* internal);
/// @endcond
-
};
/**
namespace Dali
{
-
namespace Toolkit
{
-
Model3dView::Model3dView()
-{}
+{
+}
-Model3dView::Model3dView( const Model3dView& model3dView ) = default;
+Model3dView::Model3dView(const Model3dView& model3dView) = default;
-Model3dView::Model3dView( Model3dView&& rhs ) = default;
+Model3dView::Model3dView(Model3dView&& rhs) = default;
-Model3dView& Model3dView::operator=( const Model3dView& model3dView ) = default;
+Model3dView& Model3dView::operator=(const Model3dView& model3dView) = default;
-Model3dView& Model3dView::operator=( Model3dView&& rhs ) = default;
+Model3dView& Model3dView::operator=(Model3dView&& rhs) = default;
Model3dView::~Model3dView()
{
return Internal::Model3dView::New();
}
-Model3dView Model3dView::New( const std::string& objUrl, const std::string& mtlUrl, const std::string& imagesUrl )
+Model3dView Model3dView::New(const std::string& objUrl, const std::string& mtlUrl, const std::string& imagesUrl)
{
Model3dView model3dView = Internal::Model3dView::New();
- model3dView.SetProperty( Model3dView::Property::GEOMETRY_URL, Dali::Property::Value( objUrl ) );
- model3dView.SetProperty( Model3dView::Property::MATERIAL_URL, Dali::Property::Value( mtlUrl ) );
- model3dView.SetProperty( Model3dView::Property::IMAGES_URL, Dali::Property::Value( imagesUrl ) );
+ model3dView.SetProperty(Model3dView::Property::GEOMETRY_URL, Dali::Property::Value(objUrl));
+ model3dView.SetProperty(Model3dView::Property::MATERIAL_URL, Dali::Property::Value(mtlUrl));
+ model3dView.SetProperty(Model3dView::Property::IMAGES_URL, Dali::Property::Value(imagesUrl));
return model3dView;
}
-Model3dView Model3dView::DownCast( BaseHandle handle )
+Model3dView Model3dView::DownCast(BaseHandle handle)
{
return Control::DownCast<Model3dView, Internal::Model3dView>(handle);
}
-Model3dView::Model3dView( Internal::Model3dView& implementation )
- : Control( implementation )
+Model3dView::Model3dView(Internal::Model3dView& implementation)
+: Control(implementation)
{
}
-Model3dView::Model3dView( Dali::Internal::CustomActor* internal )
- : Control( internal )
+Model3dView::Model3dView(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
- VerifyCustomActorPointer<Internal::Model3dView>( internal );
+ VerifyCustomActorPointer<Internal::Model3dView>(internal);
}
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class Model3dView;
class DALI_TOOLKIT_API Model3dView : public Control
{
public:
-
/**
* @brief Enumeration for the start and end property ranges for this control.
* @SINCE_1_1.4
*/
enum PropertyRange
{
- PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_1.4
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_1.4
+ PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_1.4
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_1.4
- ANIMATABLE_PROPERTY_START_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX, ///< @SINCE_1_1.4
- ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve animatable property indices @SINCE_1_1.4
+ ANIMATABLE_PROPERTY_START_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX, ///< @SINCE_1_1.4
+ ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve animatable property indices @SINCE_1_1.4
};
/**
*/
enum
{
- GEOMETRY_URL = PROPERTY_START_INDEX, ///< name "geometryUrl", The path to the geometry file, type STRING @SINCE_1_1.4
- MATERIAL_URL, ///< name "materialUrl", The path to the material file, type STRING @SINCE_1_1.4
- IMAGES_URL, ///< name "imagesUrl", The path to the images directory, type STRING @SINCE_1_1.4
- ILLUMINATION_TYPE, ///< name "illuminationType", The type of illumination, type INTEGER @SINCE_1_1.4
- TEXTURE0_URL, ///< name "texture0Url", The path to first texture, type STRING @SINCE_1_1.4
- TEXTURE1_URL, ///< name "texture1Url", The path to second texture, type STRING @SINCE_1_1.4
- TEXTURE2_URL, ///< name "texture2Url", The path to third texture, type STRING @SINCE_1_1.4
-
- LIGHT_POSITION = ANIMATABLE_PROPERTY_START_INDEX ///< name "lightPosition", The coordinates of the light, type Vector3 @SINCE_1_1.4
+ GEOMETRY_URL = PROPERTY_START_INDEX, ///< name "geometryUrl", The path to the geometry file, type STRING @SINCE_1_1.4
+ MATERIAL_URL, ///< name "materialUrl", The path to the material file, type STRING @SINCE_1_1.4
+ IMAGES_URL, ///< name "imagesUrl", The path to the images directory, type STRING @SINCE_1_1.4
+ ILLUMINATION_TYPE, ///< name "illuminationType", The type of illumination, type INTEGER @SINCE_1_1.4
+ TEXTURE0_URL, ///< name "texture0Url", The path to first texture, type STRING @SINCE_1_1.4
+ TEXTURE1_URL, ///< name "texture1Url", The path to second texture, type STRING @SINCE_1_1.4
+ TEXTURE2_URL, ///< name "texture2Url", The path to third texture, type STRING @SINCE_1_1.4
+
+ LIGHT_POSITION = ANIMATABLE_PROPERTY_START_INDEX ///< name "lightPosition", The coordinates of the light, type Vector3 @SINCE_1_1.4
};
};
*/
enum IlluminationType
{
- DIFFUSE, ///< diffuse @SINCE_1_1.4
- DIFFUSE_WITH_TEXTURE, ///< diffuse with texture @SINCE_1_1.4
- DIFFUSE_WITH_NORMAL_MAP ///< diffuse with normal map @SINCE_1_1.4
+ DIFFUSE, ///< diffuse @SINCE_1_1.4
+ DIFFUSE_WITH_TEXTURE, ///< diffuse with texture @SINCE_1_1.4
+ DIFFUSE_WITH_NORMAL_MAP ///< diffuse with normal map @SINCE_1_1.4
};
/**
* @param[in] imagesUrl The path to the images directory
* @return A handle to the new Model3dView control
*/
- static Model3dView New( const std::string& objUrl, const std::string& mtlUrl, const std::string& imagesUrl );
-
+ static Model3dView New(const std::string& objUrl, const std::string& mtlUrl, const std::string& imagesUrl);
/**
* @brief Creates an uninitialized Model3dView.
* @SINCE_1_1.4
* @param[in] model3dView Handle to an object
*/
- Model3dView( const Model3dView& model3dView );
+ Model3dView(const Model3dView& model3dView);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- Model3dView( Model3dView&& rhs );
+ Model3dView(Model3dView&& rhs);
/**
* @brief Assignment operator.
* @param[in] model3dView Handle to an object
* @return reference to this
*/
- Model3dView& operator=( const Model3dView& model3dView );
+ Model3dView& operator=(const Model3dView& model3dView);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- Model3dView& operator=( Model3dView&& rhs );
+ Model3dView& operator=(Model3dView&& rhs);
/**
* @brief Downcasts an Object handle to Model3dView.
* @param[in] handle Handle to an object
* @return Handle to a Model3dView or an uninitialized handle
*/
- static Model3dView DownCast( BaseHandle handle );
+ static Model3dView DownCast(BaseHandle handle);
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_1.4
* @param[in] implementation The Control implementation
*/
- DALI_INTERNAL Model3dView( Internal::Model3dView& implementation );
+ DALI_INTERNAL Model3dView(Internal::Model3dView& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @SINCE_1_1.4
* @param[in] internal A pointer to the internal CustomActor
*/
- DALI_INTERNAL Model3dView( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL Model3dView(Dali::Internal::CustomActor* internal);
/// @endcond
-
};
/**
namespace Dali
{
-
namespace Toolkit
{
-
ProgressBar::ProgressBar()
{
}
-ProgressBar::ProgressBar( const ProgressBar& handle ) = default;
+ProgressBar::ProgressBar(const ProgressBar& handle) = default;
-ProgressBar::ProgressBar( ProgressBar&& rhs ) = default;
+ProgressBar::ProgressBar(ProgressBar&& rhs) = default;
-ProgressBar& ProgressBar::operator=( const ProgressBar& handle ) = default;
+ProgressBar& ProgressBar::operator=(const ProgressBar& handle) = default;
-ProgressBar& ProgressBar::operator=( ProgressBar&& rhs ) = default;
+ProgressBar& ProgressBar::operator=(ProgressBar&& rhs) = default;
ProgressBar::ProgressBar(Internal::ProgressBar& implementation)
: Control(implementation)
{
}
-ProgressBar::ProgressBar( Dali::Internal::CustomActor* internal )
-: Control( internal )
+ProgressBar::ProgressBar(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::ProgressBar>(internal);
}
ProgressBar::ValueChangedSignalType& ProgressBar::ValueChangedSignal()
{
- return GetImpl( *this ).ValueChangedSignal();
+ return GetImpl(*this).ValueChangedSignal();
}
-ProgressBar ProgressBar::DownCast( BaseHandle handle )
+ProgressBar ProgressBar::DownCast(BaseHandle handle)
{
return Control::DownCast<ProgressBar, Internal::ProgressBar>(handle);
}
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class ProgressBar;
class DALI_TOOLKIT_API ProgressBar : public Control
{
public:
-
// Properties
/**
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< Start Index. @SINCE_1_2.60
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices. @SINCE_1_2.60
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices. @SINCE_1_2.60
};
/**
};
public:
-
/**
* @brief Creates the ProgressBar control. It creates a horizontal linear shape of progress bar.
* @SINCE_1_2.60
* @SINCE_1_2.60
* @param[in] handle Handle to an object
*/
- ProgressBar( const ProgressBar& handle );
+ ProgressBar(const ProgressBar& handle);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- ProgressBar( ProgressBar&& rhs );
+ ProgressBar(ProgressBar&& rhs);
/**
* @brief Assignment operator.
* @param[in] handle Handle to an object
* @return A reference to this
*/
- ProgressBar& operator=( const ProgressBar& handle );
+ ProgressBar& operator=(const ProgressBar& handle);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- ProgressBar& operator=( ProgressBar&& rhs );
+ ProgressBar& operator=(ProgressBar&& rhs);
/**
* @brief Destructor.
* @param[in] handle Handle to an object
* @return handle to a ProgressBar or an uninitialized handle
*/
- static ProgressBar DownCast( BaseHandle handle );
-
-public: // Signals
+ static ProgressBar DownCast(BaseHandle handle);
+public: // Signals
/**
* @brief Value changed signal type.
* @SINCE_1_2.60
*/
- typedef Signal< void ( ProgressBar, float, float ) > ValueChangedSignalType;
+ typedef Signal<void(ProgressBar, float, float)> ValueChangedSignalType;
/**
* @brief Signal emitted when the ProgressBar value changes.
ValueChangedSignalType& ValueChangedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor
*/
- explicit DALI_INTERNAL ProgressBar( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL ProgressBar(Dali::Internal::CustomActor* internal);
/// @endcond
};
#define DALI_TOOLKIT_DEFAULT_ITEM_LAYOUT_PROPERTY_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
/**
*/
namespace DefaultItemLayoutProperty
{
-
/**
* @brief The properties of each type of item layout.
* @SINCE_1_2.60
/**
* @}
*/
+} // namespace DefaultItemLayoutProperty
+
} // namespace Toolkit
} // namespace Dali
-}
-
#endif // DALI_TOOLKIT_DEFAULT_ITEM_LAYOUT_PROPERTY_H
-
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace DefaultItemLayout
{
-
-ItemLayoutPtr New( Type type )
+ItemLayoutPtr New(Type type)
{
ItemLayoutPtr itemLayout;
- switch ( type )
+ switch(type)
{
case DEPTH:
{
case LIST:
{
Internal::GridLayoutPtr layout = Internal::GridLayout::New();
- layout->SetNumberOfColumns( 1 );
+ layout->SetNumberOfColumns(1);
itemLayout = layout;
break;
}
#define DALI_TOOLKIT_DEFAULT_ITEM_LAYOUT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
/**
*/
namespace DefaultItemLayout
{
-
/**
* @brief Enumeration for the type of DefaultItemLayout
* @SINCE_1_0.0
*/
enum Type
{
- DEPTH, ///< Items arranged in a grid, scrolling along the Z-Axis. @SINCE_1_0.0
- GRID, ///< Items arranged in a grid, scrolling along the Y-Axis. @SINCE_1_0.0
- LIST, ///< One item per line, scrolling along the Y-Axis. @SINCE_1_0.0
- SPIRAL ///< Items arranged in a spiral, centered around the Y-Axis. @SINCE_1_0.0
+ DEPTH, ///< Items arranged in a grid, scrolling along the Z-Axis. @SINCE_1_0.0
+ GRID, ///< Items arranged in a grid, scrolling along the Y-Axis. @SINCE_1_0.0
+ LIST, ///< One item per line, scrolling along the Y-Axis. @SINCE_1_0.0
+ SPIRAL ///< Items arranged in a spiral, centered around the Y-Axis. @SINCE_1_0.0
};
/**
* @param[in] type The type of layout required
* @return An ItemLayoutPtr to the newly created layout
*/
-DALI_TOOLKIT_API ItemLayoutPtr New( Type type );
+DALI_TOOLKIT_API ItemLayoutPtr New(Type type);
} // namespace DefaultItemLayout
#define DALI_TOOLKIT_ITEM_FACTORY_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
/**
class ItemFactory
{
public:
-
class Extension; ///< Forward declare future extension interface
/**
* @brief Virtual destructor.
* @SINCE_1_0.0
*/
- DALI_TOOLKIT_API virtual ~ItemFactory() {};
+ DALI_TOOLKIT_API virtual ~ItemFactory(){};
/**
* @brief Queries the number of items available from the factory.
* @param[in] itemId The ID of the released item
* @param[in] actor The actor that represents the released item
*/
- virtual void ItemReleased(unsigned int itemId, Actor actor) {};
+ virtual void ItemReleased(unsigned int itemId, Actor actor){};
/**
* @brief Retrieves the extension for this control.
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/public-api/animation/time-period.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/controls/scrollable/item-view/item-view.h>
#include <dali-toolkit/public-api/controls/scrollable/item-view/default-item-layout-property.h>
+#include <dali-toolkit/public-api/controls/scrollable/item-view/item-view.h>
namespace Dali
{
-
namespace Toolkit
{
-
struct ItemLayout::Impl
{
- Vector3 mItemSize; ///< The size of an item in the layout
- ControlOrientation::Type mOrientation; ///< the orientation of the layout.
- Property::Map mProperties;
+ Vector3 mItemSize; ///< The size of an item in the layout
+ ControlOrientation::Type mOrientation; ///< the orientation of the layout.
+ Property::Map mProperties;
};
ItemLayout::ItemLayout()
-: mImpl( new Impl )
+: mImpl(new Impl)
{
mImpl->mOrientation = ControlOrientation::Up;
}
return mImpl->mOrientation;
}
-void ItemLayout::GetItemSize( unsigned int itemId, const Vector3& layoutSize, Vector3& itemSize ) const
+void ItemLayout::GetItemSize(unsigned int itemId, const Vector3& layoutSize, Vector3& itemSize) const
{
// If item-size has not been set then get the default size
- if ( mImpl->mItemSize == Vector3::ZERO )
+ if(mImpl->mItemSize == Vector3::ZERO)
{
- GetDefaultItemSize( itemId, layoutSize, itemSize );
+ GetDefaultItemSize(itemId, layoutSize, itemSize);
}
else
{
}
}
-void ItemLayout::SetItemSize( const Vector3& itemSize )
+void ItemLayout::SetItemSize(const Vector3& itemSize)
{
mImpl->mItemSize = itemSize;
}
float ItemLayout::GetClosestOnScreenLayoutPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize)
{
- Vector3 itemPosition = GetItemPosition( itemID, currentLayoutPosition, layoutSize );
+ Vector3 itemPosition = GetItemPosition(itemID, currentLayoutPosition, layoutSize);
Vector3 itemSize;
GetItemSize(itemID, layoutSize, itemSize);
Vector3 onScreenArea = (layoutSize - itemSize) * 0.5f;
- if (itemPosition.x < -onScreenArea.x
- || itemPosition.x > onScreenArea.x
- || itemPosition.y < -onScreenArea.y
- || itemPosition.y > onScreenArea.y)
+ if(itemPosition.x < -onScreenArea.x || itemPosition.x > onScreenArea.x || itemPosition.y < -onScreenArea.y || itemPosition.y > onScreenArea.y)
{
// item not within viewable area
// safest thing to do here since we have no idea how the implementation will work is to return the scroll to position
int ItemLayout::GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
{
- switch( direction )
+ switch(direction)
{
case Control::KeyboardFocus::LEFT:
case Control::KeyboardFocus::UP:
{
itemID--;
- if( itemID < 0 )
+ if(itemID < 0)
{
itemID = loopEnabled ? maxItems - 1 : 0;
}
case Control::KeyboardFocus::DOWN:
{
itemID++;
- if( itemID >= maxItems )
+ if(itemID >= maxItems)
{
itemID = loopEnabled ? 0 : maxItems - 1;
}
void ItemLayout::SetLayoutProperties(const Property::Map& properties)
{
- for( unsigned int idx = 0, mapCount = properties.Count(); idx < mapCount; ++idx )
+ for(unsigned int idx = 0, mapCount = properties.Count(); idx < mapCount; ++idx)
{
- KeyValuePair propertyPair( properties.GetKeyValue( idx ) );
+ KeyValuePair propertyPair(properties.GetKeyValue(idx));
if(propertyPair.first == DefaultItemLayoutProperty::ITEM_SIZE)
{
#define DALI_TOOLKIT_ITEM_LAYOUT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/public-api/object/property-map.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/enums.h>
#include <dali-toolkit/public-api/controls/control.h>
+#include <dali-toolkit/public-api/enums.h>
#undef min
#undef max
namespace Dali
{
-
namespace Toolkit
{
/**
*/
ItemRange& operator=(const ItemRange& range)
{
- if( this != &range )
+ if(this != &range)
{
begin = range.begin;
- end = range.end;
+ end = range.end;
}
return *this;
}
ItemRange intersection(0u, 0u);
// If the ranges intersect
- if ( (begin < second.end && end > second.begin) ||
- (second.begin < end && second.end > begin) )
+ if((begin < second.end && end > second.begin) ||
+ (second.begin < end && second.end > begin))
{
intersection.begin = std::max(begin, second.begin);
intersection.end = std::min(end, second.end);
class DALI_TOOLKIT_API ItemLayout : public RefObject
{
public:
-
class Extension; ///< Forward declare future extension interface
/**
* @note layout-position is not provided as a parameter, since applying size constraints is not recommended.
* Animating to target-sizes is preferable, since this allows controls to perform layouting without constraints.
*/
- void GetItemSize( unsigned int itemId, const Vector3& layoutSize, Vector3& itemSize ) const;
+ void GetItemSize(unsigned int itemId, const Vector3& layoutSize, Vector3& itemSize) const;
/**
* @brief Overrides the default size for the layout.
* @SINCE_1_0.0
* @param[in] itemSize The size of each item.
*/
- void SetItemSize( const Vector3& itemSize );
+ void SetItemSize(const Vector3& itemSize);
/**
* @brief Query the minimum valid layout position; this is a negative value.
* @note layout-position is not provided as a parameter, since applying size constraints is not recommended.
* Animating to target-sizes is preferable, since this allows controls to perform layouting without constraints.
*/
- virtual void GetDefaultItemSize( unsigned int itemId, const Vector3& layoutSize, Vector3& itemSize ) const = 0;
+ virtual void GetDefaultItemSize(unsigned int itemId, const Vector3& layoutSize, Vector3& itemSize) const = 0;
/**
* @brief Query the scroll direction of the layout.
* @param[in] layoutSize The current size of the item view instance.
* @param[in] itemViewActor The item view instance which requests the application of constraints.
*/
- virtual void ApplyConstraints( Actor& actor, const int itemId, const Vector3& layoutSize, const Actor& itemViewActor ) = 0;
+ virtual void ApplyConstraints(Actor& actor, const int itemId, const Vector3& layoutSize, const Actor& itemViewActor) = 0;
/**
* @brief Gets the position of a given item
}
protected:
-
/**
* @brief Create a new ItemLayout; Only derived versions are instantiatable.
* @SINCE_1_0.0
ItemLayout();
private:
-
/**
* @brief Don't allow copy constructor
* @SINCE_1_0.0
*/
- ItemLayout( const ItemLayout& handle );
+ ItemLayout(const ItemLayout& handle);
/**
* @brief Don't allow copy operator
* @SINCE_1_0.0
*/
- ItemLayout& operator=( const ItemLayout& handle );
+ ItemLayout& operator=(const ItemLayout& handle);
protected:
-
struct Impl;
Impl* mImpl;
};
#define DALI_TOOLKIT_ITEM_VIEW_DECLARATIONS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <utility> // std::pair
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/common/vector-wrapper.h>
+#include <utility> // std::pair
namespace Dali
{
-
namespace Toolkit
{
/**
typedef unsigned int ItemId; ///< Unique identity for each item in the view. @SINCE_1_0.0
-typedef std::vector<ItemId> ItemIdContainer; ///< Item id container type @SINCE_1_0.0
-typedef ItemIdContainer::iterator ItemIdIter; ///< Item id iterator type @SINCE_1_0.0
-typedef ItemIdContainer::const_iterator ConstItemIdIter; ///< Item id const iterator type @SINCE_1_0.0
+typedef std::vector<ItemId> ItemIdContainer; ///< Item id container type @SINCE_1_0.0
+typedef ItemIdContainer::iterator ItemIdIter; ///< Item id iterator type @SINCE_1_0.0
+typedef ItemIdContainer::const_iterator ConstItemIdIter; ///< Item id const iterator type @SINCE_1_0.0
-typedef std::pair<ItemId, Actor> Item; ///< Item type @SINCE_1_0.0
+typedef std::pair<ItemId, Actor> Item; ///< Item type @SINCE_1_0.0
-typedef std::vector<Item> ItemContainer; ///< Item container type @SINCE_1_0.0
-typedef ItemContainer::iterator ItemIter; ///< Item iterator type @SINCE_1_0.0
-typedef ItemContainer::const_iterator ConstItemIter; ///< Item const iterator type @SINCE_1_0.0
+typedef std::vector<Item> ItemContainer; ///< Item container type @SINCE_1_0.0
+typedef ItemContainer::iterator ItemIter; ///< Item iterator type @SINCE_1_0.0
+typedef ItemContainer::const_iterator ConstItemIter; ///< Item const iterator type @SINCE_1_0.0
class ItemView;
class ItemLayout;
*
*/
-#include <dali-toolkit/public-api/controls/scrollable/scrollable.h>
-#include <dali-toolkit/public-api/controls/scrollable/item-view/item-view.h>
#include <dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h>
+#include <dali-toolkit/public-api/controls/scrollable/item-view/item-view.h>
+#include <dali-toolkit/public-api/controls/scrollable/scrollable.h>
namespace Dali
{
-
namespace Toolkit
{
-
ItemView::ItemView()
{
}
{
}
-ItemView::ItemView( Dali::Internal::CustomActor* internal )
+ItemView::ItemView(Dali::Internal::CustomActor* internal)
: Scrollable(internal)
{
VerifyCustomActorPointer<Internal::ItemView>(internal);
}
-ItemView::ItemView( const ItemView& itemView ) = default;
+ItemView::ItemView(const ItemView& itemView) = default;
-ItemView::ItemView( ItemView&& rhs ) = default;
+ItemView::ItemView(ItemView&& rhs) = default;
-ItemView& ItemView::operator=( const ItemView& itemView ) = default;
+ItemView& ItemView::operator=(const ItemView& itemView) = default;
-ItemView& ItemView::operator=( ItemView&& rhs ) = default;
+ItemView& ItemView::operator=(ItemView&& rhs) = default;
ItemView ItemView::New(ItemFactory& factory)
{
return Internal::ItemView::New(factory);
}
-ItemView ItemView::DownCast( BaseHandle handle )
+ItemView ItemView::DownCast(BaseHandle handle)
{
return Control::DownCast<ItemView, Internal::ItemView>(handle);
}
void ItemView::InsertItem(Item newItem, float durationSeconds)
{
- GetImpl(*this).InsertItem( newItem, durationSeconds );
+ GetImpl(*this).InsertItem(newItem, durationSeconds);
}
void ItemView::InsertItems(const ItemContainer& newItems, float durationSeconds)
{
- GetImpl(*this).InsertItems( newItems, durationSeconds );
+ GetImpl(*this).InsertItems(newItems, durationSeconds);
}
void ItemView::RemoveItem(unsigned int itemId, float durationSeconds)
{
- GetImpl(*this).RemoveItem( itemId, durationSeconds );
+ GetImpl(*this).RemoveItem(itemId, durationSeconds);
}
void ItemView::RemoveItems(const ItemIdContainer& itemIds, float durationSeconds)
{
- GetImpl(*this).RemoveItems( itemIds, durationSeconds );
+ GetImpl(*this).RemoveItems(itemIds, durationSeconds);
}
void ItemView::ReplaceItem(Item replacementItem, float durationSeconds)
{
- GetImpl(*this).ReplaceItem( replacementItem, durationSeconds );
+ GetImpl(*this).ReplaceItem(replacementItem, durationSeconds);
}
void ItemView::ReplaceItems(const ItemContainer& replacementItems, float durationSeconds)
{
- GetImpl(*this).ReplaceItems( replacementItems, durationSeconds );
+ GetImpl(*this).ReplaceItems(replacementItems, durationSeconds);
}
-void ItemView::SetItemsParentOrigin( const Vector3& parentOrigin )
+void ItemView::SetItemsParentOrigin(const Vector3& parentOrigin)
{
- GetImpl(*this).SetItemsParentOrigin( parentOrigin );
+ GetImpl(*this).SetItemsParentOrigin(parentOrigin);
}
Vector3 ItemView::GetItemsParentOrigin() const
return GetImpl(*this).GetItemsParentOrigin();
}
-void ItemView::SetItemsAnchorPoint( const Vector3& anchorPoint )
+void ItemView::SetItemsAnchorPoint(const Vector3& anchorPoint)
{
GetImpl(*this).SetItemsAnchorPoint(anchorPoint);
}
// EXTERNAL INCLUDES
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/controls/scrollable/scrollable.h>
#include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
+#include <dali-toolkit/public-api/controls/scrollable/scrollable.h>
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class ItemView;
class DALI_TOOLKIT_API ItemView : public Scrollable
{
public:
-
/**
* @brief Enumeration for the start and end property ranges for this control.
* @SINCE_1_1.18
*/
enum PropertyRange
{
- PROPERTY_START_INDEX = Toolkit::Scrollable::PROPERTY_END_INDEX + 1, ///< @SINCE_1_1.18
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices, @SINCE_1_1.18
+ PROPERTY_START_INDEX = Toolkit::Scrollable::PROPERTY_END_INDEX + 1, ///< @SINCE_1_1.18
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices, @SINCE_1_1.18
ANIMATABLE_PROPERTY_START_INDEX = Toolkit::Scrollable::ANIMATABLE_PROPERTY_END_INDEX + 1,
- ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_START_INDEX + 1000 ///< Reserve animatable property indices @SINCE_1_0.0
+ ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_START_INDEX + 1000 ///< Reserve animatable property indices @SINCE_1_0.0
};
/**
// Signals
- typedef Signal< void () > LayoutActivatedSignalType;
+ typedef Signal<void()> LayoutActivatedSignalType;
public:
-
/**
* @brief Creates an uninitialized ItemView; this can be initialized with ItemView::New().
*
* @SINCE_1_0.0
* @param[in] itemView Handle to an object
*/
- ItemView( const ItemView& itemView );
+ ItemView(const ItemView& itemView);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- ItemView( ItemView&& rhs );
+ ItemView(ItemView&& rhs);
/**
* @brief Assignment operator.
* @param[in] itemView Handle to an object
* @return A reference to this
*/
- ItemView& operator=( const ItemView& itemView );
+ ItemView& operator=(const ItemView& itemView);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- ItemView& operator=( ItemView&& rhs );
+ ItemView& operator=(ItemView&& rhs);
/**
* @brief Destructor.
* @param[in] handle Handle to an object
* @return A handle to a ItemView or an uninitialized handle
*/
- static ItemView DownCast( BaseHandle handle );
+ static ItemView DownCast(BaseHandle handle);
/**
* @brief Queries the number of layouts.
* @SINCE_1_0.0
* @param[in] parentOrigin New parent origin position vector
*/
- void SetItemsParentOrigin( const Vector3& parentOrigin );
+ void SetItemsParentOrigin(const Vector3& parentOrigin);
/**
* @brief Get the parent origin of the items.
* @SINCE_1_0.0
* @param[in] anchorPoint New anchor point position vector
*/
- void SetItemsAnchorPoint( const Vector3& anchorPoint );
+ void SetItemsAnchorPoint(const Vector3& anchorPoint);
/**
* @brief Get the anchor point of the items.
void GetItemsRange(ItemRange& range);
public: // Signals
-
/**
* @brief Signal emitted when layout activation is finished.
*
ItemView::LayoutActivatedSignalType& LayoutActivatedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor.
*/
- explicit DALI_INTERNAL ItemView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL ItemView(Dali::Internal::CustomActor* internal);
/// @endcond
};
#define DALI_TOOLKIT_SCROLL_VIEW_SCROLL_MODE_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_controls_scroll_view
* @{
*/
namespace ScrollMode
{
-
/**
* @brief Properties to use in a Property::MAP when setting a ScrollView's scroll mode.
* @SINCE_1_2.60
Y_AXIS_SCROLL_BOUNDARY
};
-} // ScrollMode
+} // namespace ScrollMode
/**
* @}
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-constraints.h>
#include <dali/public-api/common/constants.h>
#include <dali/public-api/math/math-utils.h>
#include <dali/public-api/object/property-input.h>
-#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-constraints.h>
using namespace Dali;
namespace Dali
{
-
namespace Toolkit
{
-
-void MoveActorConstraint( Vector3& current, const PropertyInputContainer& inputs )
+void MoveActorConstraint(Vector3& current, const PropertyInputContainer& inputs)
{
current += Vector3(inputs[0]->GetVector2());
}
-void WrapActorConstraint( Vector3& position, const PropertyInputContainer& inputs )
+void WrapActorConstraint(Vector3& position, const PropertyInputContainer& inputs)
{
bool wrap = inputs[5]->GetBoolean();
const Vector2& max = inputs[4]->GetVector2();
const Vector3& anchor = inputs[1]->GetVector3();
- const Vector3 scale = inputs[0]->GetVector3();
- const Vector3 size = inputs[2]->GetVector3();
+ const Vector3 scale = inputs[0]->GetVector3();
+ const Vector3 size = inputs[2]->GetVector3();
if(fabsf(min.x - max.x) > Math::MACHINE_EPSILON_1)
{
// WRAP X (based on the position of the right side)
float offsetX = (1.0f - anchor.x) * size.x * scale.x;
- position.x = WrapInDomain(position.x + offsetX, min.x, max.x) - offsetX;
+ position.x = WrapInDomain(position.x + offsetX, min.x, max.x) - offsetX;
}
if(fabsf(min.y - max.y) > Math::MACHINE_EPSILON_1)
{
// WRAP Y (based on the position of the bottom side)
float offsetY = (1.0f - anchor.y) * size.y * scale.y;
- position.y = WrapInDomain(position.y + offsetY, min.y, max.y) - offsetY;
+ position.y = WrapInDomain(position.y + offsetY, min.y, max.y) - offsetY;
}
}
}
} // namespace Toolkit
} // namespace Dali
-
#define DALI_TOOLKIT_SCROLL_VIEW_CONSTRAINTS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
struct Vector2;
struct Vector3;
struct Vector4;
* @param[in] current Current position
* @param[in] inputs The position input that Actor will move
*/
-DALI_TOOLKIT_API void MoveActorConstraint( Vector3& current, const PropertyInputContainer& inputs );
+DALI_TOOLKIT_API void MoveActorConstraint(Vector3& current, const PropertyInputContainer& inputs);
/**
* @brief Wraps an Actor's position in accordance with the min/max bounds of domain.
* @param[in] position Position to be wrapped
* @param[in] inputs The input that Actor's position will be wrapped
*/
-DALI_TOOLKIT_API void WrapActorConstraint( Vector3& position, const PropertyInputContainer& inputs );
+DALI_TOOLKIT_API void WrapActorConstraint(Vector3& position, const PropertyInputContainer& inputs);
/**
* @}
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*
*/
-#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-effect.h>
#include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-effect-impl.h>
+#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-effect.h>
using namespace Dali;
namespace Dali
{
-
namespace Toolkit
{
-
ScrollViewEffect::ScrollViewEffect()
{
-
}
-ScrollViewEffect::ScrollViewEffect(Internal::ScrollViewEffect *impl)
+ScrollViewEffect::ScrollViewEffect(Internal::ScrollViewEffect* impl)
: BaseHandle(impl)
{
}
#define DALI_TOOLKIT_SCROLL_VIEW_EFFECT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
struct Vector2;
struct Vector3;
struct Vector4;
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class ScrollViewEffect;
class ScrollViewWobbleEffect;
-}
+} // namespace DALI_INTERNAL
/**
* @addtogroup dali_toolkit_controls_scroll_view
* @{
*/
class DALI_TOOLKIT_API ScrollViewEffect : public Dali::BaseHandle
{
-
public:
-
/**
* @brief Creates an uninitialized ScrollViewEffect; this can only be initialized with derived classes.
*
ScrollViewEffect();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used by Dali New() methods.
* @SINCE_1_0.0
* @param[in] impl A pointer to a newly allocated Dali resource
*/
- explicit DALI_INTERNAL ScrollViewEffect(Internal::ScrollViewEffect *impl);
+ explicit DALI_INTERNAL ScrollViewEffect(Internal::ScrollViewEffect* impl);
/// @endcond
-
};
/**
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
ScrollViewPagePathEffect ScrollViewPagePathEffect::New(Path path, const Vector3& forward, Dali::Property::Index inputPropertyIndex, const Vector3& viewPageSize, unsigned int pageCount)
{
- return ScrollViewPagePathEffect(new Internal::ScrollViewPagePathEffect(path, forward, inputPropertyIndex, viewPageSize,pageCount));
+ return ScrollViewPagePathEffect(new Internal::ScrollViewPagePathEffect(path, forward, inputPropertyIndex, viewPageSize, pageCount));
}
ScrollViewPagePathEffect::ScrollViewPagePathEffect()
{
}
-ScrollViewPagePathEffect::ScrollViewPagePathEffect(Internal::ScrollViewPagePathEffect *impl)
-:ScrollViewEffect(impl)
+ScrollViewPagePathEffect::ScrollViewPagePathEffect(Internal::ScrollViewPagePathEffect* impl)
+: ScrollViewEffect(impl)
{
}
-ScrollViewPagePathEffect ScrollViewPagePathEffect::DownCast( BaseHandle handle )
+ScrollViewPagePathEffect ScrollViewPagePathEffect::DownCast(BaseHandle handle)
{
- return ScrollViewPagePathEffect( dynamic_cast<Internal::ScrollViewPagePathEffect*>(handle.GetObjectPtr()) );
+ return ScrollViewPagePathEffect(dynamic_cast<Internal::ScrollViewPagePathEffect*>(handle.GetObjectPtr()));
}
-void ScrollViewPagePathEffect::ApplyToPage( Actor page, unsigned int pageOrder )
+void ScrollViewPagePathEffect::ApplyToPage(Actor page, unsigned int pageOrder)
{
- GetImpl(*this).ApplyToPage( page, pageOrder );
+ GetImpl(*this).ApplyToPage(page, pageOrder);
}
} // namespace Toolkit
#define DALI_TOOLKIT_SCROLL_VIEW_PAGE_PATH_EFFECT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
class Actor;
class Path;
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class ScrollViewPagePathEffect;
*/
class DALI_TOOLKIT_API ScrollViewPagePathEffect : public ScrollViewEffect
{
-
public:
-
/**
* @brief Creates an initialized ScrollViewPagePathEffect.
* @SINCE_1_0.0
* @param[in] handle Handle to an object
* @return Handle to a ScrollViewPagePathEffect or an uninitialized handle
*/
- static ScrollViewPagePathEffect DownCast( BaseHandle handle );
+ static ScrollViewPagePathEffect DownCast(BaseHandle handle);
/**
* @brief Manually apply effect to a page in the scroll-view.
* @param[in] page The page to be affected by this effect
* @param[in] pageOrder The order of the page in the scroll view
*/
- void ApplyToPage( Actor page, unsigned int pageOrder );
+ void ApplyToPage(Actor page, unsigned int pageOrder);
protected:
-
/// @cond internal
/**
* @brief This constructor is used by Dali New() methods.
* @SINCE_1_0.0
* @param[in] impl A pointer to a newly allocated Dali resource
*/
- explicit DALI_INTERNAL ScrollViewPagePathEffect( Internal::ScrollViewPagePathEffect *impl );
+ explicit DALI_INTERNAL ScrollViewPagePathEffect(Internal::ScrollViewPagePathEffect* impl);
/// @endcond
-
};
/**
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/controls/scrollable/scrollable.h>
#include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-impl.h>
+#include <dali-toolkit/public-api/controls/scrollable/scrollable.h>
using namespace Dali;
namespace Dali
{
-
namespace Toolkit
{
-
///////////////////////////////////////////////////////////////////////////////////////////////////
// RulerDomain
///////////////////////////////////////////////////////////////////////////////////////////////////
return Clamp(x, length, scale, clamped);
}
-float RulerDomain::Clamp(float x, float length, float scale, ClampState &clamped) const
+float RulerDomain::Clamp(float x, float length, float scale, ClampState& clamped) const
{
if(!enabled)
{
float RulerDomain::GetSize() const
{
- return max-min;
+ return max - min;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
Ruler::Ruler()
: mType(FREE),
mEnabled(true),
- mDomain(RulerDomain(0.0f,1.0f,false))
+ mDomain(RulerDomain(0.0f, 1.0f, false))
{
}
mDomain = domain;
}
-const RulerDomain &Ruler::GetDomain() const
+const RulerDomain& Ruler::GetDomain() const
{
return mDomain;
}
void Ruler::DisableDomain()
{
- mDomain = RulerDomain(0.0f,1.0f,false);
+ mDomain = RulerDomain(0.0f, 1.0f, false);
}
float Ruler::Clamp(float x, float length, float scale) const
return mDomain.Clamp(x, length, scale);
}
-float Ruler::Clamp(float x, float length, float scale, ClampState &clamped) const
+float Ruler::Clamp(float x, float length, float scale, ClampState& clamped) const
{
return mDomain.Clamp(x, length, scale, clamped);
}
return Clamp(Snap(x, bias), length, scale);
}
-float Ruler::SnapAndClamp(float x, float bias, float length, float scale, ClampState &clamped) const
+float Ruler::SnapAndClamp(float x, float bias, float length, float scale, ClampState& clamped) const
{
return Clamp(Snap(x, bias), length, scale, clamped);
}
return x;
}
-float DefaultRuler::GetPositionFromPage(unsigned int page, unsigned int &volume, bool wrap) const
+float DefaultRuler::GetPositionFromPage(unsigned int page, unsigned int& volume, bool wrap) const
{
volume = 0;
return 0.0f;
{
if(fabsf(mSpacing) <= Math::MACHINE_EPSILON_1)
{
- DALI_LOG_ERROR( "Page spacing too small (%f).\n", double(spacing) );
+ DALI_LOG_ERROR("Page spacing too small (%f).\n", double(spacing));
mSpacing = spacing >= 0.0f ? Math::MACHINE_EPSILON_1 : -Math::MACHINE_EPSILON_1;
}
mType = FIXED;
return floor(x / mSpacing + bias) * mSpacing;
}
-float FixedRuler::GetPositionFromPage(unsigned int page, unsigned int &volume, bool wrap) const
+float FixedRuler::GetPositionFromPage(unsigned int page, unsigned int& volume, bool wrap) const
{
float position = mDomain.min;
volume = 0;
// spacing must be present.
- if( mEnabled )
+ if(mEnabled)
{
unsigned int column = page;
if(wrap)
{
unsigned int pagesPerVolume = mDomain.GetSize() / mSpacing;
- if(pagesPerVolume>0)
+ if(pagesPerVolume > 0)
{
column += pagesPerVolume;
column %= pagesPerVolume;
- volume = page/pagesPerVolume;
+ volume = page / pagesPerVolume;
}
}
position = mDomain.min + column * mSpacing;
}
- else // Domain (or Spacing) is not present, carry page to volume.
+ else // Domain (or Spacing) is not present, carry page to volume.
{
if(wrap)
{
unsigned int page = 0;
// spacing must be present.
- if( mEnabled )
+ if(mEnabled)
{
- if( wrap )
+ if(wrap)
{
position = WrapInDomain(position, mDomain.min, mDomain.max);
}
if(pagesPerVolume < 1u)
{
pagesPerVolume = 1u;
- DALI_LOG_ERROR("Ruler domain(%f) is smaller than its spacing(%f).\n", mDomain.GetSize() * 1.0, mSpacing * 1.0 );
+ DALI_LOG_ERROR("Ruler domain(%f) is smaller than its spacing(%f).\n", mDomain.GetSize() * 1.0, mSpacing * 1.0);
}
page %= pagesPerVolume;
}
unsigned int pagesPerVolume = 1;
// spacing must be present.
- if( mEnabled )
+ if(mEnabled)
{
pagesPerVolume = mDomain.GetSize() / mSpacing;
}
{
}
-ScrollView::ScrollView( Dali::Internal::CustomActor* internal )
-: Scrollable( internal )
+ScrollView::ScrollView(Dali::Internal::CustomActor* internal)
+: Scrollable(internal)
{
VerifyCustomActorPointer<Internal::ScrollView>(internal);
}
-ScrollView::ScrollView( const ScrollView& handle ) = default;
+ScrollView::ScrollView(const ScrollView& handle) = default;
-ScrollView::ScrollView( ScrollView&& rhs ) = default;
+ScrollView::ScrollView(ScrollView&& rhs) = default;
-ScrollView& ScrollView::operator=( const ScrollView& handle ) = default;
+ScrollView& ScrollView::operator=(const ScrollView& handle) = default;
-ScrollView& ScrollView::operator=( ScrollView&& rhs ) = default;
+ScrollView& ScrollView::operator=(ScrollView&& rhs) = default;
ScrollView ScrollView::New()
{
{
}
-ScrollView ScrollView::DownCast( BaseHandle handle )
+ScrollView ScrollView::DownCast(BaseHandle handle)
{
return Control::DownCast<ScrollView, Internal::ScrollView>(handle);
}
return GetImpl(*this).GetMinimumDistanceForFlick();
}
-void ScrollView::SetMinimumDistanceForFlick( const Vector2& distance )
+void ScrollView::SetMinimumDistanceForFlick(const Vector2& distance)
{
GetImpl(*this).SetMinimumDistanceForFlick(distance);
}
return GetImpl(*this).GetMinimumSpeedForFlick();
}
-void ScrollView::SetMinimumSpeedForFlick( float speed )
+void ScrollView::SetMinimumSpeedForFlick(float speed)
{
GetImpl(*this).SetMinimumSpeedForFlick(speed);
}
return GetImpl(*this).GetCurrentPage();
}
-void ScrollView::ScrollTo(const Vector2 &position)
+void ScrollView::ScrollTo(const Vector2& position)
{
GetImpl(*this).ScrollTo(position);
}
-void ScrollView::ScrollTo(const Vector2 &position, float duration)
+void ScrollView::ScrollTo(const Vector2& position, float duration)
{
GetImpl(*this).ScrollTo(position, duration);
}
-void ScrollView::ScrollTo(const Vector2 &position, float duration, AlphaFunction alpha)
+void ScrollView::ScrollTo(const Vector2& position, float duration, AlphaFunction alpha)
{
GetImpl(*this).ScrollTo(position, duration, alpha);
}
-void ScrollView::ScrollTo(const Vector2 &position, float duration,
- DirectionBias horizontalBias, DirectionBias verticalBias)
+void ScrollView::ScrollTo(const Vector2& position, float duration, DirectionBias horizontalBias, DirectionBias verticalBias)
{
GetImpl(*this).ScrollTo(position, duration, horizontalBias, verticalBias);
}
-void ScrollView::ScrollTo(const Vector2 &position, float duration, AlphaFunction alpha,
- DirectionBias horizontalBias, DirectionBias verticalBias)
+void ScrollView::ScrollTo(const Vector2& position, float duration, AlphaFunction alpha, DirectionBias horizontalBias, DirectionBias verticalBias)
{
GetImpl(*this).ScrollTo(position, duration, alpha, horizontalBias, verticalBias);
}
GetImpl(*this).ScrollTo(page, duration, bias);
}
-void ScrollView::ScrollTo(Actor &actor)
+void ScrollView::ScrollTo(Actor& actor)
{
GetImpl(*this).ScrollTo(actor);
}
-void ScrollView::ScrollTo(Actor &actor, float duration)
+void ScrollView::ScrollTo(Actor& actor, float duration)
{
GetImpl(*this).ScrollTo(actor, duration);
}
return GetImpl(*this).SnapStartedSignal();
}
-void ScrollView::SetScrollingDirection( Radian direction, Radian threshold )
+void ScrollView::SetScrollingDirection(Radian direction, Radian threshold)
{
- GetImpl(*this).SetScrollingDirection( direction, threshold );
+ GetImpl(*this).SetScrollingDirection(direction, threshold);
}
-void ScrollView::RemoveScrollingDirection( Radian direction )
+void ScrollView::RemoveScrollingDirection(Radian direction)
{
- GetImpl(*this).RemoveScrollingDirection( direction );
+ GetImpl(*this).RemoveScrollingDirection(direction);
}
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class ScrollView;
*/
enum ClampState
{
- NOT_CLAMPED, ///< The quantity isn't clamped @SINCE_1_9.28
+ NOT_CLAMPED, ///< The quantity isn't clamped @SINCE_1_9.28
CLAMPED_TO_MIN, ///< The quantity is clamped to the min value @SINCE_1_9.28
CLAMPED_TO_MAX ///< The quantity is clamped to the max value @SINCE_1_9.28
};
*/
enum SnapType
{
- SNAP, ///< SNAP @SINCE_1_9.28
- FLICK ///< FLICK @SINCE_1_9.28
+ SNAP, ///< SNAP @SINCE_1_9.28
+ FLICK ///< FLICK @SINCE_1_9.28
};
/**
*/
enum DirectionBias
{
- DIRECTION_BIAS_LEFT = -1, ///< Bias scroll snap to Left @SINCE_1_9.28
- DIRECTION_BIAS_NONE = 0, ///< Don't bias scroll snap @SINCE_1_9.28
- DIRECTION_BIAS_RIGHT = 1 ///< Bias scroll snap to Right @SINCE_1_9.28
+ DIRECTION_BIAS_LEFT = -1, ///< Bias scroll snap to Left @SINCE_1_9.28
+ DIRECTION_BIAS_NONE = 0, ///< Don't bias scroll snap @SINCE_1_9.28
+ DIRECTION_BIAS_RIGHT = 1 ///< Bias scroll snap to Right @SINCE_1_9.28
};
/**
class DALI_TOOLKIT_API RulerDomain
{
public:
-
/**
* @brief Creates Ruler domain allowing a point to traverse between min and max extents.
*
explicit RulerDomain(float min, float max, bool enabled = true);
public:
-
- float min; ///< Minimum extent (point cannot traverse less than this)
- float max; ///< Maximum extent (point cannot traverse greater than this)
- bool enabled; ///< Whether domain has been enabled or not.
+ float min; ///< Minimum extent (point cannot traverse less than this)
+ float max; ///< Maximum extent (point cannot traverse greater than this)
+ bool enabled; ///< Whether domain has been enabled or not.
/**
* @brief Clamps value (x) from (min) to (max).
* @param[out] clamped Whether clamping occurred and which size (None, Min or Max)
* @return The clamped value
*/
- float Clamp(float x, float length, float scale, ClampState &clamped) const;
+ float Clamp(float x, float length, float scale, ClampState& clamped) const;
/**
* @brief Returns (max-min) size of ruler.
* @return The size of the ruler from min to max
*/
float GetSize() const;
-
};
// Forward declare future extension interface
* @brief Enumeration for the type of the ruler.
* @SINCE_1_0.0
*/
- enum RulerType {
- FIXED, ///< A fixed ruler @SINCE_1_9.28
- FREE ///< A free ruler @SINCE_1_9.28
+ enum RulerType
+ {
+ FIXED, ///< A fixed ruler @SINCE_1_9.28
+ FREE ///< A free ruler @SINCE_1_9.28
};
public:
-
/**
* @brief Constructs ruler, enabled by default, with limitless domain.
* @SINCE_1_0.0
* @param[in] wrap Enable wrap mode
* @return The position representing this page point
*/
- virtual float GetPositionFromPage(unsigned int page, unsigned int &volume, bool wrap) const = 0;
+ virtual float GetPositionFromPage(unsigned int page, unsigned int& volume, bool wrap) const = 0;
/**
* @brief Returns page from position, based on whatever the ruler
* @SINCE_1_0.0
* @return The extension interface of the Ruler
*/
- virtual RulerExtension* GetExtension() { return NULL; }
+ virtual RulerExtension* GetExtension()
+ {
+ return NULL;
+ }
public:
-
/**
* @brief Gets the ruler type.
*
* @SINCE_1_0.0
* @return The domain
*/
- const RulerDomain &GetDomain() const;
+ const RulerDomain& GetDomain() const;
/**
* @brief Disables Domain (minimum/maximum extents for this axis).
*/
float Clamp(float x, float length = 0.0f, float scale = 1.0f) const;
-
/**
* @brief Clamps value (x) from (min) to (max).
*
* @param[out] clamped Whether clamping occurred and which size (None, Min or Max)
* @return The clamped value
*/
- float Clamp(float x, float length, float scale, ClampState &clamped) const;
+ float Clamp(float x, float length, float scale, ClampState& clamped) const;
/**
* @brief Snaps and Clamps (x) in accordance to ruler settings.
* @param[out] clamped Whether clamping occurred and which size (None, Min or Max)
* @return The clamped value after snapping
*/
- float SnapAndClamp(float x, float bias, float length, float scale, ClampState &clamped) const;
+ float SnapAndClamp(float x, float bias, float length, float scale, ClampState& clamped) const;
protected:
-
/**
* @brief Destructor - A reference counted object may only be deleted by calling Unreference().
* @SINCE_1_0.0
virtual ~Ruler();
protected:
-
- RulerType mType; ///< Type of Ruler (FIXED or FREE).
- bool mEnabled; ///< If the ruler is enabled.
- RulerDomain mDomain; ///< The domain of the ruler.
-
+ RulerType mType; ///< Type of Ruler (FIXED or FREE).
+ bool mEnabled; ///< If the ruler is enabled.
+ RulerDomain mDomain; ///< The domain of the ruler.
};
typedef IntrusivePtr<Ruler> RulerPtr; ///< Pointer to Dali::Toolkit::Ruler object @SINCE_1_0.0
/**
* @copydoc Toolkit::Ruler::GetPositionFromPage
*/
- float GetPositionFromPage(unsigned int page, unsigned int &volume, bool wrap) const override;
+ float GetPositionFromPage(unsigned int page, unsigned int& volume, bool wrap) const override;
/**
* @copydoc Toolkit::Ruler::GetPageFromPosition
/**
* @copydoc Toolkit::Ruler::GetPositionFromPage
*/
- float GetPositionFromPage(unsigned int page, unsigned int &volume, bool wrap) const override;
+ float GetPositionFromPage(unsigned int page, unsigned int& volume, bool wrap) const override;
/**
* @copydoc Toolkit::Ruler::GetPageFromPosition
*/
class DALI_TOOLKIT_API ScrollView : public Scrollable
{
-
public:
-
/**
* @brief Clamps signal event's data.
* @SINCE_1_0.0
*/
struct ClampEvent
{
- ClampState2D scale; ///< Clamp information for scale axes
- ClampState2D position; ///< Clamp information for position axes
- ClampState rotation; ///< Clamp information for rotation
+ ClampState2D scale; ///< Clamp information for scale axes
+ ClampState2D position; ///< Clamp information for position axes
+ ClampState rotation; ///< Clamp information for rotation
};
/**
*/
struct SnapEvent
{
- SnapType type; ///< Current snap commencing
- Vector2 position; ///< Target snap position
- float duration; ///< Duration of snap animation.
+ SnapType type; ///< Current snap commencing
+ Vector2 position; ///< Target snap position
+ float duration; ///< Duration of snap animation.
};
/**
*/
enum PropertyRange
{
- PROPERTY_START_INDEX = Toolkit::Scrollable::PROPERTY_END_INDEX + 1, ///< @SINCE_1_1.18
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices, @SINCE_1_1.18
+ PROPERTY_START_INDEX = Toolkit::Scrollable::PROPERTY_END_INDEX + 1, ///< @SINCE_1_1.18
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices, @SINCE_1_1.18
ANIMATABLE_PROPERTY_START_INDEX = Toolkit::Scrollable::ANIMATABLE_PROPERTY_END_INDEX + 1,
- ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_START_INDEX + 1000 ///< Reserve animatable property indices @SINCE_1_0.0
+ ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_START_INDEX + 1000 ///< Reserve animatable property indices @SINCE_1_0.0
};
/**
// Typedefs
- typedef Signal< void ( const SnapEvent& ) > SnapStartedSignalType; ///< SnapStarted signal type @SINCE_1_0.0
+ typedef Signal<void(const SnapEvent&)> SnapStartedSignalType; ///< SnapStarted signal type @SINCE_1_0.0
public:
-
/**
* @brief Creates an empty ScrollView handle.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] handle Handle to copy from
*/
- ScrollView( const ScrollView& handle );
+ ScrollView(const ScrollView& handle);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- ScrollView( ScrollView&& rhs );
+ ScrollView(ScrollView&& rhs);
/**
* @brief Assignment operator.
* @param[in] handle The handle to copy from
* @return A reference to this
*/
- ScrollView& operator=( const ScrollView& handle );
+ ScrollView& operator=(const ScrollView& handle);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- ScrollView& operator=( ScrollView&& rhs );
+ ScrollView& operator=(ScrollView&& rhs);
/**
* @brief Destructor.
* @param[in] handle Handle to an object
* @return A handle to a ScrollView or an uninitialized handle
*/
- static ScrollView DownCast( BaseHandle handle );
+ static ScrollView DownCast(BaseHandle handle);
public:
-
/**
* @brief Gets snap-animation's AlphaFunction.
*
* @SINCE_1_0.0
* @param[in] distance The minimum pan distance for a flick
*/
- void SetMinimumDistanceForFlick( const Vector2& distance );
+ void SetMinimumDistanceForFlick(const Vector2& distance);
/**
* @brief Returns the minimum pan speed required for a flick gesture in pixels per second.
* @SINCE_1_0.0
* @param[in] speed The minimum pan speed for a flick
*/
- void SetMinimumSpeedForFlick( float speed );
+ void SetMinimumSpeedForFlick(float speed);
/**
* @brief Gets the maximum flick speed setting for ScrollView when
* to get to the target page.
*
*/
- void ScrollTo(const Vector2& position, float duration,
- DirectionBias horizontalBias, DirectionBias verticalBias);
+ void ScrollTo(const Vector2& position, float duration, DirectionBias horizontalBias, DirectionBias verticalBias);
/**
* @brief Scrolls View to position specified (contents will scroll to this position).
* to get to the target page.
*
*/
- void ScrollTo(const Vector2& position, float duration, AlphaFunction alpha,
- DirectionBias horizontalBias, DirectionBias verticalBias);
+ void ScrollTo(const Vector2& position, float duration, AlphaFunction alpha, DirectionBias horizontalBias, DirectionBias verticalBias);
/**
* @brief Scrolls View to page currently based on assumption that each page is
* @param[in] threshold The threshold to apply around the axis
* @note If no threshold is specified, then the default threshold of PI * 0.25 radians (or 45 degrees) is used.
*/
- void SetScrollingDirection( Radian direction, Radian threshold = PanGestureDetector::DEFAULT_THRESHOLD );
+ void SetScrollingDirection(Radian direction, Radian threshold = PanGestureDetector::DEFAULT_THRESHOLD);
/**
* @brief Removes a direction constraint from the scroll view.
* @param[in] direction The axis to stop constraining to.
* Usually will be PanGestureDetector::DIRECTION_VERTICAL or PanGestureDetector::DIRECTION_HORIZONTAL (but can be any other angle if desired).
*/
- void RemoveScrollingDirection( Radian direction );
+ void RemoveScrollingDirection(Radian direction);
public: // Signals
-
/**
* @brief Signal emitted when the ScrollView has started to snap or flick (it tells the target
* position, scale, rotation for the snap or flick).
SnapStartedSignalType& SnapStartedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor
*/
- explicit DALI_INTERNAL ScrollView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL ScrollView(Dali::Internal::CustomActor* internal);
/// @endcond
};
*
*/
-#include <dali-toolkit/public-api/controls/scrollable/scrollable.h>
#include <dali-toolkit/internal/controls/scrollable/scrollable-impl.h>
+#include <dali-toolkit/public-api/controls/scrollable/scrollable.h>
using namespace Dali;
namespace Dali
{
-
namespace Toolkit
{
-
Scrollable::Scrollable()
{
}
{
}
-Scrollable::Scrollable( Dali::Internal::CustomActor* internal )
-: Control( internal )
+Scrollable::Scrollable(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::Scrollable>(internal);
}
-Scrollable::Scrollable( const Scrollable& handle ) = default;
+Scrollable::Scrollable(const Scrollable& handle) = default;
-Scrollable::Scrollable( Scrollable&& rhs ) = default;
+Scrollable::Scrollable(Scrollable&& rhs) = default;
-Scrollable& Scrollable::operator=( const Scrollable& handle ) = default;
+Scrollable& Scrollable::operator=(const Scrollable& handle) = default;
-Scrollable& Scrollable::operator=( Scrollable&& rhs ) = default;
+Scrollable& Scrollable::operator=(Scrollable&& rhs) = default;
Scrollable::~Scrollable()
{
}
-Scrollable Scrollable::DownCast( BaseHandle handle )
+Scrollable Scrollable::DownCast(BaseHandle handle)
{
return Control::DownCast<Scrollable, Internal::Scrollable>(handle);
}
GetImpl(*this).SetOvershootEnabled(enable);
}
-void Scrollable::SetOvershootEffectColor( const Vector4& color )
+void Scrollable::SetOvershootEffectColor(const Vector4& color)
{
GetImpl(*this).SetOvershootEffectColor(color);
}
return GetImpl(*this).GetOvershootEffectColor();
}
-void Scrollable::SetOvershootAnimationSpeed( float pixelsPerSecond )
+void Scrollable::SetOvershootAnimationSpeed(float pixelsPerSecond)
{
GetImpl(*this).SetOvershootAnimationSpeed(pixelsPerSecond);
}
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class Scrollable;
class DALI_TOOLKIT_API Scrollable : public Control
{
public:
-
/**
* @brief Enumeration for the start and end property ranges for this control.
* @SINCE_1_0.0
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_0.0
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_0.0
ANIMATABLE_PROPERTY_START_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX,
- ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve animatable property indices @SINCE_1_0.0
+ ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve animatable property indices @SINCE_1_0.0
};
/**
// Typedefs
- typedef Signal< void ( const Vector2& ) > ScrollStartedSignalType; ///< ScrollStarted signal type @SINCE_1_0.0
- typedef Signal< void ( const Vector2& ) > ScrollCompletedSignalType; ///< ScrollCompleted signal type @SINCE_1_0.0
- typedef Signal< void ( const Vector2& ) > ScrollUpdatedSignalType; ///< Scroll updated signal type @SINCE_1_0.0
+ typedef Signal<void(const Vector2&)> ScrollStartedSignalType; ///< ScrollStarted signal type @SINCE_1_0.0
+ typedef Signal<void(const Vector2&)> ScrollCompletedSignalType; ///< ScrollCompleted signal type @SINCE_1_0.0
+ typedef Signal<void(const Vector2&)> ScrollUpdatedSignalType; ///< Scroll updated signal type @SINCE_1_0.0
public:
-
/**
* @brief Creates an uninitialized Scrollable handle.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param handle to copy from
*/
- Scrollable( const Scrollable& handle );
+ Scrollable(const Scrollable& handle);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- Scrollable( Scrollable&& rhs );
+ Scrollable(Scrollable&& rhs);
/**
* @brief Assignment operator.
* @param[in] handle Handle to copy from
* @return A reference to this
*/
- Scrollable& operator=( const Scrollable& handle );
+ Scrollable& operator=(const Scrollable& handle);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- Scrollable& operator=( Scrollable&& rhs );
+ Scrollable& operator=(Scrollable&& rhs);
/**
* @brief Destructor.
* @param[in] handle Handle to an object
* @return A handle to a Scrollable or an uninitialized handle
*/
- static Scrollable DownCast( BaseHandle handle );
+ static Scrollable DownCast(BaseHandle handle);
/**
* @brief Checks if scroll overshoot has been enabled or not.
* @SINCE_1_0.0
* @param[in] color The color of the overshoot effect
*/
- void SetOvershootEffectColor( const Vector4& color );
+ void SetOvershootEffectColor(const Vector4& color);
/**
* @brief Gets the color of the overshoot effect.
* @SINCE_1_0.0
* @param[in] pixelsPerSecond The speed of the overshoot animation
*/
- void SetOvershootAnimationSpeed( float pixelsPerSecond );
+ void SetOvershootAnimationSpeed(float pixelsPerSecond);
/**
* @brief Gets the speed of overshoot animation in pixels per second.
float GetOvershootAnimationSpeed() const;
public: // Signals
-
/**
* @brief Signal emitted when the Scrollable has moved (whether by touch or animation).
*
ScrollCompletedSignalType& ScrollCompletedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor
*/
- explicit DALI_INTERNAL Scrollable( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL Scrollable(Dali::Internal::CustomActor* internal);
/// @endcond
};
namespace Dali
{
-
namespace Toolkit
{
-
Slider::Slider()
{
}
-Slider::Slider( const Slider& handle ) = default;
+Slider::Slider(const Slider& handle) = default;
-Slider::Slider( Slider&& rhs ) = default;
+Slider::Slider(Slider&& rhs) = default;
-Slider& Slider::operator=( const Slider& handle ) = default;
+Slider& Slider::operator=(const Slider& handle) = default;
-Slider& Slider::operator=( Slider&& rhs ) = default;
+Slider& Slider::operator=(Slider&& rhs) = default;
Slider::Slider(Internal::Slider& implementation)
: Control(implementation)
{
}
-Slider::Slider( Dali::Internal::CustomActor* internal )
-: Control( internal )
+Slider::Slider(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
VerifyCustomActorPointer<Internal::Slider>(internal);
}
Slider::ValueChangedSignalType& Slider::ValueChangedSignal()
{
- return GetImpl( *this ).ValueChangedSignal();
+ return GetImpl(*this).ValueChangedSignal();
}
Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal()
{
- return GetImpl( *this ).SlidingFinishedSignal();
+ return GetImpl(*this).SlidingFinishedSignal();
}
Slider::MarkReachedSignalType& Slider::MarkReachedSignal()
{
- return GetImpl( *this ).MarkReachedSignal();
+ return GetImpl(*this).MarkReachedSignal();
}
-Slider Slider::DownCast( BaseHandle handle )
+Slider Slider::DownCast(BaseHandle handle)
{
return Control::DownCast<Slider, Internal::Slider>(handle);
}
-
-
} // namespace Toolkit
} // namespace Dali
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class Slider;
class DALI_TOOLKIT_API Slider : public Control
{
public:
-
// Properties
/**
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_1.39
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices @SINCE_1_1.39
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices @SINCE_1_1.39
};
/**
};
public:
-
/**
* @brief Creates the Slider control.
* @SINCE_1_1.39
* @SINCE_1_1.39
* @param[in] handle Handle to an object
*/
- Slider( const Slider& handle );
+ Slider(const Slider& handle);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- Slider( Slider&& rhs );
+ Slider(Slider&& rhs);
/**
* @brief Assignment operator.
* @param[in] handle Handle to an object
* @return A reference to this
*/
- Slider& operator=( const Slider& handle );
+ Slider& operator=(const Slider& handle);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- Slider& operator=( Slider&& rhs );
+ Slider& operator=(Slider&& rhs);
/**
* @brief Destructor.
* @param[in] handle Handle to an object
* @return handle to a Slider or an uninitialized handle
*/
- static Slider DownCast( BaseHandle handle );
-
-public: // Signals
+ static Slider DownCast(BaseHandle handle);
+public: // Signals
/**
* @brief Value changed signal type.
* @SINCE_1_1.39
*/
- typedef Signal< bool ( Slider, float ) > ValueChangedSignalType;
+ typedef Signal<bool(Slider, float)> ValueChangedSignalType;
/**
* @brief Mark reached signal type.
* @SINCE_1_1.39
*/
- typedef Signal< bool ( Slider, int ) > MarkReachedSignalType;
+ typedef Signal<bool(Slider, int)> MarkReachedSignalType;
/**
* @brief Signal emitted when the slider value changes.
MarkReachedSignalType& MarkReachedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_1.39
* @param[in] internal A pointer to the internal CustomActor
*/
- explicit DALI_INTERNAL Slider( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL Slider(Dali::Internal::CustomActor* internal);
/// @endcond
};
#define DALI_HIDDEN_INPUT_PROPERTIES_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_controls_text_controls
* @{
namespace HiddenInput
{
-
/**
* @brief HiddenInput Property.
* @SINCE_1_2.60
*/
namespace Property
{
-
/**
* @brief HiddenInput Property.
* @SINCE_1_2.60
*/
namespace Mode
{
-
/**
* @brief The type for HiddenInput::Property::MODE.
* @SINCE_1_2.60
*/
enum Type
{
- HIDE_NONE, ///< Do not hide text. @SINCE_1_2.60
- HIDE_ALL, ///< Hide all the input text. @SINCE_1_2.60
- HIDE_COUNT, ///< Hide n characters from start. @SINCE_1_2.60
- SHOW_COUNT, ///< Show n characters from start. @SINCE_1_2.60
- SHOW_LAST_CHARACTER ///< Show last character for the duration (use Property::SHOW_LAST_CHARACTER_DURATION to modify duration). @SINCE_1_2.60
+ HIDE_NONE, ///< Do not hide text. @SINCE_1_2.60
+ HIDE_ALL, ///< Hide all the input text. @SINCE_1_2.60
+ HIDE_COUNT, ///< Hide n characters from start. @SINCE_1_2.60
+ SHOW_COUNT, ///< Show n characters from start. @SINCE_1_2.60
+ SHOW_LAST_CHARACTER ///< Show last character for the duration (use Property::SHOW_LAST_CHARACTER_DURATION to modify duration). @SINCE_1_2.60
};
} // namespace Mode
#define DALI_TOOLKIT_PLACEHOLDER_PROPERTIES_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_controls_text_controls
* @{
namespace Text
{
-
/**
* @brief Placeholder text used by Text controls to show text before any text inputed.
* @SINCE_1_2.62
*/
namespace PlaceHolder
{
-
/**
* @brief Placeholder text Properties used by Text controls to show placeholder
* @SINCE_1_2.62
*/
namespace Property
{
-
/**
* @brief The configurable settings for the Placeholder text.
* @SINCE_1_2.62
} // namespace PlaceHolder
-
} // namespace Text
/**
namespace Dali
{
-
namespace Toolkit
{
-
TextEditor TextEditor::New()
{
return Internal::TextEditor::New();
{
}
-TextEditor::TextEditor( const TextEditor& handle ) = default;
+TextEditor::TextEditor(const TextEditor& handle) = default;
-TextEditor::TextEditor( TextEditor&& rhs ) = default;
+TextEditor::TextEditor(TextEditor&& rhs) = default;
-TextEditor& TextEditor::operator=( const TextEditor& handle ) = default;
+TextEditor& TextEditor::operator=(const TextEditor& handle) = default;
-TextEditor& TextEditor::operator=( TextEditor&& rhs ) = default;
+TextEditor& TextEditor::operator=(TextEditor&& rhs) = default;
TextEditor::~TextEditor()
{
}
-TextEditor TextEditor::DownCast( BaseHandle handle )
+TextEditor TextEditor::DownCast(BaseHandle handle)
{
- return Control::DownCast<TextEditor, Internal::TextEditor>( handle );
+ return Control::DownCast<TextEditor, Internal::TextEditor>(handle);
}
TextEditor::TextChangedSignalType& TextEditor::TextChangedSignal()
{
- return Dali::Toolkit::GetImpl( *this ).TextChangedSignal();
+ return Dali::Toolkit::GetImpl(*this).TextChangedSignal();
}
TextEditor::InputStyleChangedSignalType& TextEditor::InputStyleChangedSignal()
{
- return Dali::Toolkit::GetImpl( *this ).InputStyleChangedSignal();
+ return Dali::Toolkit::GetImpl(*this).InputStyleChangedSignal();
}
-
TextEditor::ScrollStateChangedSignalType& TextEditor::ScrollStateChangedSignal()
{
- return Dali::Toolkit::GetImpl( *this ).ScrollStateChangedSignal();
+ return Dali::Toolkit::GetImpl(*this).ScrollStateChangedSignal();
}
-TextEditor::TextEditor( Internal::TextEditor& implementation )
-: Control( implementation )
+TextEditor::TextEditor(Internal::TextEditor& implementation)
+: Control(implementation)
{
}
-TextEditor::TextEditor( Dali::Internal::CustomActor* internal )
-: Control( internal )
+TextEditor::TextEditor(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
- VerifyCustomActorPointer<Internal::TextEditor>( internal );
+ VerifyCustomActorPointer<Internal::TextEditor>(internal);
}
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
- class TextEditor;
+class TextEditor;
}
/**
* @addtogroup dali_toolkit_controls_text_controls
class DALI_TOOLKIT_API TextEditor : public Control
{
public:
-
/**
* @brief Enumeration for the start and end property ranges for this control.
* @SINCE_1_1.37
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1,
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
};
/**
*/
enum Mask
{
- NONE = 0x0000, ///< @SINCE_1_2_2
- COLOR = 0x0001, ///< @SINCE_1_2_2
- FONT_FAMILY = 0x0002, ///< @SINCE_1_2_2
- POINT_SIZE = 0x0004, ///< @SINCE_1_2_2
- FONT_STYLE = 0x0008, ///< @SINCE_1_2_2
+ NONE = 0x0000, ///< @SINCE_1_2_2
+ COLOR = 0x0001, ///< @SINCE_1_2_2
+ FONT_FAMILY = 0x0002, ///< @SINCE_1_2_2
+ POINT_SIZE = 0x0004, ///< @SINCE_1_2_2
+ FONT_STYLE = 0x0008, ///< @SINCE_1_2_2
LINE_SPACING = 0x0010, ///< @SINCE_1_2_2
- UNDERLINE = 0x0020, ///< @SINCE_1_2_2
- SHADOW = 0x0040, ///< @SINCE_1_2_2
- EMBOSS = 0x0080, ///< @SINCE_1_2_2
- OUTLINE = 0x0100 ///< @SINCE_1_2_2
+ UNDERLINE = 0x0020, ///< @SINCE_1_2_2
+ SHADOW = 0x0040, ///< @SINCE_1_2_2
+ EMBOSS = 0x0080, ///< @SINCE_1_2_2
+ OUTLINE = 0x0100 ///< @SINCE_1_2_2
};
};
*/
enum Type
{
- STARTED, ///< Scrolling has started. @SINCE_1_2.60
- FINISHED ///< Scrolling has finished. @SINCE_1_2.60
+ STARTED, ///< Scrolling has started. @SINCE_1_2.60
+ FINISHED ///< Scrolling has finished. @SINCE_1_2.60
};
};
* @brief Text changed signal type.
* @SINCE_1_1.37
*/
- typedef Signal< void
- ( TextEditor ) > TextChangedSignalType;
+ typedef Signal<void(TextEditor)> TextChangedSignalType;
/**
* @brief Input Style changed signal type.
* @SINCE_1_2_2
*/
- typedef Signal< void
- ( TextEditor, InputStyle::Mask ) > InputStyleChangedSignalType;
+ typedef Signal<void(TextEditor, InputStyle::Mask)> InputStyleChangedSignalType;
/**
* @brief Scroll state changed signal type.
* @SINCE_1_2.60
*/
- typedef Signal< void
- ( TextEditor, Scroll::Type ) > ScrollStateChangedSignalType;
+ typedef Signal<void(TextEditor, Scroll::Type)> ScrollStateChangedSignalType;
/**
* @brief Creates the TextEditor control.
* @SINCE_1_1.37
* @param[in] handle The handle to copy from
*/
- TextEditor( const TextEditor &handle );
+ TextEditor(const TextEditor& handle);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- TextEditor( TextEditor&& rhs );
+ TextEditor(TextEditor&& rhs);
/**
* @brief Assignment operator.
* @param[in] handle The handle to copy from
* @return A reference to this
*/
- TextEditor& operator=( const TextEditor &handle );
+ TextEditor& operator=(const TextEditor& handle);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- TextEditor& operator=( TextEditor&& rhs );
+ TextEditor& operator=(TextEditor&& rhs);
/**
* @brief Destructor.
* @return Handle to a TextEditor or an empty handle
*/
static TextEditor
- DownCast( BaseHandle handle );
+ DownCast(BaseHandle handle);
// Signals
ScrollStateChangedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation
*/
DALI_INTERNAL
- TextEditor( Internal::TextEditor &implementation );
+ TextEditor(Internal::TextEditor& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor
*/
explicit DALI_INTERNAL
- TextEditor( Dali::Internal::CustomActor *internal );
+ TextEditor(Dali::Internal::CustomActor* internal);
/// @endcond
};
namespace Dali
{
-
namespace Toolkit
{
-
TextField TextField::New()
{
return Internal::TextField::New();
{
}
-TextField::TextField( const TextField& handle ) = default;
+TextField::TextField(const TextField& handle) = default;
-TextField::TextField( TextField&& rhs ) = default;
+TextField::TextField(TextField&& rhs) = default;
-TextField& TextField::operator=( const TextField& handle ) = default;
+TextField& TextField::operator=(const TextField& handle) = default;
-TextField& TextField::operator=( TextField&& rhs ) = default;
+TextField& TextField::operator=(TextField&& rhs) = default;
TextField::~TextField()
{
}
-TextField TextField::DownCast( BaseHandle handle )
+TextField TextField::DownCast(BaseHandle handle)
{
return Control::DownCast<TextField, Internal::TextField>(handle);
}
TextField::TextChangedSignalType& TextField::TextChangedSignal()
{
- return Dali::Toolkit::GetImpl( *this ).TextChangedSignal();
+ return Dali::Toolkit::GetImpl(*this).TextChangedSignal();
}
TextField::MaxLengthReachedSignalType& TextField::MaxLengthReachedSignal()
{
- return Dali::Toolkit::GetImpl( *this ).MaxLengthReachedSignal();
+ return Dali::Toolkit::GetImpl(*this).MaxLengthReachedSignal();
}
TextField::InputStyleChangedSignalType& TextField::InputStyleChangedSignal()
{
- return Dali::Toolkit::GetImpl( *this ).InputStyleChangedSignal();
+ return Dali::Toolkit::GetImpl(*this).InputStyleChangedSignal();
}
-TextField::TextField( Internal::TextField& implementation )
+TextField::TextField(Internal::TextField& implementation)
: Control(implementation)
{
}
-TextField::TextField( Dali::Internal::CustomActor* internal )
-: Control( internal )
+TextField::TextField(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
- VerifyCustomActorPointer<Internal::TextField>( internal );
+ VerifyCustomActorPointer<Internal::TextField>(internal);
}
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class TextField;
class DALI_TOOLKIT_API TextField : public Control
{
public:
-
/**
* @brief The start and end property ranges for this control.
* @SINCE_1_0.0
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices @SINCE_1_0.0
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices @SINCE_1_0.0
};
/**
*/
enum ExceedPolicy
{
- EXCEED_POLICY_ORIGINAL, ///< The text will be display at original size, and may exceed the TextField boundary. @SINCE_1_0.0
- EXCEED_POLICY_CLIP ///< The end of text will be clipped to fit within the TextField. @SINCE_1_0.0
+ EXCEED_POLICY_ORIGINAL, ///< The text will be display at original size, and may exceed the TextField boundary. @SINCE_1_0.0
+ EXCEED_POLICY_CLIP ///< The end of text will be clipped to fit within the TextField. @SINCE_1_0.0
};
/**
*/
struct InputStyle
{
- /**
+ /**
* @brief Mask used by the signal InputStyleChangedSignal().
*
* @SINCE_1_2_2
*/
enum Mask
{
- NONE = 0x0000, ///< @SINCE_1_2_2
- COLOR = 0x0001, ///< @SINCE_1_2_2
- FONT_FAMILY = 0x0002, ///< @SINCE_1_2_2
- POINT_SIZE = 0x0004, ///< @SINCE_1_2_2
- FONT_STYLE = 0x0008, ///< @SINCE_1_2_2
- UNDERLINE = 0x0010, ///< @SINCE_1_2_2
- SHADOW = 0x0020, ///< @SINCE_1_2_2
- EMBOSS = 0x0040, ///< @SINCE_1_2_2
- OUTLINE = 0x0080 ///< @SINCE_1_2_2
+ NONE = 0x0000, ///< @SINCE_1_2_2
+ COLOR = 0x0001, ///< @SINCE_1_2_2
+ FONT_FAMILY = 0x0002, ///< @SINCE_1_2_2
+ POINT_SIZE = 0x0004, ///< @SINCE_1_2_2
+ FONT_STYLE = 0x0008, ///< @SINCE_1_2_2
+ UNDERLINE = 0x0010, ///< @SINCE_1_2_2
+ SHADOW = 0x0020, ///< @SINCE_1_2_2
+ EMBOSS = 0x0040, ///< @SINCE_1_2_2
+ OUTLINE = 0x0080 ///< @SINCE_1_2_2
};
};
* @brief Text changed signal type.
* @SINCE_1_0.0
*/
- typedef Signal<void ( TextField ) > TextChangedSignalType;
+ typedef Signal<void(TextField)> TextChangedSignalType;
/**
* @brief Max Characters Exceed signal type.
* @SINCE_1_0.0
*/
- typedef Signal<void ( TextField ) > MaxLengthReachedSignalType;
+ typedef Signal<void(TextField)> MaxLengthReachedSignalType;
/**
* @brief Input Style changed signal type.
* @SINCE_1_2_2
*/
- typedef Signal<void ( TextField, InputStyle::Mask ) > InputStyleChangedSignalType;
+ typedef Signal<void(TextField, InputStyle::Mask)> InputStyleChangedSignalType;
/**
* @brief Creates the TextField control.
* @SINCE_1_0.0
* @param[in] handle The handle to copy from
*/
- TextField( const TextField& handle );
+ TextField(const TextField& handle);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- TextField( TextField&& rhs );
+ TextField(TextField&& rhs);
/**
* @brief Assignment operator.
* @param[in] handle The handle to copy from
* @return A reference to this
*/
- TextField& operator=( const TextField& handle );
+ TextField& operator=(const TextField& handle);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- TextField& operator=( TextField&& rhs );
+ TextField& operator=(TextField&& rhs);
/**
* @brief Destructor.
* @param[in] handle Handle to an object
* @return Handle to a TextField or an empty handle
*/
- static TextField DownCast( BaseHandle handle );
+ static TextField DownCast(BaseHandle handle);
// Signals
InputStyleChangedSignalType& InputStyleChangedSignal();
public: // Not intended for application developers
-
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
*
* @SINCE_1_0.0
* @param[in] implementation The Control implementation
*/
- DALI_INTERNAL TextField( Internal::TextField& implementation );
+ DALI_INTERNAL TextField(Internal::TextField& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor
*/
- explicit DALI_INTERNAL TextField( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL TextField(Dali::Internal::CustomActor* internal);
};
/**
namespace Dali
{
-
namespace Toolkit
{
-
TextLabel TextLabel::New()
{
return Internal::TextLabel::New();
}
-TextLabel TextLabel::New( const std::string& text )
+TextLabel TextLabel::New(const std::string& text)
{
TextLabel label = Internal::TextLabel::New();
- label.SetProperty( TextLabel::Property::TEXT, text );
+ label.SetProperty(TextLabel::Property::TEXT, text);
return label;
}
{
}
-TextLabel::TextLabel( const TextLabel& handle ) = default;
+TextLabel::TextLabel(const TextLabel& handle) = default;
-TextLabel::TextLabel( TextLabel&& rhs ) = default;
+TextLabel::TextLabel(TextLabel&& rhs) = default;
-TextLabel& TextLabel::operator=( const TextLabel& handle ) = default;
+TextLabel& TextLabel::operator=(const TextLabel& handle) = default;
-TextLabel& TextLabel::operator=( TextLabel&& rhs ) = default;
+TextLabel& TextLabel::operator=(TextLabel&& rhs) = default;
TextLabel::~TextLabel()
{
}
-TextLabel TextLabel::DownCast( BaseHandle handle )
+TextLabel TextLabel::DownCast(BaseHandle handle)
{
return Control::DownCast<TextLabel, Internal::TextLabel>(handle);
}
-TextLabel::TextLabel( Internal::TextLabel& implementation )
+TextLabel::TextLabel(Internal::TextLabel& implementation)
: Control(implementation)
{
}
-TextLabel::TextLabel( Dali::Internal::CustomActor* internal )
-: Control( internal )
+TextLabel::TextLabel(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
- VerifyCustomActorPointer<Internal::TextLabel>( internal );
+ VerifyCustomActorPointer<Internal::TextLabel>(internal);
}
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class TextLabel;
class DALI_TOOLKIT_API TextLabel : public Control
{
public:
-
/**
* @brief Enumeration for the start and end property ranges for this control.
* @SINCE_1_0.0
enum PropertyRange
{
PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_0.0
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000, ///< Reserve property indices @SINCE_1_0.0
- ANIMATABLE_PROPERTY_START_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX, ///< @SINCE_1_2.60
- ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve animatable property indices @SINCE_1_2.60
+ ANIMATABLE_PROPERTY_START_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX, ///< @SINCE_1_2.60
+ ANIMATABLE_PROPERTY_END_INDEX = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000 ///< Reserve animatable property indices @SINCE_1_2.60
};
/**
*/
enum Type
{
- FINISH_LOOP = 0, ///< Stop animation after current loop finishes. @SINCE_1_2.60
- IMMEDIATE ///< Stop animation immediately and reset position. @SINCE_1_2.60
+ FINISH_LOOP = 0, ///< Stop animation after current loop finishes. @SINCE_1_2.60
+ IMMEDIATE ///< Stop animation immediately and reset position. @SINCE_1_2.60
};
};
* @param[in] text The text to display
* @return A handle to the TextLabel control
*/
- static TextLabel New( const std::string& text );
+ static TextLabel New(const std::string& text);
/**
* @brief Creates an empty handle.
* @SINCE_1_0.0
* @param[in] handle The handle to copy from
*/
- TextLabel( const TextLabel& handle );
+ TextLabel(const TextLabel& handle);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- TextLabel( TextLabel&& rhs );
+ TextLabel(TextLabel&& rhs);
/**
* @brief Assignment operator.
* @param[in] handle The handle to copy from
* @return A reference to this
*/
- TextLabel& operator=( const TextLabel& handle );
+ TextLabel& operator=(const TextLabel& handle);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- TextLabel& operator=( TextLabel&& rhs );
+ TextLabel& operator=(TextLabel&& rhs);
/**
* @brief Destructor.
* @param[in] handle Handle to an object
* @return Handle to a TextLabel or an empty handle
*/
- static TextLabel DownCast( BaseHandle handle );
+ static TextLabel DownCast(BaseHandle handle);
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_0.0
* @param[in] implementation The Control implementation
*/
- DALI_INTERNAL TextLabel( Internal::TextLabel& implementation );
+ DALI_INTERNAL TextLabel(Internal::TextLabel& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
* @SINCE_1_0.0
* @param[in] internal A pointer to the internal CustomActor
*/
- explicit DALI_INTERNAL TextLabel( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL TextLabel(Dali::Internal::CustomActor* internal);
/// @endcond
};
#include <dali-toolkit/public-api/controls/video-view/video-view.h>
// EXTERNAL INCLUDES
-#include <dali/public-api/object/property-map.h>
#include <dali/devel-api/adaptor-framework/video-sync-mode.h>
+#include <dali/public-api/object/property-map.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/video-view/video-view-impl.h>
namespace Dali
{
-
namespace Toolkit
{
-
VideoView::VideoView()
{
}
-VideoView::VideoView( const VideoView& videoView ) = default;
+VideoView::VideoView(const VideoView& videoView) = default;
-VideoView::VideoView( VideoView&& rhs ) = default;
+VideoView::VideoView(VideoView&& rhs) = default;
-VideoView& VideoView::operator=( const VideoView& videoView ) = default;
+VideoView& VideoView::operator=(const VideoView& videoView) = default;
-VideoView& VideoView::operator=( VideoView&& rhs ) = default;
+VideoView& VideoView::operator=(VideoView&& rhs) = default;
VideoView::~VideoView()
{
VideoView VideoView::New()
{
- return Internal::VideoView::New( Dali::VideoSyncMode::DISABLED );
+ return Internal::VideoView::New(Dali::VideoSyncMode::DISABLED);
}
-VideoView VideoView::New( const std::string& url )
+VideoView VideoView::New(const std::string& url)
{
- VideoView videoView = Internal::VideoView::New( Dali::VideoSyncMode::DISABLED );
- Dali::Toolkit::GetImpl( videoView ).SetUrl( url );
+ VideoView videoView = Internal::VideoView::New(Dali::VideoSyncMode::DISABLED);
+ Dali::Toolkit::GetImpl(videoView).SetUrl(url);
return videoView;
}
-VideoView VideoView::New( bool swCodec )
+VideoView VideoView::New(bool swCodec)
{
- VideoView videoView = Internal::VideoView::New( Dali::VideoSyncMode::DISABLED );
- Dali::Toolkit::GetImpl( videoView ).SetSWCodec( swCodec );
+ VideoView videoView = Internal::VideoView::New(Dali::VideoSyncMode::DISABLED);
+ Dali::Toolkit::GetImpl(videoView).SetSWCodec(swCodec);
return videoView;
}
-VideoView VideoView::New( const std::string& url, bool swCodec )
+VideoView VideoView::New(const std::string& url, bool swCodec)
{
- VideoView videoView = Internal::VideoView::New( Dali::VideoSyncMode::DISABLED );
- Dali::Toolkit::GetImpl( videoView ).SetUrl( url );
- Dali::Toolkit::GetImpl( videoView ).SetSWCodec( swCodec );
+ VideoView videoView = Internal::VideoView::New(Dali::VideoSyncMode::DISABLED);
+ Dali::Toolkit::GetImpl(videoView).SetUrl(url);
+ Dali::Toolkit::GetImpl(videoView).SetSWCodec(swCodec);
return videoView;
}
-VideoView VideoView::DownCast( BaseHandle handle )
+VideoView VideoView::DownCast(BaseHandle handle)
{
- return Control::DownCast< VideoView, Internal::VideoView >( handle );
+ return Control::DownCast<VideoView, Internal::VideoView>(handle);
}
void VideoView::Play()
{
- Dali::Toolkit::GetImpl( *this ).Play();
+ Dali::Toolkit::GetImpl(*this).Play();
}
void VideoView::Pause()
{
- Dali::Toolkit::GetImpl( *this ).Pause();
+ Dali::Toolkit::GetImpl(*this).Pause();
}
void VideoView::Stop()
{
- Dali::Toolkit::GetImpl( *this ).Stop();
+ Dali::Toolkit::GetImpl(*this).Stop();
}
-void VideoView::Forward( int millisecond )
+void VideoView::Forward(int millisecond)
{
- Dali::Toolkit::GetImpl( *this ).Forward( millisecond );
+ Dali::Toolkit::GetImpl(*this).Forward(millisecond);
}
-void VideoView::Backward( int millisecond )
+void VideoView::Backward(int millisecond)
{
- Dali::Toolkit::GetImpl( *this ).Backward( millisecond );
+ Dali::Toolkit::GetImpl(*this).Backward(millisecond);
}
VideoView::VideoViewSignalType& VideoView::FinishedSignal()
{
- return Dali::Toolkit::GetImpl( *this ).FinishedSignal();
+ return Dali::Toolkit::GetImpl(*this).FinishedSignal();
}
-VideoView::VideoView( Internal::VideoView& implementation )
-: Control( implementation )
+VideoView::VideoView(Internal::VideoView& implementation)
+: Control(implementation)
{
}
-VideoView::VideoView( Dali::Internal::CustomActor* internal )
-: Control( internal )
+VideoView::VideoView(Dali::Internal::CustomActor* internal)
+: Control(internal)
{
- VerifyCustomActorPointer< Internal::VideoView >( internal );
+ VerifyCustomActorPointer<Internal::VideoView>(internal);
}
} // namespace Toolkit
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
- class VideoView;
-} // namespace Internal
+class VideoView;
+} // namespace DALI_INTERNAL
/**
* @addtogroup dali_toolkit_controls_video_view
* @SINCE_1_1.38
*
*/
-class DALI_TOOLKIT_API VideoView: public Control
+class DALI_TOOLKIT_API VideoView : public Control
{
public:
-
// Signal
- typedef Signal< void (VideoView&) > VideoViewSignalType; ///< Video playback finished signal type @ SINCE_1_1.38
+ typedef Signal<void(VideoView&)> VideoViewSignalType; ///< Video playback finished signal type @ SINCE_1_1.38
public:
-
/**
* @brief Enumeration for the start and end property ranges for this control.
* @SINCE_1_0.0
*/
enum PropertyRange
{
- PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
+ PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1, ///< @SINCE_1_0.0
};
/**
*/
VIDEO = PROPERTY_START_INDEX,
- /**
+ /**
* @brief name "looping", looping status, true or false.
* @SINCE_1_1.38
*/
LOOPING,
- /**
+ /**
* @brief name "muted", mute status, true or false.
* @SINCE_1_1.38
*/
MUTED,
- /**
+ /**
* @brief name "volume", left and right volume scalar as float type, Property::Map with two values ( "left" and "right" ).
* @SINCE_1_1.38
*/
VOLUME,
- /**
+ /**
* @brief name "underlay", Video rendering by underlay, true or false
* This shows video composited underneath the window by the system. This means it may ignore rotation of the video-view
* If false, video-view shows decoded frame images sequentially.
*/
UNDERLAY,
- /**
+ /**
* @brief The play position (millisecond) of the video.
* @details Name "playPosition", type Property::INTEGER
* @SINCE_1_3_9
};
public:
-
/**
* @brief Creates an initialized VideoView.
* @SINCE_1_1.38
* @param[in] url The url of the video resource to display
* @return A handle to a newly allocated Dali VideoView
*/
- static VideoView New( const std::string& url );
+ static VideoView New(const std::string& url);
/**
* @brief Creates an initialized VideoView.
*
* @note If platform or target does not support sw codec, video-view shows an error message and video by default codec type
*/
- static VideoView New( bool swCodec );
+ static VideoView New(bool swCodec);
/**
* @brief Creates an initialized VideoView.
*
* @note If platform or target does not support sw codec, video-view shows an error message and video by default codec type
*/
- static VideoView New( const std::string& url, bool swCodec );
+ static VideoView New(const std::string& url, bool swCodec);
/**
* @brief Creates an uninitialized VideoView.
* @SINCE_1_1.38
* @param[in] videoView VideoView to copy. The copied VideoView will point at the same implementation
*/
- VideoView( const VideoView& videoView );
+ VideoView(const VideoView& videoView);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- VideoView( VideoView&& rhs );
+ VideoView(VideoView&& rhs);
/**
* @brief Assignment operator.
* @param[in] videoView The VideoView to assign from
* @return The updated VideoView
*/
- VideoView& operator=( const VideoView& videoView );
+ VideoView& operator=(const VideoView& videoView);
/**
* @brief Move assignment
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- VideoView& operator=( VideoView&& rhs );
+ VideoView& operator=(VideoView&& rhs);
/**
* @brief Downcasts a handle to VideoView handle.
* @param[in] handle Handle to an object
* @return Handle to a VideoView or an uninitialized handle
*/
- static VideoView DownCast( BaseHandle handle );
+ static VideoView DownCast(BaseHandle handle);
/**
* @brief Starts the video playback.
* @SINCE_1_1.38
* @param[in] millisecond The position for forward playback
*/
- void Forward( int millisecond );
+ void Forward(int millisecond);
/**
* @brief Seeks backward by the specified number of milliseconds.
* @SINCE_1_1.38
* @param[in] millisecond The position for backward playback
*/
- void Backward( int millisecond );
+ void Backward(int millisecond);
/**
* @brief Connects to this signal to be notified when a video playback is finished.
VideoViewSignalType& FinishedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
* @SINCE_1_1.38
* @param[in] implementation The VideoView implementation
*/
- DALI_INTERNAL VideoView( Internal::VideoView& implementation );
+ DALI_INTERNAL VideoView(Internal::VideoView& implementation);
/**
* @brief Allows the creation of this VideoView from an Internal::CustomActor pointer.
* @SINCE_1_1.38
* @param[in] internal A pointer to the internal CustomActor
*/
- DALI_INTERNAL VideoView( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL VideoView(Dali::Internal::CustomActor* internal);
/// @endcond
-
};
/**
#define DALI_TOOLKIT_COMMON_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
* When building a library that uses DALI, HIDE_DALI_INTERNALS.
*/
#if __GNUC__ >= 4
-# ifndef HIDE_DALI_INTERNALS
-# define DALI_TOOLKIT_API
-# else
-# define DALI_TOOLKIT_API __attribute__ ((visibility ("default")))
-# endif
+#ifndef HIDE_DALI_INTERNALS
+#define DALI_TOOLKIT_API
+#else
+#define DALI_TOOLKIT_API __attribute__((visibility("default")))
+#endif
#else
#ifdef WIN32
#ifdef BUILDING_DALI_TOOLKIT
/** Visibility attribute to hide declarations */
-# define DALI_TOOLKIT_API __declspec(dllexport)
+#define DALI_TOOLKIT_API __declspec(dllexport)
#else
/** Visibility attribute to hide declarations */
-# define DALI_TOOLKIT_API __declspec(dllimport)
+#define DALI_TOOLKIT_API __declspec(dllimport)
#endif
#else
/** Visibility attribute to show declarations */
-# define DALI_TOOLKIT_API
+#define DALI_TOOLKIT_API
#endif
#endif
namespace Dali
{
-
namespace Toolkit
{
-
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 9;
const unsigned int TOOLKIT_MICRO_VERSION = 28;
-const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
+const char* const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
namespace
#define DALI_TOOLKIT_VERSION_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
DALI_TOOLKIT_API extern const unsigned int TOOLKIT_MAJOR_VERSION; ///< The major version number of the Toolkit.
DALI_TOOLKIT_API extern const unsigned int TOOLKIT_MINOR_VERSION; ///< The minor version number of the Toolkit.
DALI_TOOLKIT_API extern const unsigned int TOOLKIT_MICRO_VERSION; ///< The micro version number of the Toolkit.
-DALI_TOOLKIT_API extern const char * const TOOLKIT_BUILD_DATE; ///< The date/time the Toolkit library was built.
+DALI_TOOLKIT_API extern const char* const TOOLKIT_BUILD_DATE; ///< The date/time the Toolkit library was built.
} // namespace Toolkit
} // namespace Dali
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
bool IsVertical(ControlOrientation::Type orientation)
{
return (orientation == ControlOrientation::Up ||
#define DALI_TOOLKIT_ENUMS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
namespace ControlOrientation
{
-
/**
* @brief Enumeration for the internal orientation of a control.
* @SINCE_1_0.0
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
KeyboardFocusManager::KeyboardFocusManager()
{
}
return Internal::KeyboardFocusManager::Get();
}
-KeyboardFocusManager::KeyboardFocusManager(Internal::KeyboardFocusManager *impl)
- : BaseHandle(impl)
+KeyboardFocusManager::KeyboardFocusManager(Internal::KeyboardFocusManager* impl)
+: BaseHandle(impl)
{
}
#define DALI_TOOLKIT_KEYBOARD_FOCUS_MANAGER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class KeyboardFocusManager;
*/
class DALI_TOOLKIT_API KeyboardFocusManager : public BaseHandle
{
-
public:
-
/// @brief Pre focus change signal
- typedef Signal< Actor ( Actor, Actor, Control::KeyboardFocus::Direction ) > PreFocusChangeSignalType;
+ typedef Signal<Actor(Actor, Actor, Control::KeyboardFocus::Direction)> PreFocusChangeSignalType;
/// @brief Focus changed signal
- typedef Signal< void ( Actor, Actor ) > FocusChangedSignalType;
+ typedef Signal<void(Actor, Actor)> FocusChangedSignalType;
/// @brief Focus group changed signal
- typedef Signal< void ( Actor, bool ) > FocusGroupChangedSignalType;
+ typedef Signal<void(Actor, bool)> FocusGroupChangedSignalType;
/// @brief Focused actor has the enter key pressed signal
- typedef Signal< void ( Actor ) > FocusedActorEnterKeySignalType;
+ typedef Signal<void(Actor)> FocusedActorEnterKeySignalType;
/**
* @brief Creates a KeyboardFocusManager handle; this can be initialized with KeyboardFocusManager::New().
void MoveFocusBackward();
public: // Signals
-
/**
* @brief This signal is emitted before the focus is going to be changed.
*
* @SINCE_1_0.0
* @param[in] impl A pointer to the object
*/
- explicit DALI_INTERNAL KeyboardFocusManager(Internal::KeyboardFocusManager *impl);
+ explicit DALI_INTERNAL KeyboardFocusManager(Internal::KeyboardFocusManager* impl);
/// @endcond
}; // class KeyboardFocusManager
namespace Dali
{
-
namespace Toolkit
{
-
AsyncImageLoader::AsyncImageLoader()
{
}
{
}
-AsyncImageLoader::AsyncImageLoader( Internal::AsyncImageLoader* impl )
-: BaseHandle( impl )
+AsyncImageLoader::AsyncImageLoader(Internal::AsyncImageLoader* impl)
+: BaseHandle(impl)
{
}
-AsyncImageLoader::AsyncImageLoader( const AsyncImageLoader& handle ) = default;
+AsyncImageLoader::AsyncImageLoader(const AsyncImageLoader& handle) = default;
-AsyncImageLoader::AsyncImageLoader( AsyncImageLoader&& rhs ) = default;
+AsyncImageLoader::AsyncImageLoader(AsyncImageLoader&& rhs) = default;
-AsyncImageLoader& AsyncImageLoader::operator=( const AsyncImageLoader& handle ) = default;
+AsyncImageLoader& AsyncImageLoader::operator=(const AsyncImageLoader& handle) = default;
-AsyncImageLoader& AsyncImageLoader::operator=( AsyncImageLoader&& rhs ) = default;
+AsyncImageLoader& AsyncImageLoader::operator=(AsyncImageLoader&& rhs) = default;
-AsyncImageLoader AsyncImageLoader::DownCast( BaseHandle handle )
+AsyncImageLoader AsyncImageLoader::DownCast(BaseHandle handle)
{
- return AsyncImageLoader( dynamic_cast<Dali::Toolkit::Internal::AsyncImageLoader*>( handle.GetObjectPtr() ) );
+ return AsyncImageLoader(dynamic_cast<Dali::Toolkit::Internal::AsyncImageLoader*>(handle.GetObjectPtr()));
}
AsyncImageLoader AsyncImageLoader::New()
{
IntrusivePtr<Internal::AsyncImageLoader> internal = Internal::AsyncImageLoader::New();
- return AsyncImageLoader( internal.Get() );
+ return AsyncImageLoader(internal.Get());
}
-uint32_t AsyncImageLoader::Load( const std::string& url )
+uint32_t AsyncImageLoader::Load(const std::string& url)
{
- return GetImplementation( *this ).Load( Toolkit::Internal::VisualUrl(url), ImageDimensions(), FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true, DevelAsyncImageLoader::PreMultiplyOnLoad::OFF );
+ return GetImplementation(*this).Load(Toolkit::Internal::VisualUrl(url), ImageDimensions(), FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true, DevelAsyncImageLoader::PreMultiplyOnLoad::OFF);
}
-uint32_t AsyncImageLoader::Load( const std::string& url, ImageDimensions dimensions )
+uint32_t AsyncImageLoader::Load(const std::string& url, ImageDimensions dimensions)
{
- return GetImplementation( *this ).Load( Toolkit::Internal::VisualUrl(url), dimensions, FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true , DevelAsyncImageLoader::PreMultiplyOnLoad::OFF );
+ return GetImplementation(*this).Load(Toolkit::Internal::VisualUrl(url), dimensions, FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true, DevelAsyncImageLoader::PreMultiplyOnLoad::OFF);
}
-uint32_t AsyncImageLoader::Load( const std::string& url,
- ImageDimensions dimensions,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection )
+uint32_t AsyncImageLoader::Load(const std::string& url,
+ ImageDimensions dimensions,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection)
{
- return GetImplementation(*this).Load( Toolkit::Internal::VisualUrl(url), dimensions, fittingMode, samplingMode, orientationCorrection, DevelAsyncImageLoader::PreMultiplyOnLoad::OFF );
+ return GetImplementation(*this).Load(Toolkit::Internal::VisualUrl(url), dimensions, fittingMode, samplingMode, orientationCorrection, DevelAsyncImageLoader::PreMultiplyOnLoad::OFF);
}
-bool AsyncImageLoader::Cancel( uint32_t loadingTaskId )
+bool AsyncImageLoader::Cancel(uint32_t loadingTaskId)
{
- return GetImplementation(*this).Cancel( loadingTaskId );
+ return GetImplementation(*this).Cancel(loadingTaskId);
}
void AsyncImageLoader::CancelAll()
{
- GetImplementation( *this ).CancelAll();
+ GetImplementation(*this).CancelAll();
}
AsyncImageLoader::ImageLoadedSignalType& AsyncImageLoader::ImageLoadedSignal()
{
- return GetImplementation( *this ).ImageLoadedSignal();
+ return GetImplementation(*this).ImageLoadedSignal();
}
} // namespace Toolkit
*/
// EXTERNAL INCLUDES
-#include <string>
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/images/image-operations.h>
+#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal.h>
+#include <string>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/dali-toolkit-common.h>
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class AsyncImageLoader;
class DALI_TOOLKIT_API AsyncImageLoader : public BaseHandle
{
public:
-
- typedef Signal< void( uint32_t, PixelData ) > ImageLoadedSignalType; ///< Image loaded signal type @SINCE_1_2_14
+ typedef Signal<void(uint32_t, PixelData)> ImageLoadedSignalType; ///< Image loaded signal type @SINCE_1_2_14
public:
-
/**
* @brief Constructor which creates an empty AsyncImageLoader handle.
* @SINCE_1_2_14
*
* @param[in] handle A reference to the copied handle
*/
- AsyncImageLoader( const AsyncImageLoader& handle );
+ AsyncImageLoader(const AsyncImageLoader& handle);
/**
* @brief Move constructor
*
* @param[in] rhs A reference to the moved handle
*/
- AsyncImageLoader( AsyncImageLoader&& rhs );
+ AsyncImageLoader(AsyncImageLoader&& rhs);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param[in] handle A reference to the copied handle
* @return A reference to this
*/
- AsyncImageLoader& operator=( const AsyncImageLoader& handle );
+ AsyncImageLoader& operator=(const AsyncImageLoader& handle);
/**
* @brief Move assignment
*
* @param[in] rhs A reference to the moved handle
*/
- AsyncImageLoader& operator=( AsyncImageLoader&& rhs );
+ AsyncImageLoader& operator=(AsyncImageLoader&& rhs);
/**
* @brief Creates a new loader to load the image asynchronously in a worker thread.
* @param[in] handle A handle to an object
* @return A handle to a AsyncImageLoader object or an uninitialized handle
*/
- static AsyncImageLoader DownCast( BaseHandle handle );
+ static AsyncImageLoader DownCast(BaseHandle handle);
/**
* @brief Starts an image loading task.
* @param[in] url The URL of the image file to load
* @return The loading task id
*/
- uint32_t Load( const std::string& url );
+ uint32_t Load(const std::string& url);
/**
* @brief Starts an image loading task.
* @param[in] dimensions The width and height to fit the loaded image to
* @return The loading task id
*/
- uint32_t Load( const std::string& url, ImageDimensions dimensions );
+ uint32_t Load(const std::string& url, ImageDimensions dimensions);
/**
* @brief Starts an image loading task.
* @param[in] orientationCorrection Reorient the image to respect any orientation metadata in its header
* @return The loading task id
*/
- uint32_t Load( const std::string& url,
- ImageDimensions dimensions,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection );
+ uint32_t Load(const std::string& url,
+ ImageDimensions dimensions,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection);
/**
* @brief Cancels an image loading task if it is still queueing in the work thread.
* @param[in] loadingTaskId The task id returned when invoking the load call.
* @return If true, the loading task is removed from the queue, otherwise the loading is already implemented and unable to cancel anymore
*/
- bool Cancel( uint32_t loadingTaskId );
+ bool Cancel(uint32_t loadingTaskId);
/**
* @brief Cancels all the loading tasks in the queue.
ImageLoadedSignalType& ImageLoadedSignal();
public: // Not intended for developer use
-
/// @cond internal
/**
* @brief Allows the creation of a AsyncImageLoader handle from an internal pointer.
* @SINCE_1_2_14
* @param[in] impl A pointer to the object
*/
- explicit DALI_INTERNAL AsyncImageLoader( Internal::AsyncImageLoader* impl );
+ explicit DALI_INTERNAL AsyncImageLoader(Internal::AsyncImageLoader* impl);
/// @endcond
-
};
/**
namespace Dali
{
-
namespace Toolkit
{
-
namespace Image
{
-
-std::string GenerateUrl( Dali::FrameBuffer frameBuffer, Pixel::Format pixelFormat, uint32_t width, uint32_t height )
+std::string GenerateUrl(Dali::FrameBuffer frameBuffer, Pixel::Format pixelFormat, uint32_t width, uint32_t height)
{
- Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D, pixelFormat, width, height );
- frameBuffer.AttachColorTexture( texture, 0u, 0u );
- return Dali::Toolkit::TextureManager::AddTexture( texture );
+ Texture texture = Texture::New(Dali::TextureType::TEXTURE_2D, pixelFormat, width, height);
+ frameBuffer.AttachColorTexture(texture, 0u, 0u);
+ return Dali::Toolkit::TextureManager::AddTexture(texture);
}
-std::string GenerateUrl( const Dali::FrameBuffer frameBuffer, uint8_t index )
+std::string GenerateUrl(const Dali::FrameBuffer frameBuffer, uint8_t index)
{
- Texture texture = Dali::DevelFrameBuffer::GetColorTexture( frameBuffer, index );
- return Dali::Toolkit::TextureManager::AddTexture( texture );
+ Texture texture = Dali::DevelFrameBuffer::GetColorTexture(frameBuffer, index);
+ return Dali::Toolkit::TextureManager::AddTexture(texture);
}
-std::string GenerateUrl( const Dali::PixelData pixelData )
+std::string GenerateUrl(const Dali::PixelData pixelData)
{
- Texture texture = Texture::New( TextureType::TEXTURE_2D, pixelData.GetPixelFormat(), pixelData.GetWidth(), pixelData.GetHeight() );
- texture.Upload( pixelData );
- return Dali::Toolkit::TextureManager::AddTexture( texture );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, pixelData.GetPixelFormat(), pixelData.GetWidth(), pixelData.GetHeight());
+ texture.Upload(pixelData);
+ return Dali::Toolkit::TextureManager::AddTexture(texture);
}
-std::string GenerateUrl( const Dali::NativeImageSourcePtr nativeImageSource )
+std::string GenerateUrl(const Dali::NativeImageSourcePtr nativeImageSource)
{
- Texture texture = Dali::Texture::New( *nativeImageSource );
- return Dali::Toolkit::TextureManager::AddTexture( texture );
+ Texture texture = Dali::Texture::New(*nativeImageSource);
+ return Dali::Toolkit::TextureManager::AddTexture(texture);
}
-} // Image
+} // namespace Image
-} // Toolkit
+} // namespace Toolkit
-} // Dali
+} // namespace Dali
*/
// EXTERNAL INCLUDES
+#include <dali/public-api/adaptor-framework/native-image-source.h>
#include <dali/public-api/images/pixel-data.h>
#include <dali/public-api/rendering/frame-buffer.h>
-#include <dali/public-api/adaptor-framework/native-image-source.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/dali-toolkit-common.h>
namespace Dali
{
-
namespace Toolkit
{
-
/**
* API to interface with the toolkit image
* Allows developers to add FrameBuffer, PixelData and NativeImageSource to toolkit so that visuals can use them to render
*/
namespace Image
{
-
/**
* @brief Generate a Url from frame buffer.
* This Url can be used in visuals to render the frame buffer.
* @param[in] height the height for this frame buffer
* @return the Url string representing this frame buffer
*/
-DALI_TOOLKIT_API std::string GenerateUrl( const Dali::FrameBuffer frameBuffer, Pixel::Format pixelFormat, uint32_t width, uint32_t height );
+DALI_TOOLKIT_API std::string GenerateUrl(const Dali::FrameBuffer frameBuffer, Pixel::Format pixelFormat, uint32_t width, uint32_t height);
/**
* @brief Generate a Url from frame buffer.
* @param[in] index the index of the attached color texture.
* @return the Url string representing this frame buffer
*/
-DALI_TOOLKIT_API std::string GenerateUrl( const Dali::FrameBuffer frameBuffer, uint8_t index );
+DALI_TOOLKIT_API std::string GenerateUrl(const Dali::FrameBuffer frameBuffer, uint8_t index);
/**
* @brief Generate a Url from Pixel data.
* @param[in] pixelData the pixel data to converted to Url
* @return the Url string representing this pixel data
*/
-DALI_TOOLKIT_API std::string GenerateUrl( const Dali::PixelData pixelData );
+DALI_TOOLKIT_API std::string GenerateUrl(const Dali::PixelData pixelData);
/**
* @brief Generate a Url from native image source.
* @param[in] nativeImageSource the native image source to converted to Url
* @return the Url string representing this native image source
*/
-DALI_TOOLKIT_API std::string GenerateUrl( const Dali::NativeImageSourcePtr nativeImageSource );
+DALI_TOOLKIT_API std::string GenerateUrl(const Dali::NativeImageSourcePtr nativeImageSource);
-} // Image
+} // namespace Image
-} // Toolkit
+} // namespace Toolkit
-} // Dali
+} // namespace Dali
#endif // DALI_TOOLKIT_IMAGE_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include "sync-image-loader.h"
#include <dali/devel-api/adaptor-framework/image-loading.h>
-
namespace Dali
{
-
namespace Toolkit
{
-
namespace SyncImageLoader
{
-
-
-PixelData Load( const std::string& url )
+PixelData Load(const std::string& url)
{
- return Load( url, ImageDimensions(), FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true );
+ return Load(url, ImageDimensions(), FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true);
}
-PixelData Load( const std::string& url, ImageDimensions dimensions )
+PixelData Load(const std::string& url, ImageDimensions dimensions)
{
- return Load( url, dimensions, FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true );
+ return Load(url, dimensions, FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true);
}
-PixelData Load( const std::string& url,
- ImageDimensions dimensions,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection )
+PixelData Load(const std::string& url,
+ ImageDimensions dimensions,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection)
{
// Load the image synchronously (block the thread here).
- Devel::PixelBuffer pixelBuffer = Dali::LoadImageFromFile( url, dimensions, fittingMode, samplingMode, orientationCorrection );
- if( pixelBuffer )
+ Devel::PixelBuffer pixelBuffer = Dali::LoadImageFromFile(url, dimensions, fittingMode, samplingMode, orientationCorrection);
+ if(pixelBuffer)
{
- return Devel::PixelBuffer::Convert( pixelBuffer );
+ return Devel::PixelBuffer::Convert(pixelBuffer);
}
return Dali::PixelData(); // return empty handle
}
-
} // namespace SyncImageLoader
} // namespace Toolkit
#define DALI_TOOLKIT_SYNC_IMAGE_LOADER_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <string>
#include <dali/public-api/images/image-operations.h>
#include <dali/public-api/images/pixel-data.h>
+#include <string>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/dali-toolkit-common.h>
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_image_loader
* @{
namespace SyncImageLoader
{
-
/**
* @brief The methods in the SyncImageLoader namespace are used to load pixel data from a URL synchronously.
*
* @param[in] url The URL of the image file to load
* @return A PixelData object containing the image, or an invalid object on failure
*/
-DALI_TOOLKIT_API PixelData Load( const std::string& url );
+DALI_TOOLKIT_API PixelData Load(const std::string& url);
/**
* @brief Loads an image synchronously by specifying the target dimensions.
* @param[in] dimensions The width and height to fit the loaded image to
* @return A PixelData object containing the image, or an invalid object on failure
*/
-DALI_TOOLKIT_API PixelData Load( const std::string& url, ImageDimensions dimensions );
+DALI_TOOLKIT_API PixelData Load(const std::string& url, ImageDimensions dimensions);
/**
* @brief Loads an image synchronously by specifying the target dimensions and options.
* @param[in] orientationCorrection Reorient the image to respect any orientation metadata in its header
* @return A PixelData object containing the image, or an invalid object on failure
*/
-DALI_TOOLKIT_API PixelData Load( const std::string& url,
- ImageDimensions dimensions,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection );
+DALI_TOOLKIT_API PixelData Load(const std::string& url,
+ ImageDimensions dimensions,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection);
} // namespace SyncImageLoader
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
StyleManager::StyleManager()
{
}
return Internal::StyleManager::Get();
}
-void StyleManager::ApplyTheme( const std::string& themeFile )
+void StyleManager::ApplyTheme(const std::string& themeFile)
{
- GetImpl(*this).ApplyTheme( themeFile );
+ GetImpl(*this).ApplyTheme(themeFile);
}
void StyleManager::ApplyDefaultTheme()
GetImpl(*this).ApplyDefaultTheme();
}
-void StyleManager::SetStyleConstant( const std::string& key, const Property::Value& value )
+void StyleManager::SetStyleConstant(const std::string& key, const Property::Value& value)
{
- GetImpl(*this).SetStyleConstant( key, value );
+ GetImpl(*this).SetStyleConstant(key, value);
}
-bool StyleManager::GetStyleConstant( const std::string& key, Property::Value& valueOut )
+bool StyleManager::GetStyleConstant(const std::string& key, Property::Value& valueOut)
{
- return GetImpl(*this).GetStyleConstant( key, valueOut );
+ return GetImpl(*this).GetStyleConstant(key, valueOut);
}
-void StyleManager::ApplyStyle( Toolkit::Control control, const std::string& jsonFileName, const std::string& styleName )
+void StyleManager::ApplyStyle(Toolkit::Control control, const std::string& jsonFileName, const std::string& styleName)
{
- GetImpl(*this).ApplyStyle( control, jsonFileName, styleName );
+ GetImpl(*this).ApplyStyle(control, jsonFileName, styleName);
}
StyleManager::StyleChangedSignalType& StyleManager::StyleChangedSignal()
{
- return GetImpl( *this ).StyleChangedSignal();
+ return GetImpl(*this).StyleChangedSignal();
}
-StyleManager::StyleManager( Internal::StyleManager *impl )
- : BaseHandle( impl )
+StyleManager::StyleManager(Internal::StyleManager* impl)
+: BaseHandle(impl)
{
}
#define DALI_TOOLKIT_STYLE_MANAGER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal DALI_INTERNAL
{
class StyleManager;
class DALI_TOOLKIT_API StyleManager : public BaseHandle
{
public:
-
/// @brief Style Changed signal. Emitted after controls have been updated.
- typedef Signal< void ( StyleManager, StyleChange::Type ) > StyleChangedSignalType;
+ typedef Signal<void(StyleManager, StyleChange::Type)> StyleChangedSignalType;
/**
* @brief Creates a StyleManager handle; this can be initialized with StyleManager::Get().
* @param[in] themeFile If a relative path is specified, then this is relative
* to the directory returned by Application::GetResourcePath()
*/
- void ApplyTheme( const std::string& themeFile );
+ void ApplyTheme(const std::string& themeFile);
/**
* @brief Applies the default Toolkit theme.
* @param[in] key The key of the constant
* @param[in] value The value of the constant
*/
- void SetStyleConstant( const std::string& key, const Property::Value& value );
+ void SetStyleConstant(const std::string& key, const Property::Value& value);
/**
* @brief Returns the style constant set for a specific key.
*
* @return If the constant for key exists, then return the constant in valueOut and return true
*/
- bool GetStyleConstant( const std::string& key, Property::Value& valueOut );
+ bool GetStyleConstant(const std::string& key, Property::Value& valueOut);
/**
* @brief Applies the specified style to the control.
* returned by Application::GetResourcePath()
* @param[in] styleName The name of the style within the JSON file to apply
*/
- void ApplyStyle( Toolkit::Control control, const std::string& jsonFileName, const std::string& styleName );
+ void ApplyStyle(Toolkit::Control control, const std::string& jsonFileName, const std::string& styleName);
public: // Signals
-
/**
* @brief This signal is emitted after the style (e.g. theme/font change) has changed
* and the controls have been informed.
StyleChangedSignalType& StyleChangedSignal();
public:
-
/// @cond internal
/**
* @brief Allows the creation of a StyleManager handle from an internal pointer.
* @SINCE_1_1.32
* @param[in] impl A pointer to the object
*/
- explicit DALI_INTERNAL StyleManager( Internal::StyleManager *impl );
+ explicit DALI_INTERNAL StyleManager(Internal::StyleManager* impl);
/// @endcond
}; // class StyleManager
#define DALI_TOOLKIT_TEXT_ENUMERATIONS_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
/**
namespace Text
{
-
/**
* @brief The available Horizontal alignments for text.
*
*/
namespace HorizontalAlignment
{
-
/**
* @brief Enumerations for Horizontal alignment.
*
*/
enum Type
{
- BEGIN, ///< @SINCE_1_2.60
- CENTER, ///< @SINCE_1_2.60
- END ///< @SINCE_1_2.60
+ BEGIN, ///< @SINCE_1_2.60
+ CENTER, ///< @SINCE_1_2.60
+ END ///< @SINCE_1_2.60
};
} // namespace HorizontalAlignment
*/
namespace VerticalAlignment
{
-
/**
* @brief Enumerations for Vertical alignment.
*
*/
enum Type
{
- TOP, ///< @SINCE_1_2.60
- CENTER, ///< @SINCE_1_2.60
- BOTTOM ///< @SINCE_1_2.60
+ TOP, ///< @SINCE_1_2.60
+ CENTER, ///< @SINCE_1_2.60
+ BOTTOM ///< @SINCE_1_2.60
};
} // namespace VerticalAlignment
*/
namespace LineWrap
{
-
/**
* @brief Enumerations specifying how a line is wrapped.
* @SINCE_1_2.60
*/
enum Mode
{
- WORD, ///< @SINCE_1_2.60
- CHARACTER ///< @SINCE_1_2.60
+ WORD, ///< @SINCE_1_2.60
+ CHARACTER ///< @SINCE_1_2.60
};
} // namespace LineWrap
#define DALI_TOOLKIT_PROPERTY_INDEX_RANGES_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
/**
*/
enum PropertyRanges
{
- VISUAL_PROPERTY_BASE_START_INDEX = CORE_PROPERTY_MAX_INDEX + 1, ///< Visual Property Base Start Index. @SINCE_1_1.45
- VISUAL_PROPERTY_BASE_END_INDEX = VISUAL_PROPERTY_BASE_START_INDEX + 100, ///< Visual Property Base End Index. @SINCE_1_1.45
- VISUAL_PROPERTY_START_INDEX = VISUAL_PROPERTY_BASE_END_INDEX + 1, ///< Visual Property Start Index. @SINCE_1_1.45
- VISUAL_PROPERTY_END_INDEX = VISUAL_PROPERTY_START_INDEX + 100000, ///< Visual Property End Index. @SINCE_1_1.45
+ VISUAL_PROPERTY_BASE_START_INDEX = CORE_PROPERTY_MAX_INDEX + 1, ///< Visual Property Base Start Index. @SINCE_1_1.45
+ VISUAL_PROPERTY_BASE_END_INDEX = VISUAL_PROPERTY_BASE_START_INDEX + 100, ///< Visual Property Base End Index. @SINCE_1_1.45
+ VISUAL_PROPERTY_START_INDEX = VISUAL_PROPERTY_BASE_END_INDEX + 1, ///< Visual Property Start Index. @SINCE_1_1.45
+ VISUAL_PROPERTY_END_INDEX = VISUAL_PROPERTY_START_INDEX + 100000, ///< Visual Property End Index. @SINCE_1_1.45
};
/**
#define DALI_TOOLKIT_BORDER_VISUAL_PROPERTIES_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_visuals
* @{
*/
namespace BorderVisual
{
-
/**
* @brief BorderVisual Property.
* @SINCE_1_1.45
*/
namespace Property
{
-
/**
* @brief Enumeration for the instance of properties belonging to the BorderVisual.
* @SINCE_1_1.45
#define DALI_TOOLKIT_COLOR_VISUAL_PROPERTIES_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_visuals
* @{
*/
namespace ColorVisual
{
-
/**
* @brief ColorVisual Property.
* @SINCE_1_1.45
*/
namespace Property
{
-
/**
* @brief Enumeration for the instance of properties belonging to the ColorVisual.
* @SINCE_1_1.45
#define DALI_TOOLKIT_GRADIENT_VISUAL_PROPERTIES_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_visuals
* @{
*/
namespace GradientVisual
{
-
/**
* @brief GradientVisual Property.
* @SINCE_1_1.45
*/
namespace Property
{
-
/**
* @brief Enumeration for the instance of properties belonging to the GradientVisual.
* @SINCE_1_1.45
*/
namespace Units
{
-
/**
* @brief The type of coordinate system for certain attributes of the points in a gradient.
*
enum Type
{
OBJECT_BOUNDING_BOX, ///< Uses the normals for the start, end & center points, i.e. top-left is (-0.5, -0.5) and bottom-right is (0.5, 0.5). @SINCE_1_1.45
- USER_SPACE ///< Uses the user coordinates for the start, end & center points, i.e. in a 200 by 200 control, top-left is (0, 0) and bottom-right is (200, 200). @SINCE_1_1.45
+ USER_SPACE ///< Uses the user coordinates for the start, end & center points, i.e. in a 200 by 200 control, top-left is (0, 0) and bottom-right is (200, 200). @SINCE_1_1.45
};
} // namespace Units
*/
namespace SpreadMethod
{
-
/**
* @brief Policies that define what happens if the gradient starts or ends inside the bounds of the target rectangle.
* @SINCE_1_1.45
*/
enum Type
{
- PAD, ///< Uses the terminal colors of the gradient to fill the remainder of the quad. @SINCE_1_1.45
+ PAD, ///< Uses the terminal colors of the gradient to fill the remainder of the quad. @SINCE_1_1.45
REFLECT, ///< Reflect the gradient pattern start-to-end, end-to-start, start-to-end etc. until the quad is filled. @SINCE_1_1.45
- REPEAT ///< Repeat the gradient pattern start-to-end, start-to-end, start-to-end etc. until the quad is filled. @SINCE_1_1.45
+ REPEAT ///< Repeat the gradient pattern start-to-end, start-to-end, start-to-end etc. until the quad is filled. @SINCE_1_1.45
};
} // namespace SpreadMethod
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_visuals
* @{
*/
namespace ImageVisual
{
-
/**
* @brief ImageVisual Property.
* @SINCE_1_1.45
*/
namespace Property
{
-
/**
* @brief Enumeration for the instance of properties belonging to the ImageVisual.
* @SINCE_1_1.45
*/
namespace LoadPolicy
{
-
/**
* @brief The available named elements that define the LoadPolicy.
* @SINCE_1_3_5
*/
enum Type
{
- IMMEDIATE = 0, ///< The image is loaded when the ImageVisual is created.
- ATTACHED ///< The image is loaded when the ImageVisual is attached to the stage.
+ IMMEDIATE = 0, ///< The image is loaded when the ImageVisual is created.
+ ATTACHED ///< The image is loaded when the ImageVisual is attached to the stage.
};
} // namespace LoadPolicy
*/
namespace ReleasePolicy
{
-
/**
* @brief The available named elements that define the ReleasePolicy.
* @SINCE_1_3_5
*/
enum Type
{
- DETACHED = 0, ///< Image deleted from cache when ImageVisual detached from stage.
- DESTROYED, ///< Image deleted from cache when ImageVisual destroyed.
- NEVER ///< Image is never deleted, will survive the lifetime of the application.
+ DETACHED = 0, ///< Image deleted from cache when ImageVisual detached from stage.
+ DESTROYED, ///< Image deleted from cache when ImageVisual destroyed.
+ NEVER ///< Image is never deleted, will survive the lifetime of the application.
};
-} // namespace ReleasePolicy;
+} // namespace ReleasePolicy
} // namespace ImageVisual
#define DALI_TOOLKIT_MESH_VISUAL_PROPERTIES_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_visuals
* @{
*/
namespace MeshVisual
{
-
/**
* @brief MeshVisual Property.
* @SINCE_1_1.45
*/
namespace Property
{
-
/**
* @brief Enumeration for the instance of properties belonging to the MeshVisual.
* @SINCE_1_1.45
*/
namespace ShadingMode
{
-
/**
* @brief The shading mode used by MeshVisual.
* @SINCE_1_1.45
*/
enum Value
{
- TEXTURELESS_WITH_DIFFUSE_LIGHTING, ///< *Simplest*. One color that is lit by ambient and diffuse lighting. @SINCE_1_1.45
- TEXTURED_WITH_SPECULAR_LIGHTING, ///< Uses only the visual image textures provided with specular lighting in addition to ambient and diffuse lighting. @SINCE_1_1.45
+ TEXTURELESS_WITH_DIFFUSE_LIGHTING, ///< *Simplest*. One color that is lit by ambient and diffuse lighting. @SINCE_1_1.45
+ TEXTURED_WITH_SPECULAR_LIGHTING, ///< Uses only the visual image textures provided with specular lighting in addition to ambient and diffuse lighting. @SINCE_1_1.45
TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING ///< Uses all textures provided including a gloss, normal and texture map along with specular, ambient and diffuse lighting. @SINCE_1_1.45
};
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_visuals
* @{
*/
namespace PrimitiveVisual
{
-
/**
* @brief PrimitiveVisual Property.
* @SINCE_1_1.45
*/
namespace Property
{
-
/**
* @brief Enumeration for the instance of properties belonging to the PrimitiveVisual.
* @SINCE_1_1.45
*/
namespace Shape
{
-
/**
* @brief The primitive shape to render as a PrimitiveVisual.
* @SINCE_1_1.45
*/
enum Type
{
- SPHERE, ///< A perfectly round geometrical object in three-dimensional space. @SINCE_1_1.45
+ SPHERE, ///< A perfectly round geometrical object in three-dimensional space. @SINCE_1_1.45
CONICAL_FRUSTUM, ///< The area bound between two circles, i.e. a cone with the tip removed. @SINCE_1_3.15
- CONE, ///< Equivalent to a conical frustum with top radius of zero. @SINCE_1_1.45
- CYLINDER, ///< Equivalent to a conical frustum with equal radii for the top and bottom circles. @SINCE_1_1.45
- CUBE, ///< Equivalent to a bevelled cube with a bevel percentage of zero. @SINCE_1_1.45
- OCTAHEDRON, ///< Equivalent to a bevelled cube with a bevel percentage of one. @SINCE_1_1.45
- BEVELLED_CUBE ///< A cube/cuboid with all edges flattened to some degree. @SINCE_1_1.45
+ CONE, ///< Equivalent to a conical frustum with top radius of zero. @SINCE_1_1.45
+ CYLINDER, ///< Equivalent to a conical frustum with equal radii for the top and bottom circles. @SINCE_1_1.45
+ CUBE, ///< Equivalent to a bevelled cube with a bevel percentage of zero. @SINCE_1_1.45
+ OCTAHEDRON, ///< Equivalent to a bevelled cube with a bevel percentage of one. @SINCE_1_1.45
+ BEVELLED_CUBE ///< A cube/cuboid with all edges flattened to some degree. @SINCE_1_1.45
};
-}
+} // namespace Shape
} // namespace PrimitiveVisual
#define DALI_TOOLKIT_TEXT_VISUAL_PROPERTIES_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
/**
*/
namespace TextVisual
{
-
/**
* @brief TextVisual Property.
* @SINCE_1_2.60
*/
namespace Property
{
-
/**
* @brief Enumeration for the instance of properties belonging to the TextVisual.
* @SINCE_1_2.60
#define DALI_TOOLKIT_VISUAL_PROPERTIES_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Toolkit
{
-
/**
* @addtogroup dali_toolkit_visuals
* @{
*/
namespace Visual
{
-
/**
* @brief All the visual types.
* @SINCE_1_1.45
*/
enum Type
{
- BORDER, ///< Renders a solid color as an internal border to the control's quad. @SINCE_1_1.45
- COLOR, ///< Renders a solid color to the control's quad. @SINCE_1_1.45
- GRADIENT, ///< Renders a smooth transition of colors to the control's quad. @SINCE_1_1.45
- IMAGE, ///< Renders an image into the control's quad. @SINCE_1_1.45
- MESH, ///< Renders a mesh using an "obj" file, optionally with textures provided by an "mtl" file. @SINCE_1_1.45
- PRIMITIVE, ///< Renders a simple 3D shape, such as a cube or sphere. @SINCE_1_1.45
- WIREFRAME, ///< Renders a simple wire-frame outlining a quad. @SINCE_1_2_2
- TEXT, ///< Renders text @SINCE_1_2.60
- N_PATCH, ///< Renders an n-patch image. @SINCE_1_2.60
- SVG, ///< Renders an SVG image. @SINCE_1_2.60
- ANIMATED_IMAGE, ///< Renders a animated image. @SINCE_1_2.60
+ BORDER, ///< Renders a solid color as an internal border to the control's quad. @SINCE_1_1.45
+ COLOR, ///< Renders a solid color to the control's quad. @SINCE_1_1.45
+ GRADIENT, ///< Renders a smooth transition of colors to the control's quad. @SINCE_1_1.45
+ IMAGE, ///< Renders an image into the control's quad. @SINCE_1_1.45
+ MESH, ///< Renders a mesh using an "obj" file, optionally with textures provided by an "mtl" file. @SINCE_1_1.45
+ PRIMITIVE, ///< Renders a simple 3D shape, such as a cube or sphere. @SINCE_1_1.45
+ WIREFRAME, ///< Renders a simple wire-frame outlining a quad. @SINCE_1_2_2
+ TEXT, ///< Renders text @SINCE_1_2.60
+ N_PATCH, ///< Renders an n-patch image. @SINCE_1_2.60
+ SVG, ///< Renders an SVG image. @SINCE_1_2.60
+ ANIMATED_IMAGE, ///< Renders a animated image. @SINCE_1_2.60
};
/**
*/
namespace Property
{
-
/**
* @brief Enumeration for the instance of properties belonging to the Visual Property.
* @SINCE_1_1.45
*/
namespace Transform
{
-
/**
* @brief Policies used by the transform for the offset or size.
* @SINCE_1_2.60
*/
namespace Policy
{
-
/**
* @brief Enumeration for the type of Transform Policy.
* @SINCE_1_2.60
*/
enum Type
{
- RELATIVE = 0, ///< Relative to the control (percentage [0.0f to 1.0f] of the control). @SINCE_1_2.60
- ABSOLUTE = 1 ///< Absolute value in world units. @SINCE_1_2.60
+ RELATIVE = 0, ///< Relative to the control (percentage [0.0f to 1.0f] of the control). @SINCE_1_2.60
+ ABSOLUTE = 1 ///< Absolute value in world units. @SINCE_1_2.60
};
} // namespace Policy
*/
namespace Property
{
-
/**
* @brief Enumeration for the type of Transform Property.
* @SINCE_1_2.60
*/
namespace Shader
{
-
/**
* @brief Shader Property.
* @SINCE_1_1.45
*/
namespace Property
{
-
/**
* @brief The type of Shader.
* @SINCE_1_1.45
} // namespace Shader
-
/**
* @brief Status of resource which is used for visual.
* @SINCE_1_3_5
projects / platform / core / uifw / dali-toolkit.git / commitdiff