}
/**
- * @DEPRECATED_1_1.11
+ * @DEPRECATED_1_1.11 Use an actor with renderer instead.
* @brief An actor for displaying images.
*
* Allows the developer to add an actor to stage which displays the content of an Image object.
*
* @SINCE_1_0.0
* @remarks This is an experimental feature and might not be supported in the next release. We do recommend not to use it. Use of ImageActor should be avoided unless shader effects need to be applied.
- * For general purpose, use Toolkit::ImageView which has much better performance.
- * @see Toolkit::ImageView
*/
class DALI_IMPORT_API ImageActor : public Actor
{
};
/**
- * @DEPRECATED_1_1.11. Only quad style supported, use ImageView instead for nine patch.
+ * @DEPRECATED_1_1.11. Only quad style supported.
*
* @brief Style determines how the Image is rendered.
*
PixelArea GetPixelArea() const;
/**
- * @DEPRECATED_1_1.11. Use ImageView instead.
+ * @DEPRECATED_1_1.11
*
* @brief Set how the image is rendered; the default is STYLE_QUAD.
*
void SetStyle(Style style);
/**
- * @DEPRECATED_1_1.11. Use ImageView instead.
+ * @DEPRECATED_1_1.11
*
* @brief Query how the image is rendered.
*
Style GetStyle() const;
/**
- * @DEPRECATED_1_1.11. Use ImageView instead.
+ * @DEPRECATED_1_1.11
*
* @brief Set the border used with ImageActor::STYLE_NINE_PATCH.
*
void SetNinePatchBorder(const Vector4& border);
/**
- * @DEPRECATED_1_1.11. Use ImageView instead.
+ * @DEPRECATED_1_1.11
*
* @brief Retrieve the border used with ImageActor::STYLE_NINE_PATCH.
*
*
* For the following actor tree of the Layer1 object, D and E hide B, B and C hides A,
* and F hides C, regardless of their Z positions.
- * Rendering order between siblings, such as D & E or B & C, is not determined.
+ * Rendering order between siblings, such as D & E or B & C, is determined based on the depth index.
* If you have two overlapped actors, just make them parent-child, not siblings.
*
* @code
* Unlike LAYER_2D, parent-child relationship does not affect rendering order at all.
*
* @SINCE_1_0.0
- * @remarks This is an experimental feature. Using 2D UI components of DALi Toolkit
- * in LAYER_3D mode has not been enoughly tested yet
- * because they are orginally designed for 2D use cases.
- * Simple controls such as Toolkit::Control or Toolkit::ImageView might not have any problem with LAYER_3D,
- * but more complex one like Toolkit::PushButton, you might get unexpected rendered order in LAYER_3D.
- * Although we'll support 2D controls in LAYER_3D soon, we recommend to use 2D controls with LAYER_2D only at this moment.
- * Of course, controls rendered in 3D space, such as SpiralLayout of Toolkit::ItemView
- * (see Toolkit::DefaultItemLayout::New), should be used with LAYER_3D.
*/
LAYER_3D,
};
/**
- * @brief BufferImage represents an image resource that can be added to ImageViews.
+ * @brief BufferImage represents an image resource as a pixel data buffer.
*
* Its pixel buffer data is provided by the application developer.
*
- * Care should be taken with pixel data allocated by the application,
- * as the data is copied to GL both when the image is added to the
- * stage and after a call to Update(). In both of these cases, a
- * Image::UploadedSignal will be sent to the application confirming that the
- * operation has completed.
- *
- * The application can free the pixel data after receiving a
- * Image::UploadedSignal.
- *
- * Similarly, once the image is on stage (i.e. it's being used by an
- * ImageView that is on stage), the application should only write to
- * the buffer after receiving a Image::UploadedSignal, then call Update()
- * once the write is finished. This avoids the pixel data being changed
- * whilst it's being copied to GL. Writing to the buffer without waiting
- * for the signal will likely result in visible tearing.
- *
* If the pixel format of the pixel buffer contains an alpha channel,
* then the image is considered to be have transparent pixels without
* regard for the actual content of the channel, and will be blended.
/**
- * @brief EncodedBufferImage represents an image resource that can be added to
- * ImageViews.
+ * @brief EncodedBufferImage represents an image resource as a buffer of encoded pixel data.
*
* A memory buffer of encoded image data is provided by the application and
* decoded asynchronously on a background thread to fill the image's
}
/**
- * @brief FrameBufferImage represents a GLES Frame Buffer Object and contains the result
+ * @brief FrameBufferImage represents an Open GL ES Frame Buffer Object and contains the result
* of an 'off screen' render pass of a RenderTask.
*
- * The FrameBufferImage can then be used with an @ref Dali::Toolkit::ImageView (with optional shader
- * effects) and rendered to the screen.
+ * The FrameBufferImage can then be used for rendering to the screen.
* @SINCE_1_0.0
*/
class DALI_IMPORT_API FrameBufferImage : public Image
}
/**
- * @brief An Image object represents an image resource that can be added to ImageViews.
+ * @brief An Image object represents an image resource that can be used for rendering.
*
- * Image objects can be shared between ImageViews. This is practical if you have a visual element on screen
- * which is repeatedly used. An example would be a button background image.
- * The image resource is discarded when all ImageViews using the Image object are discarded.
+ * Image objects can be shared between Actors. This is practical if you have a visual element on screen
+ * which is repeatedly used.
+ *
+ * The image resource is released as soon as the last Image handle is released.
* @SINCE_1_0.0
* @note If a resource was shared between Image objects it exists until its last reference is gone.
*
class DALI_IMPORT_API Image : public BaseHandle
{
public:
- /**
- * @brief Resource management options.
- */
/**
* @DEPRECATED_1_1.3. Image resource is released as soon as last handle is released.
virtual unsigned int TargetTexture() = 0;
/**
- * @brief Called in internal each NativeTexture::Bind() call to allow implementation specific operations.
+ * @brief Called internally for each Bind call for this texture to allow implementation specific operations.
*
* The correct texture sampler has already been bound before the function gets called.
* @SINCE_1_0.0
}
/**
- * @brief NativeImage represents an image resource that can be added to ImageViews.
+ * @brief NativeImage represents a platform specific image resource.
*
- * Its data is provided by native resources, such as shared bitmap memory or pixmap from X11 or ECORE-X11, etc.
+ * Its data is provided by native resources, such as shared bitmap memory or pixmap.
* @SINCE_1_0.0
*/
class DALI_IMPORT_API NativeImage : public Image
* @SINCE_1_0.0
* @param [in] filename File to load synchronously into buffer
* @return A handle to a new instance of NinePatchImage
- * @note Default resource management policies are Immediate and Never
- *
*/
static NinePatchImage New( const std::string& filename );
/**
* @brief ResourceImage is an image loaded using a URL
*
- * <h3>ResourceImage Loading</h3>
- *
- * When the ResourceImage is created, resource loading will be attempted unless
- * the ResourceImage is created with ResourceImage::IMMEDIATE loading policy or a compatible resource is found in cache.
- * In case of loading images ResourceImage::ON_DEMAND, resource loading will only be attempted if the associated Dali::Toolkit::ImageView
- * is put on Stage.
- * Scaling of images to a desired smaller size can be requested by providing desired dimensions,
- * scaling mode and filter mode to to ResourceImage::New().
- *
- * <i>Custom load requests</i>
+ * <i>Customizing load requests</i>
*
* Size, scaling mode, filter mode, and orientation compensation can be set when requesting an image.
*
- * <i>Compatible resources</i>
- *
- * Before loading a new ResourceImage the internal image resource cache is checked by DALi.
- * If there is an image already loaded in memory and is deemed "compatible" with the requested image,
- * that resource is reused.
- * This happens for example if a loaded image exists with the same URL, scaling and filtering modes,
- * and the difference between both of the dimensions is less than a few pixels.
- *
* <i>Reloading images</i>
*
* The same request used on creating the ResourceImage is re-issued when reloading images.
* If the file changed since the last load operation, this might result in a different resource.
- * Reload only takes effect if both of these conditions apply:
- * - The ResourceImage has already finished loading
- * - The ResourceImage is either on Stage or using ResourceImage::IMMEDIATE load policy
+ * Reload only takes effect if the ResourceImage has already finished loading.
*
* Signals
* | %Signal Name | Method |
class DALI_IMPORT_API ResourceImage : public Image
{
public:
- /**
- * @brief Resource management options.
- */
/**
* @DEPRECATED_1_1.3. Image loading starts immediately in the frame when then ResourceImage object is created.
projects / platform / core / uifw / dali-core.git / commitdiff