--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/devel-api/adaptor-framework/canvas-renderer-gradient.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/canvas-renderer/common/canvas-renderer-impl.h>
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+
+namespace Dali
+{
+// CanvasRenderer::Gradient
+//
+CanvasRenderer::Gradient::Gradient()
+{
+}
+
+CanvasRenderer::Gradient::~Gradient()
+{
+}
+
+CanvasRenderer::Gradient::Gradient(Internal::Adaptor::Gradient* pImpl)
+: BaseHandle(pImpl)
+{
+}
+
+bool CanvasRenderer::Gradient::SetColorStops(Dali::CanvasRenderer::Gradient::ColorStops& colorStops)
+{
+ return GetImplementation(*this).SetColorStops(colorStops);
+}
+
+Dali::CanvasRenderer::Gradient::ColorStops CanvasRenderer::Gradient::GetColorStops() const
+{
+ return GetImplementation(*this).GetColorStops();
+}
+
+bool CanvasRenderer::Gradient::SetSpread(Dali::CanvasRenderer::Gradient::Spread spread)
+{
+ return GetImplementation(*this).SetSpread(spread);
+}
+
+Dali::CanvasRenderer::Gradient::Spread CanvasRenderer::Gradient::GetSpread() const
+{
+ return GetImplementation(*this).GetSpread();
+}
+
+CanvasRenderer::Gradient CanvasRenderer::Gradient::DownCast(BaseHandle handle)
+{
+ return CanvasRenderer::Gradient(dynamic_cast<Internal::Adaptor::Gradient*>(handle.GetObjectPtr()));
+}
+} // namespace Dali
--- /dev/null
+#ifndef DALI_CANVAS_RENDERER_GRADIENT_H
+#define DALI_CANVAS_RENDERER_GRADIENT_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-handle.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer.h>
+#include <dali/public-api/dali-adaptor-common.h>
+
+namespace Dali
+{
+/**
+ * @addtogroup dali_adaptor_framework
+ * @{
+ */
+
+namespace Internal DALI_INTERNAL
+{
+namespace Adaptor
+{
+class CanvasRenderer;
+class Gradient;
+} // namespace Adaptor
+} // namespace DALI_INTERNAL
+
+/**
+ * @brief An abstract class representing the gradient fill of the Shape object.
+ *
+ * It contains the information about the gradient colors and their arrangement
+ * inside the gradient bounds. The gradients bounds are defined in the LinearGradient
+ * or RadialGradient class, depending on the type of the gradient to be used.
+ * It specifies the gradient behavior in case the area defined by the gradient bounds
+ * is smaller than the area to be filled.
+ */
+class DALI_ADAPTOR_API CanvasRenderer::Gradient : public BaseHandle
+{
+public:
+ /**
+ * @brief Constructor
+ */
+ Gradient();
+
+ /**
+ * @brief Destructor.
+ */
+ ~Gradient();
+
+ /**
+ * @brief This copy constructor is required for (smart) pointer semantics.
+ *
+ * @param[in] handle A reference to the copied handle
+ */
+ Gradient(const Gradient& handle) = default;
+
+public:
+ /**
+ * @brief Enumeration specifying how to fill the area outside the gradient bounds.
+ */
+ enum class Spread
+ {
+ PAD = 0, ///< The remaining area is filled with the closest stop color.
+ REFLECT, ///< The gradient pattern is reflected outside the gradient area until the expected region is filled.
+ REPEAT ///< The gradient pattern is repeated continuously beyond the gradient area until the expected region is filled.
+ };
+
+ /**
+ * @brief A data structure storing the information about the color and its relative position inside the gradient bounds.
+ */
+ struct ColorStop
+ {
+ float offset; /**< The relative position of the color. */
+ Vector4 color; /**< The color value. */
+ };
+
+ /// @brief List of Colorstop.
+ using ColorStops = Dali::Vector<ColorStop>;
+
+public:
+ /**
+ * @brief Sets the parameters of the colors of the gradient and their position.
+ * @param[in] colorStops An array of ColorStop data structure.
+ * @return Result::Success when succeed.
+ */
+ bool SetColorStops(ColorStops& colorStops);
+
+ /**
+ * @brief Gets the parameters of the colors of the gradient, their position and number.
+ * @return Returns the colorstops list.
+ */
+ ColorStops GetColorStops() const;
+
+ /**
+ * @brief Set the spread.
+ * @param[in] spread The current spraed type of the shape.
+ * @return Returns True when it's successful. False otherwise.
+ */
+ bool SetSpread(Spread spread);
+
+ /**
+ * @brief Get the spread type
+ * @return Returns the current spread type of the shape.
+ */
+ Spread GetSpread() const;
+
+ /**
+ * @brief Downcast a handle to Gradient handle.
+ *
+ * If handle points to an InputMethodContext the downcast produces valid
+ * handle. If not the returned handle is left uninitialized.
+ *
+ * @param[in] handle Handle to an object.
+ * @return Handle to an Gradient or an uninitialized handle.
+ */
+ static Gradient DownCast(BaseHandle handle);
+
+public: // Not intended for application developers
+ /// @cond internal
+ /**
+ * @brief The constructor.
+ * @note Not intended for application developers.
+ *
+ * @param[in] pointer A pointer to a newly allocated CanvasRenderer::Gradient
+ */
+ explicit DALI_INTERNAL Gradient(Internal::Adaptor::Gradient* pImpl);
+ /// @endcond
+};
+
+/**
+ * @}
+ */
+} // namespace Dali
+
+#endif // DALI_CANVAS_RENDERER_GRADIENT_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/devel-api/adaptor-framework/canvas-renderer-linear-gradient.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/canvas-renderer/common/linear-gradient-factory.h>
+#include <dali/internal/canvas-renderer/common/linear-gradient-impl.h>
+
+namespace Dali
+{
+CanvasRenderer::LinearGradient CanvasRenderer::LinearGradient::New()
+{
+ return LinearGradient(Internal::Adaptor::LinearGradientFactory::New());
+}
+
+CanvasRenderer::LinearGradient::LinearGradient()
+{
+}
+
+CanvasRenderer::LinearGradient::~LinearGradient()
+{
+}
+
+CanvasRenderer::LinearGradient::LinearGradient(Internal::Adaptor::LinearGradient* impl)
+: CanvasRenderer::Gradient(impl)
+{
+}
+
+bool CanvasRenderer::LinearGradient::SetBounds(Vector2 firstPoint, Vector2 secondPoint)
+{
+ return GetImplementation(*this).SetBounds(firstPoint, secondPoint);
+}
+
+bool CanvasRenderer::LinearGradient::GetBounds(Vector2& firstPoint, Vector2& secondPoint) const
+{
+ return GetImplementation(*this).GetBounds(firstPoint, secondPoint);
+}
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_CANVAS_RENDERER_LINEAR_GRADIENT_H
+#define DALI_CANVAS_RENDERER_LINEAR_GRADIENT_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-handle.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-gradient.h>
+#include <dali/devel-api/adaptor-framework/canvas-renderer.h>
+#include <dali/public-api/dali-adaptor-common.h>
+
+namespace Dali
+{
+/**
+ * @addtogroup dali_adaptor_framework
+ * @{
+ */
+
+namespace Internal DALI_INTERNAL
+{
+namespace Adaptor
+{
+class CanvasRenderer;
+class LinearGradient;
+} // namespace Adaptor
+} // namespace DALI_INTERNAL
+
+/**
+ * @brief A class representing the linear gradient fill of the Shape object.
+ *
+ * Besides the class inherited from the Gradient class, it enables setting and getting the linear gradient bounds.
+ * The behavior outside the gradient bounds depends on the value specified in the spread API.
+ */
+class DALI_ADAPTOR_API CanvasRenderer::LinearGradient : public CanvasRenderer::Gradient
+{
+public:
+ /**
+ * @brief Creates an initialized handle to a new CanvasRenderer::LinearGradient.
+ * @return A handle to a newly allocated LinearGradient
+ */
+ static LinearGradient New();
+
+public:
+ /**
+ * @brief Creates an empty handle. Use CanvasRenderer::LinearGradient::New() to create an initialized object.
+ */
+ LinearGradient();
+
+ /**
+ * @brief Destructor.
+ */
+ ~LinearGradient();
+
+ /**
+ * @brief This copy constructor is required for (smart) pointer semantics.
+ *
+ * @param[in] handle A reference to the copied handle
+ */
+ LinearGradient(const LinearGradient& handle) = default;
+
+public:
+ /**
+ * @brief Sets the linear gradient bounds.
+ * The bounds of the linear gradient are defined as a surface constrained by two parallel lines crossing
+ * the given points (@p x1, @p y1) and (@p x2, @p y2), respectively. Both lines are perpendicular to the line linking
+ * (@p x1, @p y1) and (@p x2, @p y2).
+ * @param[in] firstPoint The first point used to determine the gradient bounds.
+ * @param[in] secondPoint The second point used to determine the gradient bounds.
+ * @return Returns True when it's successful. False otherwise.
+ */
+ bool SetBounds(Vector2 firstPoint, Vector2 secondPoint);
+
+ /**
+ * @brief Gets the linear gradient bounds.
+ * @param[out] firstPoint The first point used to determine the gradient bounds.
+ * @param[out] secondPoint The second point used to determine the gradient bounds.
+ * @return Returns True when it's successful. False otherwise.
+ */
+ bool GetBounds(Vector2& firstPoint, Vector2& secondPoint) const;
+
+public: // Not intended for application developers
+ /// @cond internal
+ /**
+ * @brief The constructor.
+ * @note Not intended for application developers.
+ *
+ * @param[in] pointer A pointer to a newly allocated CanvasRenderer::LinearGradient
+ */
+ explicit DALI_INTERNAL LinearGradient(Internal::Adaptor::LinearGradient* impl);
+ /// @endcond
+};
+
+/**
+ * @}
+ */
+} // namespace Dali
+
+#endif // DALI_CANVAS_RENDERER_LINEAR_GRADIENT_H
--- /dev/null
+/*
+* Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/devel-api/adaptor-framework/canvas-renderer-picture.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/canvas-renderer/common/canvas-renderer-impl.h>
+#include <dali/internal/canvas-renderer/common/picture-factory.h>
+#include <dali/internal/canvas-renderer/common/picture-impl.h>
+
+namespace Dali
+{
+CanvasRenderer::Picture CanvasRenderer::Picture::New()
+{
+ return Picture(Internal::Adaptor::PictureFactory::New());
+}
+
+CanvasRenderer::Picture::Picture()
+{
+}
+
+CanvasRenderer::Picture::~Picture()
+{
+}
+
+CanvasRenderer::Picture::Picture(Internal::Adaptor::Picture* impl)
+: CanvasRenderer::Drawable(impl)
+{
+}
+
+bool CanvasRenderer::Picture::Load(const std::string& url)
+{
+ return GetImplementation(*this).Load(url);
+}
+
+bool CanvasRenderer::Picture::SetSize(Vector2 size)
+{
+ return GetImplementation(*this).SetSize(size);
+}
+
+Vector2 CanvasRenderer::Picture::GetSize() const
+{
+ return GetImplementation(*this).GetSize();
+}
+} // namespace Dali
--- /dev/null
+#ifndef DALI_CANVAS_RENDERER_PICTURE_H
+#define DALI_CANVAS_RENDERER_PICTURE_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-handle.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-drawable.h>
+#include <dali/devel-api/adaptor-framework/canvas-renderer.h>
+#include <dali/public-api/dali-adaptor-common.h>
+
+namespace Dali
+{
+/**
+ * @addtogroup dali_adaptor_framework
+ * @{
+ */
+
+namespace Internal DALI_INTERNAL
+{
+namespace Adaptor
+{
+class CanvasRenderer;
+class Picture;
+} // namespace Adaptor
+} // namespace DALI_INTERNAL
+
+/**
+ * @brief A class representing an image read in one of the supported formats: raw, svg, png and etc.
+ * Besides the methods inherited from the Drawable, it provides methods to load & draw images on the canvas.
+ */
+class DALI_ADAPTOR_API CanvasRenderer::Picture : public CanvasRenderer::Drawable
+{
+public:
+ /**
+ * @brief Creates an initialized handle to a new CanvasRenderer::Picture.
+ *
+ * @return A handle to a newly allocated Picture
+ */
+ static Picture New();
+
+public:
+ /**
+ * @brief Creates an empty handle.
+ * Use CanvasRenderer::Picture::New() to create an initialized object.
+ */
+ Picture();
+
+ /**
+ * @brief Destructor.
+ */
+ ~Picture();
+
+ /**
+ * @brief This copy constructor is required for (smart) pointer semantics.
+ *
+ * @param[in] handle A reference to the copied handle
+ */
+ Picture(const Picture& handle) = default;
+
+public:
+ /**
+ * @brief Loads a picture data directly from a file.
+ * @param[in] url A path to the picture file.
+ * @return Returns True when it's successful. False otherwise.
+ */
+ bool Load(const std::string& url);
+
+ /**
+ * @brief Resize the picture content with the given size.
+ *
+ * Resize the picture content while keeping the default size aspect ratio.
+ * The scaling factor is established for each of dimensions and the smaller value is applied to both of them.
+ * @param[in] size A new size of the image in pixels.
+ * @return Returns True when it's successful. False otherwise.
+ */
+ bool SetSize(Vector2 size);
+
+ /**
+ * @brief Gets the size of the image.
+ * @return Returns The size of the image in pixels.
+ */
+ Vector2 GetSize() const;
+
+public: // Not intended for application developers
+ /// @cond internal
+ /**
+ * @brief The constructor.
+ * @note Not intended for application developers.
+ *
+ * @param[in] pointer A pointer to a newly allocated CanvasRenderer::Picture
+ */
+ explicit DALI_INTERNAL Picture(Internal::Adaptor::Picture* impl);
+ /// @endcond
+};
+
+/**
+ * @}
+ */
+} // namespace Dali
+
+#endif // DALI_CANVAS_RENDERER_PICTURE_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/devel-api/adaptor-framework/canvas-renderer-radial-gradient.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/canvas-renderer/common/radial-gradient-factory.h>
+#include <dali/internal/canvas-renderer/common/radial-gradient-impl.h>
+
+namespace Dali
+{
+CanvasRenderer::RadialGradient CanvasRenderer::RadialGradient::New()
+{
+ return RadialGradient(Internal::Adaptor::RadialGradientFactory::New());
+}
+
+CanvasRenderer::RadialGradient::RadialGradient()
+{
+}
+
+CanvasRenderer::RadialGradient::~RadialGradient()
+{
+}
+
+CanvasRenderer::RadialGradient::RadialGradient(Internal::Adaptor::RadialGradient* impl)
+: CanvasRenderer::Gradient(impl)
+{
+}
+
+bool CanvasRenderer::RadialGradient::SetBounds(Vector2 centerPoint, float radius)
+{
+ return GetImplementation(*this).SetBounds(centerPoint, radius);
+}
+
+bool CanvasRenderer::RadialGradient::GetBounds(Vector2& centerPoint, float& radius) const
+{
+ return GetImplementation(*this).GetBounds(centerPoint, radius);
+}
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_CANVAS_RENDERER_RADIAL_GRADIENT_H
+#define DALI_CANVAS_RENDERER_RADIAL_GRADIENT_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-handle.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-gradient.h>
+#include <dali/devel-api/adaptor-framework/canvas-renderer.h>
+#include <dali/public-api/dali-adaptor-common.h>
+
+namespace Dali
+{
+/**
+ * @addtogroup dali_adaptor_framework
+ * @{
+ */
+
+namespace Internal DALI_INTERNAL
+{
+namespace Adaptor
+{
+class CanvasRenderer;
+class RadialGradient;
+} // namespace Adaptor
+} // namespace DALI_INTERNAL
+
+/**
+ * @brief A class representing the radial gradient fill of the Shape object.
+ */
+class DALI_ADAPTOR_API CanvasRenderer::RadialGradient : public CanvasRenderer::Gradient
+{
+public:
+ /**
+ * @brief Creates an initialized handle to a new CanvasRenderer::RadialGradient.
+ * @return A handle to a newly allocated RadialGradient
+ */
+ static RadialGradient New();
+
+public:
+ /**
+ * @brief Creates an empty handle. Use CanvasRenderer::RadialGradient::New() to create an initialized object.
+ */
+ RadialGradient();
+
+ /**
+ * @brief Destructor.
+ */
+ ~RadialGradient();
+
+ /**
+ * @brief This copy constructor is required for (smart) pointer semantics.
+ *
+ * @param[in] handle A reference to the copied handle
+ */
+ RadialGradient(const RadialGradient& handle) = default;
+
+public:
+ /**
+ * @brief Sets the radial gradient bounds.
+ * The radial gradient bounds are defined as a circle centered in a given point of a given radius.
+ * @param[in] centerPoint The point of the center of the bounding circle.
+ * @param[in] radius The radius of the bounding circle.
+ * @return Returns True when it's successful. False otherwise.
+ */
+ bool SetBounds(Vector2 centerPoint, float radius);
+
+ /**
+ * @brief Gets the radial gradient bounds.
+ * @param[out] centerPoint The point used to determine the gradient bounds.
+ * @param[out] radius The radius of the bounding circle.
+ * @return Returns True when it's successful. False otherwise.
+ */
+ bool GetBounds(Vector2& centerPoint, float& radius) const;
+
+public: // Not intended for application developers
+ /// @cond internal
+ /**
+ * @brief The constructor.
+ * @note Not intended for application developers.
+ *
+ * @param[in] pointer A pointer to a newly allocated CanvasRenderer::RadialGradient
+ */
+ explicit DALI_INTERNAL RadialGradient(Internal::Adaptor::RadialGradient* impl);
+ /// @endcond
+};
+
+/**
+ * @}
+ */
+} // namespace Dali
+
+#endif // DALI_CANVAS_RENDERER_RADIAL_GRADIENT_H
return GetImplementation(*this).AddCubicTo(controlPoint1, controlPoint2, endPoint);
}
+bool CanvasRenderer::Shape::AddPath(PathCommands& pathCommand)
+{
+ return GetImplementation(*this).AddPath(pathCommand);
+}
+
bool CanvasRenderer::Shape::Close()
{
return GetImplementation(*this).Close();
return GetImplementation(*this).GetFillColor();
}
+bool CanvasRenderer::Shape::SetFillGradient(CanvasRenderer::Gradient& gradient)
+{
+ return GetImplementation(*this).SetFillGradient(gradient);
+}
+
+CanvasRenderer::Gradient CanvasRenderer::Shape::GetFillGradient() const
+{
+ return GetImplementation(*this).GetFillGradient();
+}
+
bool CanvasRenderer::Shape::SetFillRule(CanvasRenderer::Shape::FillRule rule)
{
return GetImplementation(*this).SetFillRule(rule);
return GetImplementation(*this).GetStrokeColor();
}
+bool CanvasRenderer::Shape::SetStrokeGradient(CanvasRenderer::Gradient& gradient)
+{
+ return GetImplementation(*this).SetStrokeGradient(gradient);
+}
+
+CanvasRenderer::Gradient CanvasRenderer::Shape::GetStrokeGradient() const
+{
+ return GetImplementation(*this).GetStrokeGradient();
+}
+
bool CanvasRenderer::Shape::SetStrokeDash(const Dali::Vector<float>& dashPattern)
{
return GetImplementation(*this).SetStrokeDash(dashPattern);
EVEN_ODD ///< Draw a horizontal line from the point to a location outside the shape, and count the number of intersections. If the number of intersections is an odd number, the point is inside the shape.
};
+ /**
+ * @brief Enumeration specifying the values of the path commands.
+ * Not to be confused with the path commands from the svg path element (like M, L, Q, H and many others).
+ */
+ enum class PathCommandType
+ {
+ CLOSE = 0, ///< Ends the current sub-path and connects it with its initial point. This command doesn't expect any points.
+ MOVE_TO, ///< Sets a new initial point of the sub-path and a new current point. This command expects 1 point: the starting position.
+ LINE_TO, ///< Draws a line from the current point to the given point and sets a new value of the current point. This command expects 1 point: the end-position of the line.
+ CUBIC_TO ///< Draws a cubic Bezier curve from the current point to the given point using two given control points and sets a new value of the current point. This command expects 3 points: the 1st control-point, the 2nd control-point, the end-point of the curve.
+ };
+
+ /**
+ * @brief Structure that contains information about a list of path commands.
+ * For each command from the mCommands array, an appropriate number of points in mPoints array should be specified.
+ */
+ struct PathCommands
+ {
+ PathCommandType* mCommands; ///< Set of each PathComand.
+ uint32_t mCommandCount; ///< The number of command array.
+ float* mPoints; ///< Set of each Point
+ uint32_t mPointCount; ///< The number of point array.
+ };
+
public:
/**
* @brief Append the given rectangle with rounded corner to the path.
bool AddCubicTo(Vector2 controlPoint1, Vector2 controlPoint2, Vector2 endPoint);
/**
+ * @brief Appends a given sub-path to the path.
+ * The current point value is set to the last point from the sub-path.
+ * @param[in] pathCommand The command object that contain sub-path information. (This command information is copied internally.)
+ * @return Returns True when it's successful. False otherwise.
+ * @note The interface is designed for optimal path setting if the caller has a completed path commands already.
+ *
+ */
+ bool AddPath(PathCommands& pathCommand);
+
+ /**
* @brief Closes the current subpath by drawing a line to the beginning of the
* subpath, automatically starting a new path. The current point of the
* new path is (0, 0).
Vector4 GetFillColor() const;
/**
+ * @brief Set the gradient to use for filling the path.
+ * @param[in] gradient The gradient object.
+ * @return Returns True when it's successful. False otherwise.
+ */
+ bool SetFillGradient(CanvasRenderer::Gradient& gradient);
+
+ /**
+ * @brief Get the gradient to use for filling the path.
+ * @return Returns The gradient object.
+ */
+ CanvasRenderer::Gradient GetFillGradient() const;
+
+ /**
* @brief Set the fill rule.
* @param[in] rule The current fill rule of the shape.
* @return Returns True when it's successful. False otherwise.
Vector4 GetStrokeColor() const;
/**
+ * @brief Set the gradient to use for stroking the path.
+ * @param[in] gradient The gradient object.
+ * @return Returns True when it's successful. False otherwise.
+ */
+ bool SetStrokeGradient(CanvasRenderer::Gradient& gradient);
+
+ /**
+ * @brief Get the gradient to use for stroking the path.
+ * @return Returns The gradient object.
+ */
+ CanvasRenderer::Gradient GetStrokeGradient() const;
+
+ /**
* @brief Sets the stroke dash pattern. The dash pattern is specified dash pattern.
* @param[in] dashPattern Lenght and a gap list.
* @return Returns True when it's successful. False otherwise.
return GetImplementation(*this).RemoveAllDrawables();
}
-bool CanvasRenderer::SetSize(const Vector2& size)
+bool CanvasRenderer::SetSize(Vector2 size)
{
return GetImplementation(*this).SetSize(size);
}
-const Vector2& CanvasRenderer::GetSize()
+Vector2 CanvasRenderer::GetSize() const
{
return GetImplementation(*this).GetSize();
}
class Drawable;
class Shape;
class DrawableGroup;
+ class Picture;
+
+ class Gradient;
+ class LinearGradient;
+ class RadialGradient;
public:
/**
* @param[in] size The size of canvas buffer.
* @return Returns True when it's successful. False otherwise.
*/
- bool SetSize(const Vector2& size);
+ bool SetSize(Vector2 size);
/**
* @brief This is the size of the Buffer in the Canvas.
* @return Returns The size of canvas buffer.
*/
- const Vector2& GetSize();
+ Vector2 GetSize() const;
/**
* @brief This is the viewbox of the Canvas.
${adaptor_devel_api_dir}/adaptor-framework/bitmap-saver.cpp
${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer.cpp
${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-drawable.cpp
- ${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-shape.cpp
+ ${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-picture.cpp
${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-drawable-group.cpp
+ ${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-shape.cpp
+ ${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-gradient.cpp
+ ${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-linear-gradient.cpp
+ ${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-radial-gradient.cpp
${adaptor_devel_api_dir}/adaptor-framework/capture-devel.cpp
${adaptor_devel_api_dir}/adaptor-framework/clipboard.cpp
${adaptor_devel_api_dir}/adaptor-framework/clipboard-event-notifier.cpp
${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-drawable.h
${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-shape.h
${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-drawable-group.h
+ ${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-gradient.h
+ ${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-linear-gradient.h
+ ${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-radial-gradient.h
+ ${adaptor_devel_api_dir}/adaptor-framework/canvas-renderer-picture.h
${adaptor_devel_api_dir}/adaptor-framework/capture-devel.h
${adaptor_devel_api_dir}/adaptor-framework/clipboard-event-notifier.h
${adaptor_devel_api_dir}/adaptor-framework/clipboard.h
return mImpl->AddIdle(timeout, data, callback);
}
- return -1;
+ return 0;
}
void Framework::RemoveIdle(unsigned int id)
{
if(javaVM == nullptr || javaVM->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK)
{
DALI_LOG_ERROR("Couldn't get JNI env.");
- return -1;
+ return 0;
}
jclass clazz = env->FindClass("com/sec/daliview/DaliView");
if(!clazz)
{
DALI_LOG_ERROR("Couldn't find com.sec.daliview.DaliView.");
- return -1;
+ return 0;
}
jmethodID addIdle = env->GetStaticMethodID(clazz, "addIdle", "(JJJ)I");
if(!addIdle)
{
DALI_LOG_ERROR("Couldn't find com.sec.daliview.DaliView.addIdle.");
- return -1;
+ return 0;
}
jint id = env->CallStaticIntMethod(clazz, addIdle, reinterpret_cast<jlong>(callback), reinterpret_cast<jlong>(data), static_cast<jlong>(timeout));
return false;
}
-bool CanvasRenderer::SetSize(const Vector2& size)
+bool CanvasRenderer::SetSize(Vector2 size)
{
return false;
}
-const Vector2& CanvasRenderer::GetSize()
+Vector2 CanvasRenderer::GetSize() const
{
return Vector2::ZERO;
}
/**
* @copydoc Dali::CanvasRenderer::SetSize()
*/
- virtual bool SetSize(const Vector2& size);
+ virtual bool SetSize(Vector2 size);
/**
* @copydoc Dali::CanvasRenderer::GetSize()
*/
- virtual const Vector2& GetSize();
+ virtual Vector2 GetSize() const;
/**
* @copydoc Dali::CanvasRenderer::SetViewBox()
*/
enum class Types
{
- NONE = 0, ///< Means that type is not defined.
- SHAPE, ///< Meaning of Shape class that inherits Drawable.
- DRAWABLE_GROUP ///< Meaning of DrawableGorup class that inherits Drawable.
+ NONE = 0, ///< Means that type is not defined.
+ SHAPE, ///< Meaning of Shape class that inherits Drawable.
+ DRAWABLE_GROUP, ///< Meaning of DrawableGorup class that inherits Drawable.
+ PICTURE ///< Meaning of Picture class that inherits Drawable.
};
/**
--- /dev/null
+#ifndef DALI_INTERNAL_GRADIENT_FACTORY_H
+#define DALI_INTERNAL_GRADIENT_FACTORY_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-gradient.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace GradientFactory
+{
+/**
+ * @brief Creates new instance of Gradient implementation
+ * @return pointer to Gradient implementation instance
+ */
+Dali::Internal::Adaptor::Gradient* New();
+
+} // namespace GradientFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_GRADIENT_FACTORY_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/common/gradient-factory.h>
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+Gradient::Gradient() = default;
+
+Gradient::~Gradient()
+{
+ if(mImpl)
+ {
+ delete mImpl;
+ }
+}
+
+void Gradient::Create()
+{
+ if(!mImpl)
+ {
+ mImpl = Internal::Adaptor::GradientFactory::New();
+ }
+}
+
+bool Gradient::SetColorStops(Dali::CanvasRenderer::Gradient::ColorStops& colorStops)
+{
+ if(!mImpl)
+ {
+ return false;
+ }
+ return mImpl->SetColorStops(colorStops);
+}
+
+Dali::CanvasRenderer::Gradient::ColorStops Gradient::GetColorStops() const
+{
+ if(!mImpl)
+ {
+ return Dali::CanvasRenderer::Gradient::ColorStops();
+ }
+ return mImpl->GetColorStops();
+}
+
+bool Gradient::SetSpread(Dali::CanvasRenderer::Gradient::Spread spread)
+{
+ if(!mImpl)
+ {
+ return false;
+ }
+ return mImpl->SetSpread(spread);
+}
+
+Dali::CanvasRenderer::Gradient::Spread Gradient::GetSpread() const
+{
+ if(!mImpl)
+ {
+ return Dali::CanvasRenderer::Gradient::Spread::PAD;
+ }
+ return mImpl->GetSpread();
+}
+
+void* Gradient::GetObject() const
+{
+ if(!mImpl)
+ {
+ return nullptr;
+ }
+ return mImpl->GetObject();
+}
+
+void Gradient::SetObject(const void* object)
+{
+ if(!mImpl)
+ {
+ return;
+ }
+ mImpl->SetObject(object);
+}
+
+void Gradient::SetChanged(bool changed)
+{
+ if(!mImpl)
+ {
+ return;
+ }
+ mImpl->SetChanged(changed);
+}
+
+bool Gradient::GetChanged() const
+{
+ if(!mImpl)
+ {
+ return false;
+ }
+ return mImpl->GetChanged();
+}
+
+Dali::Internal::Adaptor::Gradient* Gradient::GetImplementation()
+{
+ return mImpl;
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_GRADIENT_IMPL_H
+#define DALI_INTERNAL_GRADIENT_IMPL_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-gradient.h>
+#include <dali/devel-api/adaptor-framework/canvas-renderer.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal Gradient.
+ */
+class Gradient : public Dali::BaseObject
+{
+public:
+ /**
+ * @brief Constructor
+ */
+ Gradient();
+
+ /**
+ * @brief Destructor.
+ */
+ virtual ~Gradient() override;
+
+ /**
+ * @brief Create factory item(implementation) object.
+ */
+ void Create();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::SetColorStops()
+ */
+ virtual bool SetColorStops(Dali::CanvasRenderer::Gradient::ColorStops& colorStops);
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::GetColorStops()
+ */
+ virtual Dali::CanvasRenderer::Gradient::ColorStops GetColorStops() const;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::SetSpread()
+ */
+ virtual bool SetSpread(Dali::CanvasRenderer::Gradient::Spread spread);
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::GetSpread()
+ */
+ virtual Dali::CanvasRenderer::Gradient::Spread GetSpread() const;
+
+ /**
+ * @brief Set a gradient object
+ * @param[in] object gradient object
+ */
+ virtual void SetObject(const void* object);
+
+ /**
+ * @brief Returns a gradient object pointer.
+ * @return Returns a gradient object pointer.
+ */
+ virtual void* GetObject() const;
+
+ /**
+ * @brief Set a changed state.
+ * @param[in] changed The state of changed.
+ */
+ virtual void SetChanged(bool changed);
+
+ /**
+ * @brief Get a changed state.
+ * @return Returns state of changed.
+ */
+ virtual bool GetChanged() const;
+
+ /**
+ * @brief Returns a gradient's implements object pointer.
+ * @return Returns a gradient's implements object pointer.
+ */
+ Dali::Internal::Adaptor::Gradient* GetImplementation();
+
+ Gradient(const Gradient&) = delete;
+ Gradient& operator=(Gradient&) = delete;
+ Gradient(Gradient&&) = delete;
+ Gradient& operator=(Gradient&&) = delete;
+
+private:
+ Dali::Internal::Adaptor::Gradient* mImpl = nullptr;
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+inline static Internal::Adaptor::Gradient& GetImplementation(Dali::CanvasRenderer::Gradient& gradient)
+{
+ DALI_ASSERT_ALWAYS(gradient && "Gradient handle is empty.");
+
+ BaseObject& handle = gradient.GetBaseObject();
+
+ return static_cast<Internal::Adaptor::Gradient&>(handle);
+}
+
+inline static const Internal::Adaptor::Gradient& GetImplementation(const Dali::CanvasRenderer::Gradient& gradient)
+{
+ DALI_ASSERT_ALWAYS(gradient && "Gradient handle is empty.");
+
+ const BaseObject& handle = gradient.GetBaseObject();
+
+ return static_cast<const Internal::Adaptor::Gradient&>(handle);
+}
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_GRADIENT_IMPL_H
--- /dev/null
+#ifndef DALI_INTERNAL_LINEAR_GRADIENT_FACTORY_H
+#define DALI_INTERNAL_LINEAR_GRADIENT_FACTORY_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-linear-gradient.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace LinearGradientFactory
+{
+/**
+ * @brief Creates new instance of LinearGradient implementation
+ * @return pointer to LinearGradient implementation instance
+ */
+Dali::Internal::Adaptor::LinearGradient* New();
+
+} // namespace LinearGradientFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_LINEAR_GRADIENT_FACTORY_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/common/linear-gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+LinearGradient::LinearGradient() = default;
+
+LinearGradient::~LinearGradient() = default;
+
+bool LinearGradient::SetBounds(Vector2 firstPoint, Vector2 SecondPoint)
+{
+ return false;
+}
+
+bool LinearGradient::GetBounds(Vector2& firstPoint, Vector2& SecondPoint) const
+{
+ return false;
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_LINEAR_GRADIENT_IMPL_H
+#define DALI_INTERNAL_LINEAR_GRADIENT_IMPL_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-linear-gradient.h>
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal LinearGradient.
+ */
+class LinearGradient : public Internal::Adaptor::Gradient
+{
+public:
+ /**
+ * @brief Constructor
+ */
+ LinearGradient();
+
+ /**
+ * @brief Destructor.
+ */
+ ~LinearGradient() override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::LinearGradient::SetBounds()
+ */
+ virtual bool SetBounds(Vector2 firstPoint, Vector2 SecondPoint);
+
+ /**
+ * @copydoc Dali::CanvasRenderer::LinearGradient::SetBounds()
+ */
+ virtual bool GetBounds(Vector2& firstPoint, Vector2& SecondPoint) const;
+
+ LinearGradient(const LinearGradient&) = delete;
+ LinearGradient& operator=(LinearGradient&) = delete;
+ LinearGradient(LinearGradient&&) = delete;
+ LinearGradient& operator=(LinearGradient&&) = delete;
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+inline static Internal::Adaptor::LinearGradient& GetImplementation(Dali::CanvasRenderer::LinearGradient& linearGradient)
+{
+ DALI_ASSERT_ALWAYS(linearGradient && "LinearGradient handle is empty.");
+
+ BaseObject& handle = linearGradient.GetBaseObject();
+
+ return static_cast<Internal::Adaptor::LinearGradient&>(handle);
+}
+
+inline static const Internal::Adaptor::LinearGradient& GetImplementation(const Dali::CanvasRenderer::LinearGradient& linearGradient)
+{
+ DALI_ASSERT_ALWAYS(linearGradient && "LinearGradient handle is empty.");
+
+ const BaseObject& handle = linearGradient.GetBaseObject();
+
+ return static_cast<const Internal::Adaptor::LinearGradient&>(handle);
+}
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_LINEAR_GRADIENT_IMPL_H
--- /dev/null
+#ifndef DALI_INTERNAL_PICTURE_FACTORY_H
+#define DALI_INTERNAL_PICTURE_FACTORY_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-picture.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace PictureFactory
+{
+/**
+ * @brief Creates new instance of Picture implementation
+ * @return pointer to Picture implementation instance
+ */
+Dali::Internal::Adaptor::Picture* New();
+
+} // namespace PictureFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_PICTURE_FACTORY_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/common/picture-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+Picture::Picture() = default;
+
+Picture::~Picture() = default;
+
+bool Picture::Load(const std::string& url)
+{
+ return false;
+}
+
+bool Picture::SetSize(Vector2 size)
+{
+ return false;
+}
+
+Vector2 Picture::GetSize() const
+{
+ return Vector2::ZERO;
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_PICTURE_IMPL_H
+#define DALI_INTERNAL_PICTURE_IMPL_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-picture.h>
+#include <dali/internal/canvas-renderer/common/drawable-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal Picture.
+ */
+class Picture : public Internal::Adaptor::Drawable
+{
+public:
+ /**
+ * @brief Constructor
+ */
+ Picture();
+
+ /**
+ * @brief Destructor.
+ */
+ ~Picture() override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Picture::Load()
+ */
+ virtual bool Load(const std::string& url);
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Picture::SetSize()
+ */
+ virtual bool SetSize(Vector2 size);
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Picture::GetSize()
+ */
+ virtual Vector2 GetSize() const;
+
+ Picture(const Picture&) = delete;
+ Picture& operator=(Picture&) = delete;
+ Picture(Picture&&) = delete;
+ Picture& operator=(Picture&&) = delete;
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+inline static Internal::Adaptor::Picture& GetImplementation(Dali::CanvasRenderer::Picture& picture)
+{
+ DALI_ASSERT_ALWAYS(picture && "Picture handle is empty.");
+
+ BaseObject& handle = picture.GetBaseObject();
+
+ return static_cast<Internal::Adaptor::Picture&>(handle);
+}
+
+inline static const Internal::Adaptor::Picture& GetImplementation(const Dali::CanvasRenderer::Picture& picture)
+{
+ DALI_ASSERT_ALWAYS(picture && "Picture handle is empty.");
+
+ const BaseObject& handle = picture.GetBaseObject();
+
+ return static_cast<const Internal::Adaptor::Picture&>(handle);
+}
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_PICTURE_IMPL_H
--- /dev/null
+#ifndef DALI_INTERNAL_RADIAL_GRADIENT_FACTORY_H
+#define DALI_INTERNAL_RADIAL_GRADIENT_FACTORY_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-radial-gradient.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace RadialGradientFactory
+{
+/**
+ * @brief Creates new instance of RadialGradient implementation
+ * @return pointer to RadialGradient implementation instance
+ */
+Dali::Internal::Adaptor::RadialGradient* New();
+
+} // namespace RadialGradientFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_RADIAL_GRADIENT_FACTORY_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/common/radial-gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+RadialGradient::RadialGradient() = default;
+
+RadialGradient::~RadialGradient() = default;
+
+bool RadialGradient::SetBounds(const Vector2 centerPoint, float radius)
+{
+ return false;
+}
+
+bool RadialGradient::GetBounds(Vector2& centerPoint, float& radius) const
+{
+ return false;
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_RADIAL_GRADIENT_IMPL_H
+#define DALI_INTERNAL_RADIAL_GRADIENT_IMPL_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-radial-gradient.h>
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal RadialGradient.
+ */
+class RadialGradient : public Internal::Adaptor::Gradient
+{
+public:
+ /**
+ * @brief Constructor
+ */
+ RadialGradient();
+
+ /**
+ * @brief Destructor.
+ */
+ ~RadialGradient() override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::RadialGradient::SetBounds()
+ */
+ virtual bool SetBounds(Vector2 centerPoint, float radius);
+
+ /**
+ * @copydoc Dali::CanvasRenderer::RadialGradient::SetBounds()
+ */
+ virtual bool GetBounds(Vector2& centerPoint, float& radius) const;
+
+ RadialGradient(const RadialGradient&) = delete;
+ RadialGradient& operator=(RadialGradient&) = delete;
+ RadialGradient(RadialGradient&&) = delete;
+ RadialGradient& operator=(RadialGradient&&) = delete;
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+inline static Internal::Adaptor::RadialGradient& GetImplementation(Dali::CanvasRenderer::RadialGradient& radialGradient)
+{
+ DALI_ASSERT_ALWAYS(radialGradient && "RadialGradient handle is empty.");
+
+ BaseObject& handle = radialGradient.GetBaseObject();
+
+ return static_cast<Internal::Adaptor::RadialGradient&>(handle);
+}
+
+inline static const Internal::Adaptor::RadialGradient& GetImplementation(const Dali::CanvasRenderer::RadialGradient& radialGradient)
+{
+ DALI_ASSERT_ALWAYS(radialGradient && "RadialGradient handle is empty.");
+
+ const BaseObject& handle = radialGradient.GetBaseObject();
+
+ return static_cast<const Internal::Adaptor::RadialGradient&>(handle);
+}
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_RADIAL_GRADIENT_IMPL_H
return false;
}
+bool Shape::AddPath(Dali::CanvasRenderer::Shape::PathCommands& pathCommand)
+{
+ return false;
+}
+
bool Shape::Close()
{
return false;
return Vector4(0, 0, 0, 0);
}
+bool Shape::SetFillGradient(Dali::CanvasRenderer::Gradient& gradient)
+{
+ return false;
+}
+
+Dali::CanvasRenderer::Gradient Shape::GetFillGradient() const
+{
+ return Dali::CanvasRenderer::Gradient();
+}
+
bool Shape::SetFillRule(Dali::CanvasRenderer::Shape::FillRule rule)
{
return false;
return Vector4(0, 0, 0, 0);
}
+bool Shape::SetStrokeGradient(Dali::CanvasRenderer::Gradient& gradient)
+{
+ return false;
+}
+
+Dali::CanvasRenderer::Gradient Shape::GetStrokeGradient() const
+{
+ return Dali::CanvasRenderer::Gradient();
+}
+
bool Shape::SetStrokeDash(const Dali::Vector<float> dashPattern)
{
return false;
#include <dali/public-api/object/base-object.h>
// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-gradient.h>
#include <dali/devel-api/adaptor-framework/canvas-renderer-shape.h>
#include <dali/internal/canvas-renderer/common/drawable-impl.h>
virtual bool AddCubicTo(Vector2 controlPoint1, Vector2 controlPoint2, Vector2 endPoint);
/**
+ * @copydoc Dali::CanvasRenderer::Shape::AddPath()
+ */
+ virtual bool AddPath(Dali::CanvasRenderer::Shape::PathCommands& pathCommand);
+
+ /**
* @copydoc Dali::CanvasRenderer::Shape::Close()
*/
virtual bool Close();
virtual Vector4 GetFillColor() const;
/**
+ * @copydoc Dali::CanvasRenderer::Shape::SetFillGradient()
+ */
+ virtual bool SetFillGradient(Dali::CanvasRenderer::Gradient& gradient);
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Shape::GetFillGradient()
+ */
+ virtual Dali::CanvasRenderer::Gradient GetFillGradient() const;
+
+ /**
* @copydoc Dali::CanvasRenderer::Shape::SetFillRule()
*/
virtual bool SetFillRule(Dali::CanvasRenderer::Shape::FillRule rule);
virtual Vector4 GetStrokeColor() const;
/**
+ * @copydoc Dali::CanvasRenderer::Shape::SetStrokeGradient()
+ */
+ virtual bool SetStrokeGradient(Dali::CanvasRenderer::Gradient& gradient);
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Shape::GetStrokeGradient()
+ */
+ virtual Dali::CanvasRenderer::Gradient GetStrokeGradient() const;
+
+ /**
* @copydoc Dali::CanvasRenderer::Shape::SetStrokeDash()
*/
virtual bool SetStrokeDash(const Dali::Vector<float> dashPattern);
${adaptor_canvas_renderer_dir}/common/drawable-group-impl.cpp
${adaptor_canvas_renderer_dir}/generic/drawable-group-factory-generic.cpp
${adaptor_canvas_renderer_dir}/generic/drawable-group-impl-generic.cpp
+
+ ${adaptor_canvas_renderer_dir}/common/gradient-impl.cpp
+ ${adaptor_canvas_renderer_dir}/generic/gradient-factory-generic.cpp
+ ${adaptor_canvas_renderer_dir}/generic/gradient-impl-generic.cpp
+
+ ${adaptor_canvas_renderer_dir}/common/linear-gradient-impl.cpp
+ ${adaptor_canvas_renderer_dir}/generic/linear-gradient-factory-generic.cpp
+ ${adaptor_canvas_renderer_dir}/generic/linear-gradient-impl-generic.cpp
+
+ ${adaptor_canvas_renderer_dir}/common/radial-gradient-impl.cpp
+ ${adaptor_canvas_renderer_dir}/generic/radial-gradient-factory-generic.cpp
+ ${adaptor_canvas_renderer_dir}/generic/radial-gradient-impl-generic.cpp
+
+ ${adaptor_canvas_renderer_dir}/common/picture-impl.cpp
+ ${adaptor_canvas_renderer_dir}/generic/picture-factory-generic.cpp
+ ${adaptor_canvas_renderer_dir}/generic/picture-impl-generic.cpp
)
# module: canvas-renderer, backend: ubuntu
${adaptor_canvas_renderer_dir}/common/drawable-group-impl.cpp
${adaptor_canvas_renderer_dir}/ubuntu/drawable-group-factory-ubuntu.cpp
${adaptor_canvas_renderer_dir}/ubuntu/drawable-group-impl-ubuntu.cpp
+
+ ${adaptor_canvas_renderer_dir}/common/gradient-impl.cpp
+ ${adaptor_canvas_renderer_dir}/ubuntu/gradient-factory-ubuntu.cpp
+ ${adaptor_canvas_renderer_dir}/ubuntu/gradient-impl-ubuntu.cpp
+
+ ${adaptor_canvas_renderer_dir}/common/linear-gradient-impl.cpp
+ ${adaptor_canvas_renderer_dir}/ubuntu/linear-gradient-factory-ubuntu.cpp
+ ${adaptor_canvas_renderer_dir}/ubuntu/linear-gradient-impl-ubuntu.cpp
+
+ ${adaptor_canvas_renderer_dir}/common/radial-gradient-impl.cpp
+ ${adaptor_canvas_renderer_dir}/ubuntu/radial-gradient-factory-ubuntu.cpp
+ ${adaptor_canvas_renderer_dir}/ubuntu/radial-gradient-impl-ubuntu.cpp
+
+ ${adaptor_canvas_renderer_dir}/common/picture-impl.cpp
+ ${adaptor_canvas_renderer_dir}/ubuntu/picture-factory-ubuntu.cpp
+ ${adaptor_canvas_renderer_dir}/ubuntu/picture-impl-ubuntu.cpp
)
# module: canvas-renderer, backend: tizen (generic, ivi, mobile, tizen-post, tv, wearable)
${adaptor_canvas_renderer_dir}/common/drawable-group-impl.cpp
${adaptor_canvas_renderer_dir}/tizen/drawable-group-factory-tizen.cpp
${adaptor_canvas_renderer_dir}/tizen/drawable-group-impl-tizen.cpp
+
+ ${adaptor_canvas_renderer_dir}/common/gradient-impl.cpp
+ ${adaptor_canvas_renderer_dir}/tizen/gradient-factory-tizen.cpp
+ ${adaptor_canvas_renderer_dir}/tizen/gradient-impl-tizen.cpp
+
+ ${adaptor_canvas_renderer_dir}/common/linear-gradient-impl.cpp
+ ${adaptor_canvas_renderer_dir}/tizen/linear-gradient-factory-tizen.cpp
+ ${adaptor_canvas_renderer_dir}/tizen/linear-gradient-impl-tizen.cpp
+
+ ${adaptor_canvas_renderer_dir}/common/radial-gradient-impl.cpp
+ ${adaptor_canvas_renderer_dir}/tizen/radial-gradient-factory-tizen.cpp
+ ${adaptor_canvas_renderer_dir}/tizen/radial-gradient-impl-tizen.cpp
+
+ ${adaptor_canvas_renderer_dir}/common/picture-impl.cpp
+ ${adaptor_canvas_renderer_dir}/tizen/picture-factory-tizen.cpp
+ ${adaptor_canvas_renderer_dir}/tizen/picture-impl-tizen.cpp
)
return false;
}
-bool CanvasRendererGeneric::SetSize(const Vector2& size)
+bool CanvasRendererGeneric::SetSize(Vector2 size)
{
return false;
}
-const Vector2& CanvasRendererGeneric::GetSize()
+Vector2 CanvasRendererGeneric::GetSize() const
{
return Vector2::ZERO;
}
/**
* @copydoc Dali::CanvasRenderer::SetSize()
*/
- bool SetSize(const Vector2& size) override;
+ bool SetSize(Vector2 size) override;
/**
* @copydoc Dali::CanvasRenderer::GetSize()
*/
- const Vector2& GetSize() override;
+ Vector2 GetSize() const override;
/**
* @copydoc Dali::CanvasRenderer::SetViewBox()
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/internal/canvas-renderer/generic/gradient-impl-generic.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace GradientFactory
+{
+Dali::Internal::Adaptor::Gradient* New()
+{
+ return Dali::Internal::Adaptor::GradientGeneric::New();
+}
+
+} // namespace GradientFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/generic/gradient-impl-generic.h>
+
+// EXTERNAL INCLUDES
+#include <dali/devel-api/common/stage.h>
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/type-registry.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace // unnamed namespace
+{
+// Type Registration
+Dali::BaseHandle Create()
+{
+ return Dali::BaseHandle();
+}
+
+Dali::TypeRegistration type(typeid(Dali::CanvasRenderer::Gradient), typeid(Dali::BaseHandle), Create);
+
+} // unnamed namespace
+
+GradientGeneric* GradientGeneric::New()
+{
+ return new GradientGeneric();
+}
+
+GradientGeneric::GradientGeneric()
+{
+}
+
+GradientGeneric::~GradientGeneric()
+{
+}
+
+bool GradientGeneric::SetColorStops(Dali::CanvasRenderer::Gradient::ColorStops& colorStops)
+{
+ return false;
+}
+
+Dali::CanvasRenderer::Gradient::ColorStops GradientGeneric::GetColorStops() const
+{
+ return Dali::CanvasRenderer::Gradient::ColorStops();
+}
+
+bool GradientGeneric::SetSpread(Dali::CanvasRenderer::Gradient::Spread spread)
+{
+ return false;
+}
+
+Dali::CanvasRenderer::Gradient::Spread GradientGeneric::GetSpread() const
+{
+ return Dali::CanvasRenderer::Gradient::Spread::PAD;
+}
+
+void GradientGeneric::SetObject(const void* object)
+{
+}
+
+void* GradientGeneric::GetObject() const
+{
+ return nullptr;
+}
+
+void GradientGeneric::SetChanged(bool changed)
+{
+}
+
+bool GradientGeneric::GetChanged() const
+{
+ return false;
+}
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_GENERIC_GRADIENT_IMPL_GENERIC_H
+#define DALI_INTERNAL_GENERIC_GRADIENT_IMPL_GENERIC_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-gradient.h>
+#include <dali/devel-api/adaptor-framework/canvas-renderer.h>
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+#include <dali/internal/canvas-renderer/generic/canvas-renderer-impl-generic.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal Gradient.
+ */
+class GradientGeneric : public Dali::Internal::Adaptor::Gradient
+{
+public:
+ /**
+ * @brief Creates a Gradient object.
+ * @return A pointer to a newly allocated Gradient
+ */
+ static GradientGeneric* New();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::SetColorStops()
+ */
+ bool SetColorStops(Dali::CanvasRenderer::Gradient::ColorStops& colorStops) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::GetColorStops()
+ */
+ Dali::CanvasRenderer::Gradient::ColorStops GetColorStops() const override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::SetSpread()
+ */
+ bool SetSpread(Dali::CanvasRenderer::Gradient::Spread spread) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::GetSpread()
+ */
+ Dali::CanvasRenderer::Gradient::Spread GetSpread() const override;
+
+ /**
+ * @copydoc Internal::Adaptor::Gradient::GetObject()
+ */
+ void SetObject(const void* object) override;
+
+ /**
+ * @copydoc Internal::Adaptor::Gradient::SetObject()
+ */
+ void* GetObject() const override;
+
+ /**
+ * @copydoc Internal::Adaptor::Gradient::SetChanged()
+ */
+ void SetChanged(bool changed) override;
+
+ /**
+ * @copydoc Internal::Adaptor::Gradient::GetChanged()
+ */
+ bool GetChanged() const override;
+
+ GradientGeneric(const Gradient&) = delete;
+ GradientGeneric& operator=(Gradient&) = delete;
+ GradientGeneric(Gradient&&) = delete;
+ GradientGeneric& operator=(Gradient&&) = delete;
+
+protected:
+ /**
+ * @brief Constructor
+ */
+ GradientGeneric();
+
+ /**
+ * @brief Destructor.
+ */
+ virtual ~GradientGeneric() override;
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_GENERIC_GRADIENT_IMPL_GENERIC_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/internal/canvas-renderer/generic/linear-gradient-impl-generic.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace LinearGradientFactory
+{
+Dali::Internal::Adaptor::LinearGradient* New()
+{
+ return Dali::Internal::Adaptor::LinearGradientGeneric::New();
+}
+
+} // namespace LinearGradientFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/generic/linear-gradient-impl-generic.h>
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/type-registry.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace // unnamed namespace
+{
+// Type Registration
+Dali::BaseHandle Create()
+{
+ return Dali::BaseHandle();
+}
+
+Dali::TypeRegistration type(typeid(Dali::CanvasRenderer::LinearGradient), typeid(Dali::BaseHandle), Create);
+
+} // unnamed namespace
+
+LinearGradientGeneric* LinearGradientGeneric::New()
+{
+ return new LinearGradientGeneric();
+}
+
+LinearGradientGeneric::LinearGradientGeneric()
+{
+}
+
+LinearGradientGeneric::~LinearGradientGeneric()
+{
+}
+
+bool LinearGradientGeneric::SetBounds(Vector2 firstPoint, Vector2 secondPoint)
+{
+ return false;
+}
+
+bool LinearGradientGeneric::GetBounds(Vector2& firstPoint, Vector2& secondPoint) const
+{
+ return false;
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_GENERIC_LINEAR_GRADIENT_IMPL_GENERIC_H
+#define DALI_INTERNAL_GENERIC_LINEAR_GRADIENT_IMPL_GENERIC_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-linear-gradient.h>
+#include <dali/internal/canvas-renderer/common/linear-gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal LinearGradient.
+ */
+class LinearGradientGeneric : public Dali::Internal::Adaptor::LinearGradient
+{
+public:
+ /**
+ * @brief Creates a LinearGradient object.
+ * @return A pointer to a newly allocated drawablegroup
+ */
+ static LinearGradientGeneric* New();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::LinearGradient::SetBounds()
+ */
+ bool SetBounds(Vector2 firstPoint, Vector2 secondPoint) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::LinearGradient::SetBounds()
+ */
+ bool GetBounds(Vector2& firstPoint, Vector2& secondPoint) const override;
+
+private:
+ LinearGradientGeneric(const LinearGradientGeneric&) = delete;
+ LinearGradientGeneric& operator=(LinearGradientGeneric&) = delete;
+ LinearGradientGeneric(LinearGradientGeneric&&) = delete;
+ LinearGradientGeneric& operator=(LinearGradientGeneric&&) = delete;
+
+ /**
+ * @brief Constructor
+ */
+ LinearGradientGeneric();
+
+ /**
+ * @brief Destructor.
+ */
+ virtual ~LinearGradientGeneric() override;
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_GENERIC_LINEAR_GRADIENT_IMPL_GENERIC_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/internal/canvas-renderer/generic/picture-impl-generic.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace PictureFactory
+{
+Dali::Internal::Adaptor::Picture* New()
+{
+ return Dali::Internal::Adaptor::PictureGeneric::New();
+}
+
+} // namespace PictureFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/generic/picture-impl-generic.h>
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/type-registry.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace // unnamed namespace
+{
+// Type Registration
+Dali::BaseHandle Create()
+{
+ return Dali::BaseHandle();
+}
+
+Dali::TypeRegistration type(typeid(Dali::CanvasRenderer::Picture), typeid(Dali::BaseHandle), Create);
+
+} // unnamed namespace
+
+PictureGeneric* PictureGeneric::New()
+{
+ return new PictureGeneric();
+}
+
+PictureGeneric::PictureGeneric()
+{
+}
+
+PictureGeneric::~PictureGeneric()
+{
+}
+
+bool PictureGeneric::Load(const std::string& url)
+{
+ return false;
+}
+
+bool PictureGeneric::SetSize(Vector2 size)
+{
+ return false;
+}
+
+Vector2 PictureGeneric::GetSize() const
+{
+ return Vector2::ZERO;
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_GENERIC_PICTURE_IMPL_GENERIC_H
+#define DALI_INTERNAL_GENERIC_PICTURE_IMPL_GENERIC_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-picture.h>
+#include <dali/internal/canvas-renderer/common/picture-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal Picture.
+ */
+class PictureGeneric : public Dali::Internal::Adaptor::Picture
+{
+public:
+ /**
+ * @brief Creates a Picture object.
+ * @return A pointer to a newly allocated picture
+ */
+ static PictureGeneric* New();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Picture::Load()
+ */
+ bool Load(const std::string& url) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Picture::SetSize()
+ */
+ bool SetSize(Vector2 size) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Picture::GetSize()
+ */
+ Vector2 GetSize() const override;
+
+private:
+ PictureGeneric(const PictureGeneric&) = delete;
+ PictureGeneric& operator=(PictureGeneric&) = delete;
+ PictureGeneric(PictureGeneric&&) = delete;
+ PictureGeneric& operator=(PictureGeneric&&) = delete;
+
+ /**
+ * @brief Constructor
+ */
+ PictureGeneric();
+
+ /**
+ * @brief Destructor.
+ */
+ ~PictureGeneric() override;
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_GENERIC_PICTURE_IMPL_GENERIC_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/internal/canvas-renderer/generic/radial-gradient-impl-generic.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace RadialGradientFactory
+{
+Dali::Internal::Adaptor::RadialGradient* New()
+{
+ return Dali::Internal::Adaptor::RadialGradientGeneric::New();
+}
+
+} // namespace RadialGradientFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/generic/radial-gradient-impl-generic.h>
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/type-registry.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace // unnamed namespace
+{
+// Type Registration
+Dali::BaseHandle Create()
+{
+ return Dali::BaseHandle();
+}
+
+Dali::TypeRegistration type(typeid(Dali::CanvasRenderer::RadialGradient), typeid(Dali::BaseHandle), Create);
+
+} // unnamed namespace
+
+RadialGradientGeneric* RadialGradientGeneric::New()
+{
+ return new RadialGradientGeneric();
+}
+
+RadialGradientGeneric::RadialGradientGeneric()
+{
+}
+
+RadialGradientGeneric::~RadialGradientGeneric()
+{
+}
+
+bool RadialGradientGeneric::SetBounds(Vector2 centerPoint, float radius)
+{
+ return false;
+}
+
+bool RadialGradientGeneric::GetBounds(Vector2& centerPoint, float& radius) const
+{
+ return false;
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_GENERIC_RADIAL_GRADIENT_IMPL_GENERIC_H
+#define DALI_INTERNAL_GENERIC_RADIAL_GRADIENT_IMPL_GENERIC_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-radial-gradient.h>
+#include <dali/internal/canvas-renderer/common/radial-gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal RadialGradient.
+ */
+class RadialGradientGeneric : public Dali::Internal::Adaptor::RadialGradient
+{
+public:
+ /**
+ * @brief Creates a RadialGradient object.
+ * @return A pointer to a newly allocated drawablegroup
+ */
+ static RadialGradientGeneric* New();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::RadialGradient::SetBounds()
+ */
+ bool SetBounds(Vector2 centerPoint, float radius) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::RadialGradient::SetBounds()
+ */
+ bool GetBounds(Vector2& centerPoint, float& radius) const override;
+
+private:
+ RadialGradientGeneric(const RadialGradientGeneric&) = delete;
+ RadialGradientGeneric& operator=(RadialGradientGeneric&) = delete;
+ RadialGradientGeneric(RadialGradientGeneric&&) = delete;
+ RadialGradientGeneric& operator=(RadialGradientGeneric&&) = delete;
+
+ /**
+ * @brief Constructor
+ */
+ RadialGradientGeneric();
+
+ /**
+ * @brief Destructor.
+ */
+ virtual ~RadialGradientGeneric() override;
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_GENERIC_RADIAL_GRADIENT_IMPL_GENERIC_H
return false;
}
+bool ShapeGeneric::AddPath(Dali::CanvasRenderer::Shape::PathCommands& pathCommand)
+{
+ return false;
+}
+
bool ShapeGeneric::Close()
{
return false;
bool AddCubicTo(Vector2 controlPoint1, Vector2 controlPoint2, Vector2 endPoint) override;
/**
+ * @copydoc Dali::CanvasRenderer::Shape::AddPath()
+ */
+ bool AddPath(Dali::CanvasRenderer::Shape::PathCommands& pathCommand) override;
+
+ /**
* @copydoc Dali::CanvasRenderer::Shape::Close()
*/
bool Close() override;
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
#include <dali/internal/canvas-renderer/common/drawable-group-impl.h>
#include <dali/internal/canvas-renderer/common/drawable-impl.h>
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+#include <dali/internal/canvas-renderer/common/shape-impl.h>
#include <dali/internal/imaging/common/pixel-buffer-impl.h>
namespace Dali
}
}
}
+ else if(drawableImpl.GetType() == Drawable::Types::SHAPE)
+ {
+ const Dali::CanvasRenderer::Shape& shape = static_cast<const Dali::CanvasRenderer::Shape&>(drawable);
+ Dali::CanvasRenderer::Gradient fillGradient = shape.GetFillGradient();
+ if(DALI_UNLIKELY(fillGradient))
+ {
+ Internal::Adaptor::Gradient& fillGradientImpl = Dali::GetImplementation(fillGradient);
+ if(fillGradientImpl.GetChanged())
+ {
+ return true;
+ }
+ }
+
+ Dali::CanvasRenderer::Gradient strokeGradient = shape.GetStrokeGradient();
+ if(DALI_UNLIKELY(strokeGradient))
+ {
+ Internal::Adaptor::Gradient& strokeGradientImpl = Dali::GetImplementation(strokeGradient);
+ if(strokeGradientImpl.GetChanged())
+ {
+ return true;
+ }
+ }
+ }
return false;
}
UpdateDrawablesChanged(it, changed);
}
}
+ else if(drawableImpl.GetType() == Drawable::Types::SHAPE)
+ {
+ Dali::CanvasRenderer::Shape& shape = static_cast<Dali::CanvasRenderer::Shape&>(drawable);
+ Dali::CanvasRenderer::Gradient fillGradient = shape.GetFillGradient();
+ if(DALI_UNLIKELY(fillGradient))
+ {
+ Internal::Adaptor::Gradient& fillGradientImpl = Dali::GetImplementation(fillGradient);
+ fillGradientImpl.SetChanged(changed);
+ }
+
+ Dali::CanvasRenderer::Gradient strokeGradient = shape.GetStrokeGradient();
+ if(DALI_UNLIKELY(strokeGradient))
+ {
+ Internal::Adaptor::Gradient& strokeGradientImpl = Dali::GetImplementation(strokeGradient);
+ strokeGradientImpl.SetChanged(changed);
+ }
+ }
}
#endif
#endif
}
-bool CanvasRendererTizen::SetSize(const Vector2& size)
+bool CanvasRendererTizen::SetSize(Vector2 size)
{
if(size.width < 1.0f || size.height < 1.0f)
{
return true;
}
-const Vector2& CanvasRendererTizen::GetSize()
+Vector2 CanvasRendererTizen::GetSize() const
{
return mSize;
}
PushDrawableToGroup(it, static_cast<tvg::Scene*>(tvgDuplicatedObject));
}
}
+ else if(type == Drawable::Types::SHAPE)
+ {
+ //FillGradient
+ Dali::CanvasRenderer::Shape& shape = static_cast<Dali::CanvasRenderer::Shape&>(drawable);
+ Dali::CanvasRenderer::Gradient fillGradient = shape.GetFillGradient();
+ if(DALI_UNLIKELY(fillGradient))
+ {
+ Internal::Adaptor::Gradient& fillGradientImpl = Dali::GetImplementation(fillGradient);
+ tvg::Fill* tvgDuplicatedFillGradient = static_cast<tvg::Fill*>(fillGradientImpl.GetObject())->duplicate();
+ if(!tvgDuplicatedFillGradient)
+ {
+ DALI_LOG_ERROR("Invalid gradient object [%p]\n", this);
+ return;
+ }
+ if(static_cast<tvg::Shape*>(tvgDuplicatedObject)->fill(std::unique_ptr<tvg::Fill>(tvgDuplicatedFillGradient)) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("Tvg gradient set fail [%p]\n", this);
+ return;
+ }
+ }
+
+ //StrokeGradient
+ Dali::CanvasRenderer::Gradient strokeGradient = shape.GetStrokeGradient();
+ if(DALI_UNLIKELY(strokeGradient))
+ {
+ Internal::Adaptor::Gradient& strokeGradientImpl = Dali::GetImplementation(strokeGradient);
+ tvg::Fill* tvgDuplicatedStrokeGradient = static_cast<tvg::Fill*>(strokeGradientImpl.GetObject())->duplicate();
+ if(!tvgDuplicatedStrokeGradient)
+ {
+ DALI_LOG_ERROR("Invalid gradient object [%p]\n", this);
+ return;
+ }
+ if(static_cast<tvg::Shape*>(tvgDuplicatedObject)->stroke(std::unique_ptr<tvg::Fill>(tvgDuplicatedStrokeGradient)) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("Tvg gradient set fail [%p]\n", this);
+ return;
+ }
+ }
+ }
Dali::CanvasRenderer::Drawable compositeDrawable = drawableImpl.GetCompositionDrawable();
if(DALI_UNLIKELY(compositeDrawable))
/**
* @copydoc Dali::CanvasRenderer::SetSize()
*/
- bool SetSize(const Vector2& size) override;
+ bool SetSize(Vector2 size) override;
/**
* @copydoc Dali::CanvasRenderer::GetSize()
*/
- const Vector2& GetSize() override;
+ Vector2 GetSize() const override;
/**
* @copydoc Dali::CanvasRenderer::SetViewBox()
#ifdef THORVG_SUPPORT
if(object)
{
- mTvgPaint = static_cast<tvg::Paint*>((void*)object);
+ mTvgPaint = static_cast<tvg::Paint*>(const_cast<void*>(object));
}
#endif
}
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/internal/canvas-renderer/tizen/gradient-impl-tizen.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace GradientFactory
+{
+Dali::Internal::Adaptor::Gradient* New()
+{
+ return Dali::Internal::Adaptor::GradientTizen::New();
+}
+
+} // namespace GradientFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/tizen/gradient-impl-tizen.h>
+
+// EXTERNAL INCLUDES
+#include <dali/devel-api/common/stage.h>
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/type-registry.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace // unnamed namespace
+{
+// Type Registration
+Dali::BaseHandle Create()
+{
+ return Dali::BaseHandle();
+}
+
+Dali::TypeRegistration type(typeid(Dali::CanvasRenderer::Gradient), typeid(Dali::BaseHandle), Create);
+
+} // unnamed namespace
+
+GradientTizen* GradientTizen::New()
+{
+ return new GradientTizen();
+}
+
+GradientTizen::GradientTizen()
+: mChanged(false)
+#ifdef THORVG_SUPPORT
+ ,
+ mTvgFill(nullptr)
+#endif
+{
+}
+
+GradientTizen::~GradientTizen()
+{
+#ifdef THORVG_SUPPORT
+ if(mTvgFill)
+ {
+ delete mTvgFill;
+ }
+#endif
+}
+
+bool GradientTizen::SetColorStops(Dali::CanvasRenderer::Gradient::ColorStops& colorStops)
+{
+#ifdef THORVG_SUPPORT
+ if(!mTvgFill)
+ {
+ DALI_LOG_ERROR("Fill(Gradient) is null [%p]\n", this);
+ return false;
+ }
+ SetChanged(true);
+
+ tvg::Fill::ColorStop* tvgColorStops = (tvg::Fill::ColorStop*)alloca(sizeof(tvg::Fill::ColorStop) * colorStops.Count());
+
+ for(unsigned int i = 0u; i < colorStops.Count(); ++i)
+ {
+ tvgColorStops[i].offset = colorStops[i].offset;
+ tvgColorStops[i].r = colorStops[i].color.r * 255.0f;
+ tvgColorStops[i].g = colorStops[i].color.g * 255.0f;
+ tvgColorStops[i].b = colorStops[i].color.b * 255.0f;
+ tvgColorStops[i].a = colorStops[i].color.a * 255.0f;
+ }
+
+ if(mTvgFill->colorStops(tvgColorStops, colorStops.Count()) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("SetColorStops() fail.\n");
+ return false;
+ }
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+Dali::CanvasRenderer::Gradient::ColorStops GradientTizen::GetColorStops() const
+{
+#ifdef THORVG_SUPPORT
+ if(!mTvgFill)
+ {
+ DALI_LOG_ERROR("Fill(Gradient) is null [%p]\n", this);
+ return Dali::CanvasRenderer::Gradient::ColorStops();
+ }
+
+ const tvg::Fill::ColorStop* tvgColorStops = nullptr;
+ uint32_t count = 0;
+
+ count = mTvgFill->colorStops(&tvgColorStops);
+ if(!tvgColorStops || count <= 0)
+ {
+ DALI_LOG_ERROR("GetColorStops() fail.\n");
+ return Dali::CanvasRenderer::Gradient::ColorStops();
+ }
+
+ Dali::CanvasRenderer::Gradient::ColorStops colorStops;
+
+ colorStops.Reserve(count);
+
+ for(unsigned int i = 0u; i < count; ++i)
+ {
+ Dali::CanvasRenderer::Gradient::ColorStop stop = {tvgColorStops[i].offset, Vector4(tvgColorStops[i].r / 255.0f, tvgColorStops[i].g / 255.0f, tvgColorStops[i].b / 255.0f, tvgColorStops[i].a / 255.0f)};
+
+ colorStops.PushBack(stop);
+ }
+ return colorStops;
+#else
+ return Dali::CanvasRenderer::Gradient::ColorStops();
+#endif
+}
+
+bool GradientTizen::SetSpread(Dali::CanvasRenderer::Gradient::Spread spread)
+{
+#ifdef THORVG_SUPPORT
+ if(!mTvgFill)
+ {
+ DALI_LOG_ERROR("Fill(Gradient) is null [%p]\n", this);
+ return false;
+ }
+ if(mTvgFill->spread(static_cast<tvg::FillSpread>(spread)) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("SetSpread() fail.\n");
+ return false;
+ }
+ SetChanged(true);
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+Dali::CanvasRenderer::Gradient::Spread GradientTizen::GetSpread() const
+{
+#ifdef THORVG_SUPPORT
+ if(!mTvgFill)
+ {
+ DALI_LOG_ERROR("Fill(Gradient) is null [%p]\n", this);
+ return Dali::CanvasRenderer::Gradient::Spread::PAD;
+ }
+
+ tvg::FillSpread spread = mTvgFill->spread();
+
+ return static_cast<Dali::CanvasRenderer::Gradient::Spread>(spread);
+#else
+ return Dali::CanvasRenderer::Gradient::Spread::PAD;
+#endif
+}
+
+void GradientTizen::SetObject(const void* object)
+{
+#ifdef THORVG_SUPPORT
+ if(object)
+ {
+ mTvgFill = static_cast<tvg::Fill*>(const_cast<void*>(object));
+ }
+#endif
+}
+
+void* GradientTizen::GetObject() const
+{
+#ifdef THORVG_SUPPORT
+ return static_cast<void*>(mTvgFill);
+#else
+ return nullptr;
+#endif
+}
+
+void GradientTizen::SetChanged(bool changed)
+{
+ if(!mChanged && changed) Dali::Stage::GetCurrent().KeepRendering(0.0f);
+ mChanged = !!changed;
+}
+
+bool GradientTizen::GetChanged() const
+{
+ return mChanged;
+}
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_TIZEN_GRADIENT_IMPL_TIZEN_H
+#define DALI_INTERNAL_TIZEN_GRADIENT_IMPL_TIZEN_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#ifdef THORVG_SUPPORT
+#include <thorvg.h>
+#endif
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-gradient.h>
+#include <dali/devel-api/adaptor-framework/canvas-renderer.h>
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+#include <dali/internal/canvas-renderer/tizen/canvas-renderer-impl-tizen.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal Gradient.
+ */
+class GradientTizen : public Dali::Internal::Adaptor::Gradient
+{
+public:
+ /**
+ * @brief Creates a Gradient object.
+ * @return A pointer to a newly allocated Gradient
+ */
+ static GradientTizen* New();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::SetColorStops()
+ */
+ bool SetColorStops(Dali::CanvasRenderer::Gradient::ColorStops& colorStops) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::GetColorStops()
+ */
+ Dali::CanvasRenderer::Gradient::ColorStops GetColorStops() const override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::SetSpread()
+ */
+ bool SetSpread(Dali::CanvasRenderer::Gradient::Spread spread) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::GetSpread()
+ */
+ Dali::CanvasRenderer::Gradient::Spread GetSpread() const override;
+
+ /**
+ * @copydoc Internal::Adaptor::Gradient::GetObject()
+ */
+ void SetObject(const void* object) override;
+
+ /**
+ * @copydoc Internal::Adaptor::Gradient::SetObject()
+ */
+ void* GetObject() const override;
+
+ /**
+ * @copydoc Internal::Adaptor::Gradient::SetChanged()
+ */
+ void SetChanged(bool changed) override;
+
+ /**
+ * @copydoc Internal::Adaptor::Gradient::GetChanged()
+ */
+ bool GetChanged() const override;
+
+ GradientTizen(const Gradient&) = delete;
+ GradientTizen& operator=(Gradient&) = delete;
+ GradientTizen(Gradient&&) = delete;
+ GradientTizen& operator=(Gradient&&) = delete;
+
+protected:
+ /**
+ * @brief Constructor
+ */
+ GradientTizen();
+
+ /**
+ * @brief Destructor.
+ */
+ virtual ~GradientTizen() override;
+
+private:
+ bool mChanged;
+#ifdef THORVG_SUPPORT
+ tvg::Fill* mTvgFill;
+#endif
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_TIZEN_GRADIENT_IMPL_TIZEN_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/internal/canvas-renderer/tizen/linear-gradient-impl-tizen.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace LinearGradientFactory
+{
+Dali::Internal::Adaptor::LinearGradient* New()
+{
+ return Dali::Internal::Adaptor::LinearGradientTizen::New();
+}
+
+} // namespace LinearGradientFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/tizen/linear-gradient-impl-tizen.h>
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/type-registry.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace // unnamed namespace
+{
+// Type Registration
+Dali::BaseHandle Create()
+{
+ return Dali::BaseHandle();
+}
+
+Dali::TypeRegistration type(typeid(Dali::CanvasRenderer::LinearGradient), typeid(Dali::BaseHandle), Create);
+
+} // unnamed namespace
+
+LinearGradientTizen* LinearGradientTizen::New()
+{
+ return new LinearGradientTizen();
+}
+
+LinearGradientTizen::LinearGradientTizen()
+#ifdef THORVG_SUPPORT
+: mTvgLinearGradient(nullptr)
+#endif
+{
+ Initialize();
+}
+
+LinearGradientTizen::~LinearGradientTizen()
+{
+}
+
+void LinearGradientTizen::Initialize()
+{
+#ifdef THORVG_SUPPORT
+ mTvgLinearGradient = tvg::LinearGradient::gen().release();
+ if(!mTvgLinearGradient)
+ {
+ DALI_LOG_ERROR("LinearGradient is null [%p]\n", this);
+ }
+
+ Gradient::Create();
+ Gradient::SetObject(static_cast<void*>(mTvgLinearGradient));
+#endif
+}
+
+bool LinearGradientTizen::SetBounds(Vector2 firstPoint, Vector2 secondPoint)
+{
+#ifdef THORVG_SUPPORT
+ if(!Gradient::GetObject() || !mTvgLinearGradient)
+ {
+ DALI_LOG_ERROR("LinearGradient is null\n");
+ return false;
+ }
+
+ if(mTvgLinearGradient->linear(firstPoint.x, firstPoint.y, secondPoint.x, secondPoint.y) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("SetBounds() fail.\n");
+ return false;
+ }
+
+ Gradient::SetChanged(true);
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool LinearGradientTizen::GetBounds(Vector2& firstPoint, Vector2& secondPoint) const
+{
+#ifdef THORVG_SUPPORT
+ if(!Gradient::GetObject() || !mTvgLinearGradient)
+ {
+ DALI_LOG_ERROR("LinearGradient is null\n");
+ return false;
+ }
+
+ if(mTvgLinearGradient->linear(&firstPoint.x, &firstPoint.y, &secondPoint.x, &secondPoint.y) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("GetBounds() fail.\n");
+ return false;
+ }
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_TIZEN_LINEAR_GRADIENT_IMPL_TIZEN_H
+#define DALI_INTERNAL_TIZEN_LINEAR_GRADIENT_IMPL_TIZEN_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#ifdef THORVG_SUPPORT
+#include <thorvg.h>
+#endif
+#include <dali/public-api/object/base-object.h>
+#include <dali/public-api/object/weak-handle.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-linear-gradient.h>
+#include <dali/internal/canvas-renderer/common/linear-gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal LinearGradient.
+ */
+class LinearGradientTizen : public Dali::Internal::Adaptor::LinearGradient
+{
+public:
+ /**
+ * @brief Creates a LinearGradient object.
+ * @return A pointer to a newly allocated drawablegroup
+ */
+ static LinearGradientTizen* New();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::LinearGradient::SetBounds()
+ */
+ bool SetBounds(Vector2 firstPoint, Vector2 secondPoint) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::LinearGradient::SetBounds()
+ */
+ bool GetBounds(Vector2& firstPoint, Vector2& secondPoint) const override;
+
+private:
+ LinearGradientTizen(const LinearGradientTizen&) = delete;
+ LinearGradientTizen& operator=(LinearGradientTizen&) = delete;
+ LinearGradientTizen(LinearGradientTizen&&) = delete;
+ LinearGradientTizen& operator=(LinearGradientTizen&&) = delete;
+
+ /**
+ * @brief Constructor
+ */
+ LinearGradientTizen();
+
+ /**
+ * @brief Destructor.
+ */
+ virtual ~LinearGradientTizen() override;
+
+private:
+ /**
+ * @brief Initializes member data.
+ */
+ void Initialize();
+
+private:
+#ifdef THORVG_SUPPORT
+ tvg::LinearGradient* mTvgLinearGradient;
+#endif
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_TIZEN_LINEAR_GRADIENT_IMPL_TIZEN_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/internal/canvas-renderer/tizen/picture-impl-tizen.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace PictureFactory
+{
+Dali::Internal::Adaptor::Picture* New()
+{
+ return Dali::Internal::Adaptor::PictureTizen::New();
+}
+
+} // namespace PictureFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/tizen/picture-impl-tizen.h>
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/type-registry.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace // unnamed namespace
+{
+// Type Registration
+Dali::BaseHandle Create()
+{
+ return Dali::BaseHandle();
+}
+
+Dali::TypeRegistration type(typeid(Dali::CanvasRenderer::Picture), typeid(Dali::BaseHandle), Create);
+
+} // unnamed namespace
+
+PictureTizen* PictureTizen::New()
+{
+ return new PictureTizen();
+}
+
+PictureTizen::PictureTizen()
+#ifdef THORVG_SUPPORT
+: mTvgPicture(nullptr)
+#endif
+{
+ Initialize();
+}
+
+PictureTizen::~PictureTizen()
+{
+}
+
+void PictureTizen::Initialize()
+{
+#ifdef THORVG_SUPPORT
+ mTvgPicture = tvg::Picture::gen().release();
+ if(!mTvgPicture)
+ {
+ DALI_LOG_ERROR("Picture is null [%p]\n", this);
+ }
+
+ Drawable::Create();
+ Drawable::SetObject(static_cast<void*>(mTvgPicture));
+ Drawable::SetType(Drawable::Types::PICTURE);
+#endif
+}
+
+bool PictureTizen::Load(const std::string& url)
+{
+#ifdef THORVG_SUPPORT
+ if(!Drawable::GetObject() || !mTvgPicture)
+ {
+ DALI_LOG_ERROR("Picture is null [%p]\n", this);
+ return false;
+ }
+ if(url.empty())
+ {
+ DALI_LOG_ERROR("Url is empty [%p]\n", this);
+ return false;
+ }
+
+ if(mTvgPicture->load(url.c_str()) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("Load() fail. (%s)\n", url.c_str());
+ return false;
+ }
+
+ Drawable::SetChanged(true);
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool PictureTizen::SetSize(Vector2 size)
+{
+#ifdef THORVG_SUPPORT
+ if(!Drawable::GetObject() || !mTvgPicture)
+ {
+ DALI_LOG_ERROR("Picture is null [%p]\n", this);
+ return false;
+ }
+ if(mTvgPicture->size(size.width, size.height) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("SetSize() fail.\n");
+ return false;
+ }
+ Drawable::SetChanged(true);
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+Vector2 PictureTizen::GetSize() const
+{
+#ifdef THORVG_SUPPORT
+ if(!Drawable::GetObject() || !mTvgPicture)
+ {
+ DALI_LOG_ERROR("Picture is null [%p]\n", this);
+ return Vector2::ZERO;
+ }
+
+ auto width = 0.0f;
+ auto height = 0.0f;
+
+ if(mTvgPicture->size(&width, &height) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("GetSize() fail.\n");
+ return Vector2::ZERO;
+ }
+ return Vector2(width, height);
+#else
+ return Vector2::ZERO;
+#endif
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_TIZEN_PICTURE_IMPL_TIZEN_H
+#define DALI_INTERNAL_TIZEN_PICTURE_IMPL_TIZEN_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#ifdef THORVG_SUPPORT
+#include <thorvg.h>
+#endif
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-picture.h>
+#include <dali/internal/canvas-renderer/common/picture-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal Picture.
+ */
+class PictureTizen : public Dali::Internal::Adaptor::Picture
+{
+public:
+ /**
+ * @brief Creates a Picture object.
+ * @return A pointer to a newly allocated picture
+ */
+ static PictureTizen* New();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Picture::Load()
+ */
+ bool Load(const std::string& url) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Picture::SetSize()
+ */
+ bool SetSize(Vector2 size) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Picture::GetSize()
+ */
+ Vector2 GetSize() const override;
+
+private:
+ PictureTizen(const PictureTizen&) = delete;
+ PictureTizen& operator=(PictureTizen&) = delete;
+ PictureTizen(PictureTizen&&) = delete;
+ PictureTizen& operator=(PictureTizen&&) = delete;
+
+ /**
+ * @brief Constructor
+ */
+ PictureTizen();
+
+ /**
+ * @brief Destructor.
+ */
+ ~PictureTizen() override;
+
+private:
+ /**
+ * @brief Initializes member data.
+ */
+ void Initialize();
+
+private:
+#ifdef THORVG_SUPPORT
+ tvg::Picture* mTvgPicture;
+#endif
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_TIZEN_PICTURE_IMPL_TIZEN_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/internal/canvas-renderer/tizen/radial-gradient-impl-tizen.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace RadialGradientFactory
+{
+Dali::Internal::Adaptor::RadialGradient* New()
+{
+ return Dali::Internal::Adaptor::RadialGradientTizen::New();
+}
+
+} // namespace RadialGradientFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/tizen/radial-gradient-impl-tizen.h>
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/type-registry.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace // unnamed namespace
+{
+// Type Registration
+Dali::BaseHandle Create()
+{
+ return Dali::BaseHandle();
+}
+
+Dali::TypeRegistration type(typeid(Dali::CanvasRenderer::RadialGradient), typeid(Dali::BaseHandle), Create);
+
+} // unnamed namespace
+
+RadialGradientTizen* RadialGradientTizen::New()
+{
+ return new RadialGradientTizen();
+}
+
+RadialGradientTizen::RadialGradientTizen()
+#ifdef THORVG_SUPPORT
+: mTvgRadialGradient(nullptr)
+#endif
+{
+ Initialize();
+}
+
+RadialGradientTizen::~RadialGradientTizen()
+{
+}
+
+void RadialGradientTizen::Initialize()
+{
+#ifdef THORVG_SUPPORT
+ mTvgRadialGradient = tvg::RadialGradient::gen().release();
+ if(!mTvgRadialGradient)
+ {
+ DALI_LOG_ERROR("RadialGradient is null [%p]\n", this);
+ }
+
+ Gradient::Create();
+ Gradient::SetObject(static_cast<void*>(mTvgRadialGradient));
+#endif
+}
+
+bool RadialGradientTizen::SetBounds(Vector2 centerPoint, float radius)
+{
+#ifdef THORVG_SUPPORT
+ if(!Gradient::GetObject() || !mTvgRadialGradient)
+ {
+ DALI_LOG_ERROR("RadialGradient is null\n");
+ return false;
+ }
+
+ if(mTvgRadialGradient->radial(centerPoint.x, centerPoint.y, radius) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("SetBounds() fail.\n");
+ return false;
+ }
+
+ Gradient::SetChanged(true);
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool RadialGradientTizen::GetBounds(Vector2& centerPoint, float& radius) const
+{
+#ifdef THORVG_SUPPORT
+ if(!Gradient::GetObject() || !mTvgRadialGradient)
+ {
+ DALI_LOG_ERROR("RadialGradient is null\n");
+ return false;
+ }
+
+ if(mTvgRadialGradient->radial(¢erPoint.x, ¢erPoint.y, &radius) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("GetBounds() fail.\n");
+ return false;
+ }
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_TIZEN_RADIAL_GRADIENT_IMPL_TIZEN_H
+#define DALI_INTERNAL_TIZEN_RADIAL_GRADIENT_IMPL_TIZEN_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#ifdef THORVG_SUPPORT
+#include <thorvg.h>
+#endif
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-radial-gradient.h>
+#include <dali/internal/canvas-renderer/common/radial-gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal RadialGradient.
+ */
+class RadialGradientTizen : public Dali::Internal::Adaptor::RadialGradient
+{
+public:
+ /**
+ * @brief Creates a RadialGradient object.
+ * @return A pointer to a newly allocated drawablegroup
+ */
+ static RadialGradientTizen* New();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::RadialGradient::SetBounds()
+ */
+ bool SetBounds(Vector2 centerPoint, float radius) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::RadialGradient::SetBounds()
+ */
+ bool GetBounds(Vector2& centerPoint, float& radius) const override;
+
+private:
+ RadialGradientTizen(const RadialGradientTizen&) = delete;
+ RadialGradientTizen& operator=(RadialGradientTizen&) = delete;
+ RadialGradientTizen(RadialGradientTizen&&) = delete;
+ RadialGradientTizen& operator=(RadialGradientTizen&&) = delete;
+
+ /**
+ * @brief Constructor
+ */
+ RadialGradientTizen();
+
+ /**
+ * @brief Destructor.
+ */
+ virtual ~RadialGradientTizen() override;
+
+private:
+ /**
+ * @brief Initializes member data.
+ */
+ void Initialize();
+
+private:
+#ifdef THORVG_SUPPORT
+ tvg::RadialGradient* mTvgRadialGradient;
+#endif
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_TIZEN_RADIAL_GRADIENT_IMPL_TIZEN_H
}
ShapeTizen::ShapeTizen()
+: mFillGradient(),
+ mStrokeGradient()
#ifdef THORVG_SUPPORT
-: mTvgShape(nullptr)
+ ,
+ mTvgShape(nullptr)
#endif
{
Initialize();
#endif
}
+bool ShapeTizen::AddPath(Dali::CanvasRenderer::Shape::PathCommands& pathCommand)
+{
+#ifdef THORVG_SUPPORT
+ if(!Drawable::GetObject() || !mTvgShape)
+ {
+ DALI_LOG_ERROR("Shape is null\n");
+ return false;
+ }
+
+ if(static_cast<tvg::Shape*>(mTvgShape)->appendPath(reinterpret_cast<const tvg::PathCommand*>(pathCommand.mCommands), pathCommand.mCommandCount, static_cast<const tvg::Point*>(static_cast<void*>(pathCommand.mPoints)), pathCommand.mPointCount) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("AddPath() fail.\n");
+ return false;
+ }
+ Drawable::SetChanged(true);
+ return true;
+#else
+ return false;
+#endif
+}
+
bool ShapeTizen::Close()
{
#ifdef THORVG_SUPPORT
#endif
}
+bool ShapeTizen::SetFillGradient(Dali::CanvasRenderer::Gradient& gradient)
+{
+#ifdef THORVG_SUPPORT
+ if(!Drawable::GetObject() || !mTvgShape)
+ {
+ DALI_LOG_ERROR("Shape is null [%p]\n", this);
+ return false;
+ }
+ mFillGradient = gradient;
+ Drawable::SetChanged(true);
+ return true;
+#else
+ return false;
+#endif
+}
+
+Dali::CanvasRenderer::Gradient ShapeTizen::GetFillGradient() const
+{
+ return mFillGradient;
+}
+
bool ShapeTizen::SetFillRule(Dali::CanvasRenderer::Shape::FillRule rule)
{
#ifdef THORVG_SUPPORT
#endif
}
+bool ShapeTizen::SetStrokeGradient(Dali::CanvasRenderer::Gradient& gradient)
+{
+#ifdef THORVG_SUPPORT
+ if(!Drawable::GetObject() || !mTvgShape)
+ {
+ DALI_LOG_ERROR("Shape is null [%p]\n", this);
+ return false;
+ }
+ mStrokeGradient = gradient;
+ Drawable::SetChanged(true);
+ return true;
+#else
+ return false;
+#endif
+}
+
+Dali::CanvasRenderer::Gradient ShapeTizen::GetStrokeGradient() const
+{
+ return mStrokeGradient;
+}
+
bool ShapeTizen::SetStrokeDash(const Dali::Vector<float> dashPattern)
{
#ifdef THORVG_SUPPORT
bool AddCubicTo(Vector2 controlPoint1, Vector2 controlPoint2, Vector2 endPoint) override;
/**
+ * @copydoc Dali::CanvasRenderer::Shape::AddPath()
+ */
+ bool AddPath(Dali::CanvasRenderer::Shape::PathCommands& pathCommand) override;
+
+ /**
* @copydoc Dali::CanvasRenderer::Shape::Close()
*/
bool Close() override;
Vector4 GetFillColor() const override;
/**
+ * @copydoc Dali::CanvasRenderer::Shape::SetFillGradient()
+ */
+ bool SetFillGradient(Dali::CanvasRenderer::Gradient& gradient) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Shape::GetFillGradient()
+ */
+ Dali::CanvasRenderer::Gradient GetFillGradient() const override;
+
+ /**
* @copydoc Dali::CanvasRenderer::Shape::SetFillRule()
*/
bool SetFillRule(Dali::CanvasRenderer::Shape::FillRule rule) override;
Vector4 GetStrokeColor() const override;
/**
+ * @copydoc Dali::CanvasRenderer::Shape::SetStrokeGradient()
+ */
+ bool SetStrokeGradient(Dali::CanvasRenderer::Gradient& gradient) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Shape::GetStrokeGradient()
+ */
+ Dali::CanvasRenderer::Gradient GetStrokeGradient() const override;
+
+ /**
* @copydoc Dali::CanvasRenderer::Shape::SetStrokeDash()
*/
bool SetStrokeDash(const Dali::Vector<float> dashPattern) override;
*/
void Initialize();
-#ifdef THORVG_SUPPORT
private:
+ Dali::CanvasRenderer::Gradient mFillGradient;
+ Dali::CanvasRenderer::Gradient mStrokeGradient;
+#ifdef THORVG_SUPPORT
tvg::Shape* mTvgShape;
#endif
};
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
#include <dali/internal/canvas-renderer/common/drawable-group-impl.h>
#include <dali/internal/canvas-renderer/common/drawable-impl.h>
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+#include <dali/internal/canvas-renderer/common/shape-impl.h>
#include <dali/internal/imaging/common/pixel-buffer-impl.h>
namespace Dali
}
}
}
+ else if(drawableImpl.GetType() == Drawable::Types::SHAPE)
+ {
+ const Dali::CanvasRenderer::Shape& shape = static_cast<const Dali::CanvasRenderer::Shape&>(drawable);
+ Dali::CanvasRenderer::Gradient fillGradient = shape.GetFillGradient();
+ if(DALI_UNLIKELY(fillGradient))
+ {
+ Internal::Adaptor::Gradient& fillGradientImpl = Dali::GetImplementation(fillGradient);
+ if(fillGradientImpl.GetChanged())
+ {
+ return true;
+ }
+ }
+
+ Dali::CanvasRenderer::Gradient strokeGradient = shape.GetStrokeGradient();
+ if(DALI_UNLIKELY(strokeGradient))
+ {
+ Internal::Adaptor::Gradient& strokeGradientImpl = Dali::GetImplementation(strokeGradient);
+ if(strokeGradientImpl.GetChanged())
+ {
+ return true;
+ }
+ }
+ }
return false;
}
UpdateDrawablesChanged(it, changed);
}
}
+ else if(drawableImpl.GetType() == Drawable::Types::SHAPE)
+ {
+ Dali::CanvasRenderer::Shape& shape = static_cast<Dali::CanvasRenderer::Shape&>(drawable);
+ Dali::CanvasRenderer::Gradient fillGradient = shape.GetFillGradient();
+ if(DALI_UNLIKELY(fillGradient))
+ {
+ Internal::Adaptor::Gradient& fillGradientImpl = Dali::GetImplementation(fillGradient);
+ fillGradientImpl.SetChanged(changed);
+ }
+
+ Dali::CanvasRenderer::Gradient strokeGradient = shape.GetStrokeGradient();
+ if(DALI_UNLIKELY(strokeGradient))
+ {
+ Internal::Adaptor::Gradient& strokeGradientImpl = Dali::GetImplementation(strokeGradient);
+ strokeGradientImpl.SetChanged(changed);
+ }
+ }
}
#endif
#endif
}
-bool CanvasRendererUbuntu::SetSize(const Vector2& size)
+bool CanvasRendererUbuntu::SetSize(Vector2 size)
{
if(size.width < 1.0f || size.height < 1.0f)
{
return true;
}
-const Vector2& CanvasRendererUbuntu::GetSize()
+Vector2 CanvasRendererUbuntu::GetSize() const
{
return mSize;
}
PushDrawableToGroup(it, static_cast<tvg::Scene*>(tvgDuplicatedObject));
}
}
+ else if(type == Drawable::Types::SHAPE)
+ {
+ //FillGradient
+ Dali::CanvasRenderer::Shape& shape = static_cast<Dali::CanvasRenderer::Shape&>(drawable);
+ Dali::CanvasRenderer::Gradient fillGradient = shape.GetFillGradient();
+ if(DALI_UNLIKELY(fillGradient))
+ {
+ Internal::Adaptor::Gradient& fillGradientImpl = Dali::GetImplementation(fillGradient);
+ tvg::Fill* tvgDuplicatedFillGradient = static_cast<tvg::Fill*>(fillGradientImpl.GetObject())->duplicate();
+ if(!tvgDuplicatedFillGradient)
+ {
+ DALI_LOG_ERROR("Invalid gradient object [%p]\n", this);
+ return;
+ }
+ if(static_cast<tvg::Shape*>(tvgDuplicatedObject)->fill(std::unique_ptr<tvg::Fill>(tvgDuplicatedFillGradient)) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("Tvg gradient set fail [%p]\n", this);
+ return;
+ }
+ }
+
+ //StrokeGradient
+ Dali::CanvasRenderer::Gradient strokeGradient = shape.GetStrokeGradient();
+ if(DALI_UNLIKELY(strokeGradient))
+ {
+ Internal::Adaptor::Gradient& strokeGradientImpl = Dali::GetImplementation(strokeGradient);
+ tvg::Fill* tvgDuplicatedStrokeGradient = static_cast<tvg::Fill*>(strokeGradientImpl.GetObject())->duplicate();
+ if(!tvgDuplicatedStrokeGradient)
+ {
+ DALI_LOG_ERROR("Invalid gradient object [%p]\n", this);
+ return;
+ }
+ if(static_cast<tvg::Shape*>(tvgDuplicatedObject)->stroke(std::unique_ptr<tvg::Fill>(tvgDuplicatedStrokeGradient)) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("Tvg gradient set fail [%p]\n", this);
+ return;
+ }
+ }
+ }
Dali::CanvasRenderer::Drawable compositeDrawable = drawableImpl.GetCompositionDrawable();
if(DALI_UNLIKELY(compositeDrawable))
/**
* @copydoc Dali::CanvasRenderer::SetSize()
*/
- bool SetSize(const Vector2& size) override;
+ bool SetSize(Vector2 size) override;
/**
* @copydoc Dali::CanvasRenderer::GetSize()
*/
- const Vector2& GetSize() override;
+ Vector2 GetSize() const override;
/**
* @copydoc Dali::CanvasRenderer::SetViewBox()
#ifdef THORVG_SUPPORT
if(object)
{
- mTvgPaint = static_cast<tvg::Paint*>((void*)object);
+ mTvgPaint = static_cast<tvg::Paint*>(const_cast<void*>(object));
}
#endif
}
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/internal/canvas-renderer/ubuntu/gradient-impl-ubuntu.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace GradientFactory
+{
+Dali::Internal::Adaptor::Gradient* New()
+{
+ return Dali::Internal::Adaptor::GradientUbuntu::New();
+}
+
+} // namespace GradientFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/ubuntu/gradient-impl-ubuntu.h>
+
+// EXTERNAL INCLUDES
+#include <dali/devel-api/common/stage.h>
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/type-registry.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace // unnamed namespace
+{
+// Type Registration
+Dali::BaseHandle Create()
+{
+ return Dali::BaseHandle();
+}
+
+Dali::TypeRegistration type(typeid(Dali::CanvasRenderer::Gradient), typeid(Dali::BaseHandle), Create);
+
+} // unnamed namespace
+
+GradientUbuntu* GradientUbuntu::New()
+{
+ return new GradientUbuntu();
+}
+
+GradientUbuntu::GradientUbuntu()
+: mChanged(false)
+#ifdef THORVG_SUPPORT
+ ,
+ mTvgFill(nullptr)
+#endif
+{
+}
+
+GradientUbuntu::~GradientUbuntu()
+{
+#ifdef THORVG_SUPPORT
+ if(mTvgFill)
+ {
+ delete mTvgFill;
+ }
+#endif
+}
+
+bool GradientUbuntu::SetColorStops(Dali::CanvasRenderer::Gradient::ColorStops& colorStops)
+{
+#ifdef THORVG_SUPPORT
+ if(!mTvgFill)
+ {
+ DALI_LOG_ERROR("Fill(Gradient) is null [%p]\n", this);
+ return false;
+ }
+ SetChanged(true);
+
+ tvg::Fill::ColorStop* tvgColorStops = (tvg::Fill::ColorStop*)alloca(sizeof(tvg::Fill::ColorStop) * colorStops.Count());
+
+ for(unsigned int i = 0u; i < colorStops.Count(); ++i)
+ {
+ tvgColorStops[i].offset = colorStops[i].offset;
+ tvgColorStops[i].r = colorStops[i].color.r * 255.0f;
+ tvgColorStops[i].g = colorStops[i].color.g * 255.0f;
+ tvgColorStops[i].b = colorStops[i].color.b * 255.0f;
+ tvgColorStops[i].a = colorStops[i].color.a * 255.0f;
+ }
+
+ if(mTvgFill->colorStops(tvgColorStops, colorStops.Count()) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("SetColorStops() fail.\n");
+ return false;
+ }
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+Dali::CanvasRenderer::Gradient::ColorStops GradientUbuntu::GetColorStops() const
+{
+#ifdef THORVG_SUPPORT
+ if(!mTvgFill)
+ {
+ DALI_LOG_ERROR("Fill(Gradient) is null [%p]\n", this);
+ return Dali::CanvasRenderer::Gradient::ColorStops();
+ }
+
+ const tvg::Fill::ColorStop* tvgColorStops = nullptr;
+ uint32_t count = 0;
+
+ count = mTvgFill->colorStops(&tvgColorStops);
+ if(!tvgColorStops || count <= 0)
+ {
+ DALI_LOG_ERROR("GetColorStops() fail.\n");
+ return Dali::CanvasRenderer::Gradient::ColorStops();
+ }
+
+ Dali::CanvasRenderer::Gradient::ColorStops colorStops;
+
+ colorStops.Reserve(count);
+
+ for(unsigned int i = 0u; i < count; ++i)
+ {
+ Dali::CanvasRenderer::Gradient::ColorStop stop = {tvgColorStops[i].offset, Vector4(tvgColorStops[i].r / 255.0f, tvgColorStops[i].g / 255.0f, tvgColorStops[i].b / 255.0f, tvgColorStops[i].a / 255.0f)};
+
+ colorStops.PushBack(stop);
+ }
+ return colorStops;
+#else
+ return Dali::CanvasRenderer::Gradient::ColorStops();
+#endif
+}
+
+bool GradientUbuntu::SetSpread(Dali::CanvasRenderer::Gradient::Spread spread)
+{
+#ifdef THORVG_SUPPORT
+ if(!mTvgFill)
+ {
+ DALI_LOG_ERROR("Fill(Gradient) is null [%p]\n", this);
+ return false;
+ }
+ if(mTvgFill->spread(static_cast<tvg::FillSpread>(spread)) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("SetSpread() fail.\n");
+ return false;
+ }
+ SetChanged(true);
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+Dali::CanvasRenderer::Gradient::Spread GradientUbuntu::GetSpread() const
+{
+#ifdef THORVG_SUPPORT
+ if(!mTvgFill)
+ {
+ DALI_LOG_ERROR("Fill(Gradient) is null [%p]\n", this);
+ return Dali::CanvasRenderer::Gradient::Spread::PAD;
+ }
+
+ tvg::FillSpread spread = mTvgFill->spread();
+
+ return static_cast<Dali::CanvasRenderer::Gradient::Spread>(spread);
+#else
+ return Dali::CanvasRenderer::Gradient::Spread::PAD;
+#endif
+}
+
+void GradientUbuntu::SetObject(const void* object)
+{
+#ifdef THORVG_SUPPORT
+ if(object)
+ {
+ mTvgFill = static_cast<tvg::Fill*>(const_cast<void*>(object));
+ }
+#endif
+}
+
+void* GradientUbuntu::GetObject() const
+{
+#ifdef THORVG_SUPPORT
+ return static_cast<void*>(mTvgFill);
+#else
+ return nullptr;
+#endif
+}
+
+void GradientUbuntu::SetChanged(bool changed)
+{
+ if(!mChanged && changed) Dali::Stage::GetCurrent().KeepRendering(0.0f);
+ mChanged = !!changed;
+}
+
+bool GradientUbuntu::GetChanged() const
+{
+ return mChanged;
+}
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_UBUNTU_GRADIENT_IMPL_UBUNTU_H
+#define DALI_INTERNAL_UBUNTU_GRADIENT_IMPL_UBUNTU_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#ifdef THORVG_SUPPORT
+#include <thorvg.h>
+#endif
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-gradient.h>
+#include <dali/devel-api/adaptor-framework/canvas-renderer.h>
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+#include <dali/internal/canvas-renderer/ubuntu/canvas-renderer-impl-ubuntu.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal Gradient.
+ */
+class GradientUbuntu : public Dali::Internal::Adaptor::Gradient
+{
+public:
+ /**
+ * @brief Creates a Gradient object.
+ * @return A pointer to a newly allocated Gradient
+ */
+ static GradientUbuntu* New();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::SetColorStops()
+ */
+ bool SetColorStops(Dali::CanvasRenderer::Gradient::ColorStops& colorStops) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::GetColorStops()
+ */
+ Dali::CanvasRenderer::Gradient::ColorStops GetColorStops() const override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::SetSpread()
+ */
+ bool SetSpread(Dali::CanvasRenderer::Gradient::Spread spread) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Gradient::GetSpread()
+ */
+ Dali::CanvasRenderer::Gradient::Spread GetSpread() const override;
+
+ /**
+ * @copydoc Internal::Adaptor::Gradient::GetObject()
+ */
+ void SetObject(const void* object) override;
+
+ /**
+ * @copydoc Internal::Adaptor::Gradient::SetObject()
+ */
+ void* GetObject() const override;
+
+ /**
+ * @copydoc Internal::Adaptor::Gradient::SetChanged()
+ */
+ void SetChanged(bool changed) override;
+
+ /**
+ * @copydoc Internal::Adaptor::Gradient::GetChanged()
+ */
+ bool GetChanged() const override;
+
+ GradientUbuntu(const Gradient&) = delete;
+ GradientUbuntu& operator=(Gradient&) = delete;
+ GradientUbuntu(Gradient&&) = delete;
+ GradientUbuntu& operator=(Gradient&&) = delete;
+
+protected:
+ /**
+ * @brief Constructor
+ */
+ GradientUbuntu();
+
+ /**
+ * @brief Destructor.
+ */
+ virtual ~GradientUbuntu() override;
+
+private:
+ bool mChanged;
+#ifdef THORVG_SUPPORT
+ tvg::Fill* mTvgFill;
+#endif
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_UBUNTU_GRADIENT_IMPL_UBUNTU_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/internal/canvas-renderer/ubuntu/linear-gradient-impl-ubuntu.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace LinearGradientFactory
+{
+Dali::Internal::Adaptor::LinearGradient* New()
+{
+ return Dali::Internal::Adaptor::LinearGradientUbuntu::New();
+}
+
+} // namespace LinearGradientFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/ubuntu/linear-gradient-impl-ubuntu.h>
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/type-registry.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace // unnamed namespace
+{
+// Type Registration
+Dali::BaseHandle Create()
+{
+ return Dali::BaseHandle();
+}
+
+Dali::TypeRegistration type(typeid(Dali::CanvasRenderer::LinearGradient), typeid(Dali::BaseHandle), Create);
+
+} // unnamed namespace
+
+LinearGradientUbuntu* LinearGradientUbuntu::New()
+{
+ return new LinearGradientUbuntu();
+}
+
+LinearGradientUbuntu::LinearGradientUbuntu()
+#ifdef THORVG_SUPPORT
+: mTvgLinearGradient(nullptr)
+#endif
+{
+ Initialize();
+}
+
+LinearGradientUbuntu::~LinearGradientUbuntu()
+{
+}
+
+void LinearGradientUbuntu::Initialize()
+{
+#ifdef THORVG_SUPPORT
+ mTvgLinearGradient = tvg::LinearGradient::gen().release();
+ if(!mTvgLinearGradient)
+ {
+ DALI_LOG_ERROR("LinearGradient is null [%p]\n", this);
+ }
+
+ Gradient::Create();
+ Gradient::SetObject(static_cast<void*>(mTvgLinearGradient));
+#endif
+}
+
+bool LinearGradientUbuntu::SetBounds(Vector2 firstPoint, Vector2 secondPoint)
+{
+#ifdef THORVG_SUPPORT
+ if(!Gradient::GetObject() || !mTvgLinearGradient)
+ {
+ DALI_LOG_ERROR("LinearGradient is null\n");
+ return false;
+ }
+
+ if(mTvgLinearGradient->linear(firstPoint.x, firstPoint.y, secondPoint.x, secondPoint.y) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("SetBounds() fail.\n");
+ return false;
+ }
+
+ Gradient::SetChanged(true);
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool LinearGradientUbuntu::GetBounds(Vector2& firstPoint, Vector2& secondPoint) const
+{
+#ifdef THORVG_SUPPORT
+ if(!Gradient::GetObject() || !mTvgLinearGradient)
+ {
+ DALI_LOG_ERROR("LinearGradient is null\n");
+ return false;
+ }
+
+ if(mTvgLinearGradient->linear(&firstPoint.x, &firstPoint.y, &secondPoint.x, &secondPoint.y) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("GetBounds() fail.\n");
+ return false;
+ }
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_UBUNTU_LINEAR_GRADIENT_IMPL_UBUNTU_H
+#define DALI_INTERNAL_UBUNTU_LINEAR_GRADIENT_IMPL_UBUNTU_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#ifdef THORVG_SUPPORT
+#include <thorvg.h>
+#endif
+#include <dali/public-api/object/base-object.h>
+#include <dali/public-api/object/weak-handle.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-linear-gradient.h>
+#include <dali/internal/canvas-renderer/common/linear-gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal LinearGradient.
+ */
+class LinearGradientUbuntu : public Dali::Internal::Adaptor::LinearGradient
+{
+public:
+ /**
+ * @brief Creates a LinearGradient object.
+ * @return A pointer to a newly allocated drawablegroup
+ */
+ static LinearGradientUbuntu* New();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::LinearGradient::SetBounds()
+ */
+ bool SetBounds(Vector2 firstPoint, Vector2 secondPoint) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::LinearGradient::SetBounds()
+ */
+ bool GetBounds(Vector2& firstPoint, Vector2& secondPoint) const override;
+
+private:
+ LinearGradientUbuntu(const LinearGradientUbuntu&) = delete;
+ LinearGradientUbuntu& operator=(LinearGradientUbuntu&) = delete;
+ LinearGradientUbuntu(LinearGradientUbuntu&&) = delete;
+ LinearGradientUbuntu& operator=(LinearGradientUbuntu&&) = delete;
+
+ /**
+ * @brief Constructor
+ */
+ LinearGradientUbuntu();
+
+ /**
+ * @brief Destructor.
+ */
+ virtual ~LinearGradientUbuntu() override;
+
+private:
+ /**
+ * @brief Initializes member data.
+ */
+ void Initialize();
+
+private:
+#ifdef THORVG_SUPPORT
+ tvg::LinearGradient* mTvgLinearGradient;
+#endif
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_UBUNTU_LINEAR_GRADIENT_IMPL_UBUNTU_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/internal/canvas-renderer/ubuntu/picture-impl-ubuntu.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace PictureFactory
+{
+Dali::Internal::Adaptor::Picture* New()
+{
+ return Dali::Internal::Adaptor::PictureUbuntu::New();
+}
+
+} // namespace PictureFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/ubuntu/picture-impl-ubuntu.h>
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/type-registry.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace // unnamed namespace
+{
+// Type Registration
+Dali::BaseHandle Create()
+{
+ return Dali::BaseHandle();
+}
+
+Dali::TypeRegistration type(typeid(Dali::CanvasRenderer::Picture), typeid(Dali::BaseHandle), Create);
+
+} // unnamed namespace
+
+PictureUbuntu* PictureUbuntu::New()
+{
+ return new PictureUbuntu();
+}
+
+PictureUbuntu::PictureUbuntu()
+#ifdef THORVG_SUPPORT
+: mTvgPicture(nullptr)
+#endif
+{
+ Initialize();
+}
+
+PictureUbuntu::~PictureUbuntu()
+{
+}
+
+void PictureUbuntu::Initialize()
+{
+#ifdef THORVG_SUPPORT
+ mTvgPicture = tvg::Picture::gen().release();
+ if(!mTvgPicture)
+ {
+ DALI_LOG_ERROR("Picture is null [%p]\n", this);
+ }
+
+ Drawable::Create();
+ Drawable::SetObject(static_cast<void*>(mTvgPicture));
+ Drawable::SetType(Drawable::Types::PICTURE);
+#endif
+}
+
+bool PictureUbuntu::Load(const std::string& url)
+{
+#ifdef THORVG_SUPPORT
+ if(!Drawable::GetObject() || !mTvgPicture)
+ {
+ DALI_LOG_ERROR("Picture is null [%p]\n", this);
+ return false;
+ }
+ if(url.empty())
+ {
+ DALI_LOG_ERROR("Url is empty [%p]\n", this);
+ return false;
+ }
+
+ if(mTvgPicture->load(url.c_str()) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("Load() fail. (%s)\n", url.c_str());
+ return false;
+ }
+
+ Drawable::SetChanged(true);
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool PictureUbuntu::SetSize(Vector2 size)
+{
+#ifdef THORVG_SUPPORT
+ if(!Drawable::GetObject() || !mTvgPicture)
+ {
+ DALI_LOG_ERROR("Picture is null [%p]\n", this);
+ return false;
+ }
+ if(mTvgPicture->size(size.width, size.height) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("SetSize() fail.\n");
+ return false;
+ }
+ Drawable::SetChanged(true);
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+Vector2 PictureUbuntu::GetSize() const
+{
+#ifdef THORVG_SUPPORT
+ if(!Drawable::GetObject() || !mTvgPicture)
+ {
+ DALI_LOG_ERROR("Picture is null [%p]\n", this);
+ return Vector2::ZERO;
+ }
+
+ auto width = 0.0f;
+ auto height = 0.0f;
+
+ if(mTvgPicture->size(&width, &height) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("GetSize() fail.\n");
+ return Vector2::ZERO;
+ }
+
+ return Vector2(width, height);
+#else
+ return Vector2::ZERO;
+#endif
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_UBUNTU_PICTURE_IMPL_UBUNTU_H
+#define DALI_INTERNAL_UBUNTU_PICTURE_IMPL_UBUNTU_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#ifdef THORVG_SUPPORT
+#include <thorvg.h>
+#endif
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-picture.h>
+#include <dali/internal/canvas-renderer/common/picture-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal Picture.
+ */
+class PictureUbuntu : public Dali::Internal::Adaptor::Picture
+{
+public:
+ /**
+ * @brief Creates a Picture object.
+ * @return A pointer to a newly allocated picture
+ */
+ static PictureUbuntu* New();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Picture::Load()
+ */
+ bool Load(const std::string& url) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Picture::SetSize()
+ */
+ bool SetSize(Vector2 size) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Picture::GetSize()
+ */
+ Vector2 GetSize() const override;
+
+private:
+ PictureUbuntu(const PictureUbuntu&) = delete;
+ PictureUbuntu& operator=(PictureUbuntu&) = delete;
+ PictureUbuntu(PictureUbuntu&&) = delete;
+ PictureUbuntu& operator=(PictureUbuntu&&) = delete;
+
+ /**
+ * @brief Constructor
+ */
+ PictureUbuntu();
+
+ /**
+ * @brief Destructor.
+ */
+ ~PictureUbuntu() override;
+
+private:
+ /**
+ * @brief Initializes member data.
+ */
+ void Initialize();
+
+private:
+#ifdef THORVG_SUPPORT
+ tvg::Picture* mTvgPicture;
+#endif
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_UBUNTU_PICTURE_IMPL_UBUNTU_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/internal/canvas-renderer/ubuntu/radial-gradient-impl-ubuntu.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace RadialGradientFactory
+{
+Dali::Internal::Adaptor::RadialGradient* New()
+{
+ return Dali::Internal::Adaptor::RadialGradientUbuntu::New();
+}
+
+} // namespace RadialGradientFactory
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/canvas-renderer/ubuntu/radial-gradient-impl-ubuntu.h>
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/type-registry.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace // unnamed namespace
+{
+// Type Registration
+Dali::BaseHandle Create()
+{
+ return Dali::BaseHandle();
+}
+
+Dali::TypeRegistration type(typeid(Dali::CanvasRenderer::RadialGradient), typeid(Dali::BaseHandle), Create);
+
+} // unnamed namespace
+
+RadialGradientUbuntu* RadialGradientUbuntu::New()
+{
+ return new RadialGradientUbuntu();
+}
+
+RadialGradientUbuntu::RadialGradientUbuntu()
+#ifdef THORVG_SUPPORT
+: mTvgRadialGradient(nullptr)
+#endif
+{
+ Initialize();
+}
+
+RadialGradientUbuntu::~RadialGradientUbuntu()
+{
+}
+
+void RadialGradientUbuntu::Initialize()
+{
+#ifdef THORVG_SUPPORT
+ mTvgRadialGradient = tvg::RadialGradient::gen().release();
+ if(!mTvgRadialGradient)
+ {
+ DALI_LOG_ERROR("RadialGradient is null [%p]\n", this);
+ }
+
+ Gradient::Create();
+ Gradient::SetObject(static_cast<void*>(mTvgRadialGradient));
+#endif
+}
+
+bool RadialGradientUbuntu::SetBounds(Vector2 centerPoint, float radius)
+{
+#ifdef THORVG_SUPPORT
+ if(!Gradient::GetObject() || !mTvgRadialGradient)
+ {
+ DALI_LOG_ERROR("RadialGradient is null\n");
+ return false;
+ }
+
+ if(mTvgRadialGradient->radial(centerPoint.x, centerPoint.y, radius) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("SetBounds() fail.\n");
+ return false;
+ }
+
+ Gradient::SetChanged(true);
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool RadialGradientUbuntu::GetBounds(Vector2& centerPoint, float& radius) const
+{
+#ifdef THORVG_SUPPORT
+ if(!Gradient::GetObject() || !mTvgRadialGradient)
+ {
+ DALI_LOG_ERROR("RadialGradient is null\n");
+ return false;
+ }
+
+ if(mTvgRadialGradient->radial(¢erPoint.x, ¢erPoint.y, &radius) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("GetBounds() fail.\n");
+ return false;
+ }
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_UBUNTU_RADIAL_GRADIENT_IMPL_UBUNTU_H
+#define DALI_INTERNAL_UBUNTU_RADIAL_GRADIENT_IMPL_UBUNTU_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#ifdef THORVG_SUPPORT
+#include <thorvg.h>
+#endif
+#include <dali/public-api/object/base-object.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/canvas-renderer-radial-gradient.h>
+#include <dali/internal/canvas-renderer/common/radial-gradient-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * Dali internal RadialGradient.
+ */
+class RadialGradientUbuntu : public Dali::Internal::Adaptor::RadialGradient
+{
+public:
+ /**
+ * @brief Creates a RadialGradient object.
+ * @return A pointer to a newly allocated drawablegroup
+ */
+ static RadialGradientUbuntu* New();
+
+ /**
+ * @copydoc Dali::CanvasRenderer::RadialGradient::SetBounds()
+ */
+ bool SetBounds(Vector2 centerPoint, float radius) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::RadialGradient::SetBounds()
+ */
+ bool GetBounds(Vector2& centerPoint, float& radius) const override;
+
+private:
+ RadialGradientUbuntu(const RadialGradientUbuntu&) = delete;
+ RadialGradientUbuntu& operator=(RadialGradientUbuntu&) = delete;
+ RadialGradientUbuntu(RadialGradientUbuntu&&) = delete;
+ RadialGradientUbuntu& operator=(RadialGradientUbuntu&&) = delete;
+
+ /**
+ * @brief Constructor
+ */
+ RadialGradientUbuntu();
+
+ /**
+ * @brief Destructor.
+ */
+ virtual ~RadialGradientUbuntu() override;
+
+private:
+ /**
+ * @brief Initializes member data.
+ */
+ void Initialize();
+
+private:
+#ifdef THORVG_SUPPORT
+ tvg::RadialGradient* mTvgRadialGradient;
+#endif
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_UBUNTU_RADIAL_GRADIENT_IMPL_UBUNTU_H
}
ShapeUbuntu::ShapeUbuntu()
+: mFillGradient(),
+ mStrokeGradient()
#ifdef THORVG_SUPPORT
-: mTvgShape(nullptr)
+ ,
+ mTvgShape(nullptr)
#endif
{
Initialize();
#endif
}
+bool ShapeUbuntu::AddPath(Dali::CanvasRenderer::Shape::PathCommands& pathCommand)
+{
+#ifdef THORVG_SUPPORT
+ if(!Drawable::GetObject() || !mTvgShape)
+ {
+ DALI_LOG_ERROR("Shape is null\n");
+ return false;
+ }
+
+ if(static_cast<tvg::Shape*>(mTvgShape)->appendPath(reinterpret_cast<const tvg::PathCommand*>(pathCommand.mCommands), pathCommand.mCommandCount, static_cast<const tvg::Point*>(static_cast<void*>(pathCommand.mPoints)), pathCommand.mPointCount) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("AddPath() fail.\n");
+ return false;
+ }
+ Drawable::SetChanged(true);
+ return true;
+#else
+ return false;
+#endif
+}
+
bool ShapeUbuntu::Close()
{
#ifdef THORVG_SUPPORT
#endif
}
+bool ShapeUbuntu::SetFillGradient(Dali::CanvasRenderer::Gradient& gradient)
+{
+#ifdef THORVG_SUPPORT
+ if(!Drawable::GetObject() || !mTvgShape)
+ {
+ DALI_LOG_ERROR("Shape is null [%p]\n", this);
+ return false;
+ }
+ mFillGradient = gradient;
+ Drawable::SetChanged(true);
+ return true;
+#else
+ return false;
+#endif
+}
+
+Dali::CanvasRenderer::Gradient ShapeUbuntu::GetFillGradient() const
+{
+ return mFillGradient;
+}
+
bool ShapeUbuntu::SetFillRule(Dali::CanvasRenderer::Shape::FillRule rule)
{
#ifdef THORVG_SUPPORT
#endif
}
+bool ShapeUbuntu::SetStrokeGradient(Dali::CanvasRenderer::Gradient& gradient)
+{
+#ifdef THORVG_SUPPORT
+ if(!Drawable::GetObject() || !mTvgShape)
+ {
+ DALI_LOG_ERROR("Shape is null [%p]\n", this);
+ return false;
+ }
+ mStrokeGradient = gradient;
+ Drawable::SetChanged(true);
+ return true;
+#else
+ return false;
+#endif
+}
+
+Dali::CanvasRenderer::Gradient ShapeUbuntu::GetStrokeGradient() const
+{
+ return mStrokeGradient;
+}
+
bool ShapeUbuntu::SetStrokeDash(const Dali::Vector<float> dashPattern)
{
#ifdef THORVG_SUPPORT
bool AddCubicTo(Vector2 controlPoint1, Vector2 controlPoint2, Vector2 endPoint) override;
/**
+ * @copydoc Dali::CanvasRenderer::Shape::AddPath()
+ */
+ bool AddPath(Dali::CanvasRenderer::Shape::PathCommands& pathCommand) override;
+
+ /**
* @copydoc Dali::CanvasRenderer::Shape::Close()
*/
bool Close() override;
Vector4 GetFillColor() const override;
/**
+ * @copydoc Dali::CanvasRenderer::Shape::SetFillGradient()
+ */
+ bool SetFillGradient(Dali::CanvasRenderer::Gradient& gradient) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Shape::GetFillGradient()
+ */
+ Dali::CanvasRenderer::Gradient GetFillGradient() const override;
+
+ /**
* @copydoc Dali::CanvasRenderer::Shape::SetFillRule()
*/
bool SetFillRule(Dali::CanvasRenderer::Shape::FillRule rule) override;
Vector4 GetStrokeColor() const override;
/**
+ * @copydoc Dali::CanvasRenderer::Shape::SetStrokeGradient()
+ */
+ bool SetStrokeGradient(Dali::CanvasRenderer::Gradient& gradient) override;
+
+ /**
+ * @copydoc Dali::CanvasRenderer::Shape::GetStrokeGradient()
+ */
+ Dali::CanvasRenderer::Gradient GetStrokeGradient() const override;
+
+ /**
* @copydoc Dali::CanvasRenderer::Shape::SetStrokeDash()
*/
bool SetStrokeDash(const Dali::Vector<float> dashPattern) override;
*/
void Initialize();
-#ifdef THORVG_SUPPORT
private:
+ Dali::CanvasRenderer::Gradient mFillGradient;
+ Dali::CanvasRenderer::Gradient mStrokeGradient;
+#ifdef THORVG_SUPPORT
tvg::Shape* mTvgShape;
#endif
};
*/
unsigned int Clipboard::NumberOfItems()
{
- return mImpl->GetCount();
+ int count = mImpl->GetCount();
+ return (count < 0 ? 0 : count);
}
void Clipboard::ShowClipboard()
{
if(mAdaptor)
{
- auto bridge = Accessibility::Bridge::GetCurrentBridge();
- auto rootLayer = mScene.GetRootLayer();
- auto accessible = Accessibility::Accessible::Get(rootLayer);
+ auto bridge = Accessibility::Bridge::GetCurrentBridge();
+ auto rootLayer = mScene.GetRootLayer();
+ auto accessible = Accessibility::Accessible::Get(rootLayer);
bridge->RemoveTopLevelWindow(accessible);
mAdaptor->RemoveWindow(this);
if(!mIconified)
{
- WindowVisibilityObserver* observer(mAdaptor);
- observer->OnWindowShown();
-
Dali::Window handle(this);
mVisibilityChangedSignal.Emit(handle, true);
+
+ WindowVisibilityObserver* observer(mAdaptor);
+ observer->OnWindowShown();
}
mSurface->SetFullSwapNextFrame();
if(!mIconified)
{
- WindowVisibilityObserver* observer(mAdaptor);
- observer->OnWindowHidden();
-
Dali::Window handle(this);
mVisibilityChangedSignal.Emit(handle, false);
+
+ WindowVisibilityObserver* observer(mAdaptor);
+ observer->OnWindowHidden();
}
DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Hide(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible);
if(mVisible)
{
- WindowVisibilityObserver* observer(mAdaptor);
- observer->OnWindowHidden();
-
Dali::Window handle(this);
mVisibilityChangedSignal.Emit(handle, false);
+
+ WindowVisibilityObserver* observer(mAdaptor);
+ observer->OnWindowHidden();
}
DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Iconified: visible = %d\n", this, mNativeWindowId, mVisible);
if(mVisible)
{
- WindowVisibilityObserver* observer(mAdaptor);
- observer->OnWindowShown();
-
Dali::Window handle(this);
mVisibilityChangedSignal.Emit(handle, true);
+
+ WindowVisibilityObserver* observer(mAdaptor);
+ observer->OnWindowShown();
}
DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Deiconified: visible = %d\n", this, mNativeWindowId, mVisible);
{
const unsigned int ADAPTOR_MAJOR_VERSION = 2;
const unsigned int ADAPTOR_MINOR_VERSION = 0;
-const unsigned int ADAPTOR_MICRO_VERSION = 39;
+const unsigned int ADAPTOR_MICRO_VERSION = 40;
const char* const ADAPTOR_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali2-adaptor
Summary: The DALi Tizen Adaptor
-Version: 2.0.39
+Version: 2.0.40
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT