+ The handle & body classes should have the same name but in different namespaces
+ TypeRegistry relies on this convention
+ Here our custom control requires
- + MyControl
- + Internal::MyControl
+ + MyUIControl
+ + Internal::MyUIControl
### General Guidelines:
+ Try to avoid adding C++ APIs as they become difficult to maintain.
-
+
+To add a visual to a control, first create a Property for the visual of type MAP, and ensure the name has a suffix of "_VISUAL". Then the visual is normally defined in the stylesheet, and the definition sent via SetProperty(), where you would then create the visual:
+
+~~~{.cpp}
+// C++
+void Internal::MyUIControl::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
+{
+ MyUIControl control = MyUIControl::DownCast( Dali::BaseHandle( object ) );
+ switch( index )
+ {
+ case MyUIControl::Property::MY_VISUAL:
+ {
+ Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
+ const Property::Map *map = value.GetMap();
+ if( map && !map->Empty() )
+ {
+ Toolkit::Visual::Base visual = visualFactory.CreateVisual( *map );
+ GetImplementation( control ).RegisterVisual( index, visual );
+ }
+ break;
+ }
+ //...
+ }
+}
+~~~
+
+The [Visuals](@ref visuals) section describes the property maps that can be used for each visual type.
+
___________________________________________________________________________________________________
## Ensuring Control is Stylable {#creating-controls-stylable}
~~~{.cpp}
// C++
-MyUIControl MyUIControlImpl::New()
+MyUIControl Internal::MyUIControl::New()
{
// Create the implementation, temporarily owned on stack
- IntrusivePtr< MyUIControlImpl > controlImpl = new MyUIControlImpl;
+ IntrusivePtr< Internal::MyUIControl > controlImpl = new Internal::MyUIControl;
// Pass ownership to handle
MyUIControl handle( *controlImpl );
This should be overridden by the custom ui control.
~~~{.cpp}
// C++
-void MyUIControlImpl::OnInitialize()
+void Internal::MyUIControl::OnInitialize()
{
// Create visuals using the VisualFactory, register events etc.
// Register any created visuals with Control base class
If the control needs to utilize hover and wheel events, then the correct behaviour flag should be used when constructing the control and then the appropriate method should be overridden.
~~~{.cpp}
// C++
-bool MyUIControlImpl::OnHoverEvent( const HoverEvent& event )
+bool Internal::MyUIControl::OnHoverEvent( const HoverEvent& event )
{
bool consumed = false;
~~~
~~~{.cpp}
// C++
-bool MyUIControlImpl::OnWheelEvent( const WheelEvent& event )
+bool Internal::MyUIControl::OnWheelEvent( const WheelEvent& event )
{
bool consumed = false;
~~~{.cpp}
// C++
-void MyUIControlImpl::OnInitialize()
+void Internal::MyUIControl::OnInitialize()
{
// Only enable pan gesture detection
EnableGestureDetection( Gesture::Pan );
Finally, the appropriate method should be overridden:
~~~{.cpp}
// C++
-void MyUIControlImpl::OnPan( const PanGesture& pan )
+void Internal::MyUIControl::OnPan( const PanGesture& pan )
{
// Handle pan-gesture
}
~~~
~~~{.cpp}
// C++
-void MyUIControlImpl::OnPinch( const PinchGesture& pinch )
+void Internal::MyUIControl::OnPinch( const PinchGesture& pinch )
{
// Handle pinch-event
}
~~~
~~~{.cpp}
// C++
-void MyUIControlImpl::OnTap( const TapGesture& tap )
+void Internal::MyUIControl::OnTap( const TapGesture& tap )
{
// Handle tap-gesture
}
~~~
~~~{.cpp}
// C++
-void MyUIControlImpl::OnLongPress( const LongPressGesture& longPress )
+void Internal::MyUIControl::OnLongPress( const LongPressGesture& longPress )
{
// Handle long-press-gesture
}
~~~{.cpp}
// C++
-void MyUIControlImpl::OnChildAdd( Actor& child );
+void Internal::MyUIControl::OnChildAdd( Actor& child );
{
// Do any other operations required upon child addition
~~~
~~~{.cpp}
// C++
-void MyUIControlImpl::OnChildRemove( Actor& child );
+void Internal::MyUIControl::OnChildRemove( Actor& child );
{
// Do any other operations required upon child removal
~~~{.cpp}
// C++
-void MyUIControlImpl::OnStageConnection( int depth )
+void Internal::MyUIControl::OnStageConnection( int depth )
{
// Do any other operations required upon stage connection
~~~
~~~{.cpp}
// C++
-void MyUIControlImpl::OnStageDisconnection()
+void Internal::MyUIControl::OnStageDisconnection()
{
// Do any other operations required upon stage disconnection
~~~{.cpp}
// C++
-Vector3 MyUIControlImpl::GetNaturalSize()
+Vector3 Internal::MyUIControl::GetNaturalSize()
{
// Return the natural size of the control
// This depends on our layout
~~~
~~~{.cpp}
// C++
-float MyUIControlImpl::GetHeightForWidth( float width )
+float Internal::MyUIControl::GetHeightForWidth( float width )
{
// Called by the size negotiation algorithm if we have a fixed width
// We should calculate the height we would like our control to be for that width
~~~
~~~{.cpp}
// C++
-float MyUIControlImpl::GetWidthForHeight( float height )
+float Internal::MyUIControl::GetWidthForHeight( float height )
{
// Called by the size negotiation algorithm if we have a fixed height
// We should calculate the width we would like our control to be for that height
~~~
~~~{.cpp}
// C++
-void MyUIControlImpl::OnRelayout( const Vector2& size, RelayoutContainer& container )
+void Internal::MyUIControl::OnRelayout( const Vector2& size, RelayoutContainer& container )
{
// The size is what we have been given and what our control needs to fit into
// Here, we need to set the position and the size of our visuals
### Clipping Support {#creating-controls-clipping}
When an Actor is set to clip its children, the renderers have to be added manually in order to specify what its children need to clip to.
-The Control base class automates the creation of the renderers/visuals when it is set to clip its children.
+The Control base class automates the creation of the visuals when it is set to clip its children.
-This is only done if the application or custom control writer has not added any renderers to the Control or registered any visuals
+This is only done if the application or custom control writer has not
+added any Renderers to the Control or registered any visuals
(regardless of whether these visuals are enabled or not).
If custom control writers want to define the clipping visuals themselves, then they should register all required visuals before the control is staged.
projects / platform / core / uifw / dali-toolkit.git / commitdiff