Enable -Wnon-virtual-dtor to avoid incorrect C++ code sneaking in

[platform/core/uifw/dali-core.git] / dali / integration-api / bitmap.h

diff --git a/dali/integration-api/bitmap.h b/dali/integration-api/bitmap.h
index f4b4472..1e1b9bc 100644 (file)
--- a/dali/integration-api/bitmap.h
+++ b/dali/integration-api/bitmap.h
@@ -25,6 +25,7 @@
 #include <dali/public-api/common/intrusive-ptr.h>
 #include <dali/public-api/images/pixel.h>
 #include <dali/public-api/object/ref-object.h>
+#include <dali/integration-api/resource-policies.h>
 
 namespace Dali
 {
@@ -47,19 +48,18 @@ typedef unsigned char                 PixelBuffer;  ///< Pixel data buffers are
 /**
  * Bitmap class.
  * An abstract container for image data.
- * \sa{BitmapPackedPixel BitmapCompressed BitmapExternal} for concrete
- * subclasses.
  */
 class DALI_IMPORT_API Bitmap : public Dali::RefObject
 {
 protected:
+
   /**
    * Constructor
-   * Use the static function Bitmap::Create() to create instances.
+   * Use the static function Bitmap::New() to create instances.
    * @param[in] discardable Flag to tell the bitmap if it can delete the buffer with the pixel data.
    * @param[in] pixBuf External buffer of pixel data or null.
    */
-  Bitmap( bool discardable = false, Dali::Integration::PixelBuffer* pixBuf = 0 );
+  Bitmap( ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_RETAIN, Dali::Integration::PixelBuffer* pixBuf = 0 );
 
   /**
    * Initializes internal class members
@@ -86,18 +86,24 @@ public:
     BITMAP_COMPRESSED
   };
 
+  enum ReleaseFunction
+  {
+    FREE,          ///< Use free function to release the buffer
+    DELETE_ARRAY,  ///< Use delete[] operator to release the buffer
+  };
+
   /**
-   * Create a new instance of a Bitmap with the profile asked for.
+   * Create a new instance of a Bitmap with the required profile.
    * @return Pointer to created Bitmap subclass. Clients should immediately
    * wrap this in a reference-counting smart pointer or store it in a similarly
    * automatic owning collection.
    * @param[in] profile Defines required features of the bitmap (\sa Profile).
-   * @param[in] managePixelBuffer If true, the bitmap object owns it's own
-   * buffer of pixel data and can delete it, else the lifetime of the pixel
-   * buffer is managed by an external component and is guaranteed to remain
-   * dereferenceable at least as long as the Bitmap remains alive.
-   **/
-  static Bitmap* New(Profile profile, bool managePixelBuffer);
+   * @param[in] discardable OWNED_DISCARD means that the data is owned by bitmap,
+   * and may released away after uploading to GPU.
+   * OWNED_RETAIN means that the data is owned and must be kept in CPU memory
+   * e.g. for an image that cannot be reloaded from disk.
+   */
+  static Bitmap* New( Profile profile, ResourcePolicy::Discardable discardable );
 
   /** \name GeneralFeatures
    * Features that are generic between profiles. */
@@ -131,17 +137,24 @@ public:
   }
 
   /**
-   * Get the pixel buffer
-   * @return The buffer. You can modify its contents.
+   * Get the pixel buffer if it's present.
+   * @return The buffer if present, or NULL if there is no pixel buffer.
+   * You can modify its contents.
    * @sa ReserveBuffer GetBufferSize
    */
   virtual PixelBuffer* GetBuffer()
   {
-    DALI_ASSERT_DEBUG(mData != NULL);
     return mData;
   }
 
   /**
+   * Get the pixel buffer if it's present and take over the ownership.
+   * @note With this function called, the bitmap loses the ownership and is no longer responsible for the release of pixel buffer.
+   * @return The raw pointer pointing to the pixel buffer
+   */
+  PixelBuffer* GetBufferOwnership();
+
+  /**
    * Get the pixel buffer size in bytes
    * @return The buffer size in bytes.
    * @sa ReserveBuffer GetBuffer
@@ -167,6 +180,12 @@ public:
     return !(HasAlphaChannel() && mAlphaChannelUsed);
   }
 
+  /**
+   * Returns which release function has to be called to release the data in the bitmap
+   * @return FREE if memory has been allocated with malloc DELETE_ARRAY if memory has been allocated with new
+   */
+  virtual ReleaseFunction GetReleaseFunction() = 0;
+
   /**@}*/ ///< End of generic features
 
 
@@ -248,6 +267,13 @@ public:
      * This property can then be tested for with IsFullyOpaque().
      */
     virtual void TestForTransparency() = 0;
+
+  protected:
+
+    /**
+     * Virtual destructor, no deletion through this interface
+     */
+    virtual ~PackedPixelsProfile() {}
   };
 
   /**
@@ -285,6 +311,12 @@ public:
                                        const unsigned width,
                                        const unsigned height,
                                        const size_t numBytes ) = 0;
+  protected:
+
+    /**
+     * Virtual destructor, no deletion through this interface
+     */
+    virtual ~CompressedProfile() {}
   };
 
   virtual const CompressedProfile* GetCompressedProfile() const { return 0; }
@@ -304,20 +336,16 @@ public:
    */
   bool IsDiscardable() const
   {
-    return mDiscardable;
+    return mDiscardable == ResourcePolicy::OWNED_DISCARD;
   }
 
- /**
-   * Transfer ownership of the pixel buffer to the calling function.
-   * @post bitmaps pixel data is set to NULL
-   * @return the bitmaps pixel buffer
-   */
-  PixelBuffer* ReleaseBuffer();
   /**
    * Delete the pixel buffer data
    */
   void DeletePixelBuffer();
 
+protected:
+
   /**
    * A reference counted object may only be deleted by calling Unreference()
    */
@@ -334,7 +362,7 @@ protected:
 
 private:
 
-  bool mDiscardable; ///< Should delete the buffer when discard buffer is called.
+  ResourcePolicy::Discardable mDiscardable; ///< Should delete the buffer when discard buffer is called.
 
   Bitmap(const Bitmap& other);  ///< defined private to prevent use
   Bitmap& operator = (const Bitmap& other); ///< defined private to prevent use