dali-extension/devel-api/capture/capture.h

   1 #ifndef __DALI_EXTENSION_CAPTURE_H__
   2 #define __DALI_EXTENSION_CAPTURE_H__
   3
   4 /*
   5  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 /**
  22  * @addtogroup CAPI_DALI_EXTENSION_FRAMEWORK_MODULE
  23  * @{
  24  */
  25
  26 // EXTERNAL HEADERS
  27 #include <dali/dali.h>
  28
  29 // INTERNAL HEADERS
  30
  31 namespace Dali
  32 {
  33
  34 namespace Extension
  35 {
  36
  37 namespace Internal
  38 {
  39 class Capture;
  40 }
  41
  42 /**
  43  * @brief Capture snapshots the current scene and save as a file.
  44  *
  45  * Applications should follow the example below to create capture :
  46  *
  47  * @code
  48  * Capture capture = Capture::New();
  49  * @endcode
  50  *
  51  * If required, you can also connect class member function to a signal :
  52  *
  53  * @code
  54  * capture.FinishedSignal().Connect(this, &CaptureSceneExample::OnCaptureFinished);
  55  * @endcode
  56  *
  57  * At the connected class member function, you can know whether capture finish state.
  58  *
  59  * @code
  60  * void CaptureSceneExample::OnCaptureFinished(Capture capture)
  61  * {
  62  *   if (capture.GetFinishState() == Capture::SUCCESSED)
  63  *   {
  64  *     // Do something
  65  *   }
  66  *   else
  67  *   {
  68  *     // Do something
  69  *   }
  70  * }
  71  * @endcode
  72  */
  73 class DALI_IMPORT_API Capture : public BaseHandle
  74 {
  75 public:
  76   enum FinishState
  77   {
  78     SUCCESSED,
  79     FAILED
  80   };
  81
  82   /**
  83    * @brief Typedef for signals sent by this class.
  84    */
  85   typedef Signal< void (Capture) > CaptureSignalType;
  86
  87   /**
  88    * @brief Create an uninitialized Capture; this can be initialized with Actor::New().
  89    *
  90    * Calling member functions with an uninitialized Dali::Object is not allowed.
  91    */
  92   Capture();
  93
  94   /**
  95    * @brief Create an initialized Capture.
  96    *
  97    * @return A handle to a newly allocated Dali resource.
  98    */
  99   static Capture New();
 100
 101   /**
 102    * @brief Create an initialized Capture.
 103    *
 104    * @param[in] mode camera projection mode.
 105    * @return A handle to a newly allocated Dali resource.
 106    */
 107   static Capture New(Dali::Camera::ProjectionMode mode);
 108
 109   /**
 110    * @brief Downcast an Object handle to Capture handle.
 111    *
 112    * If handle points to a Capture object the downcast produces valid
 113    * handle. If not the returned handle is left uninitialized.
 114    *
 115    * @param[in] handle to An object.
 116    * @return handle to a Capture object or an uninitialized handle.
 117    */
 118   static Capture DownCast( BaseHandle handle );
 119
 120   /**
 121    * @brief Dali::Actor is intended as a base class.
 122    *
 123    * This is non-virtual since derived Handle types must not contain data or virtual methods.
 124    */
 125   ~Capture();
 126
 127   /**
 128    * @brief This copy constructor is required for (smart) pointer semantics.
 129    *
 130    * @param[in] copy A reference to the copied handle.
 131    */
 132   Capture(const Capture& copy);
 133
 134   /**
 135    * @brief This assignment operator is required for (smart) pointer semantics.
 136    *
 137    * @param[in] rhs  A reference to the copied handle.
 138    * @return A reference to this.
 139    */
 140   Capture& operator=(const Capture& rhs);
 141
 142   /**
 143    * @brief Start capture and save the image as a file.
 144    *
 145    * @param[in] source source actor to be used for capture.
 146    * @param[in] size captured size.
 147    * @param[in] path image file path to be saved as a file.
 148    * @param[in] clearColor background color of captured scene
 149    */
 150   void Start(Actor source, const Vector2& size, const std::string &path, const Vector4& clearColor = Dali::Color::TRANSPARENT );
 151
 152   /**
 153    * @brief Retrieve the capture finish status.
 154    *
 155    * @return Whether success or not.
 156    */
 157   FinishState GetFinishState();
 158
 159   /**
 160    * @brief Get finished signal.
 161    *
 162    * @return finished signal instance.
 163    */
 164   CaptureSignalType& FinishedSignal();
 165
 166 public: // Not intended for application developers
 167   /**
 168    * @brief This constructor is used by New() methods.
 169    *
 170    * @param[in] internal A pointer to a newly allocated Dali resource.
 171    */
 172   explicit DALI_INTERNAL Capture(Internal::Capture* internal);
 173 };
 174
 175 } // namespace Extension
 176
 177 } // namespace Dali
 178
 179 /**
 180  * @}
 181  */
 182
 183 #endif // __DALI_EXTENSION_CAPTURE_H__